parser: move node parsers into impl block

2 files changed, 406 insertions, 410 deletions

diff --git a/askama_parser/src/lib.rs b/askama_parser/src/lib.rs
index ab3eb83..cf105cb 100644
--- a/askama_parser/src/lib.rs
+++ b/askama_parser/src/lib.rs
@@ -8,7 +8,7 @@ use nom::branch::alt;
 use nom::bytes::complete::{escaped, is_not, tag, take_till};
 use nom::character::complete::char;
 use nom::character::complete::{anychar, digit1};
-use nom::combinator::{eof, map, not, opt, recognize, value};
+use nom::combinator::{map, opt, recognize, value};
 use nom::error::ErrorKind;
 use nom::multi::separated_list1;
 use nom::sequence::{delimited, pair, tuple};
@@ -63,7 +63,7 @@ pub struct Ast<'a> {
 
 impl<'a> Ast<'a> {
     pub fn from_str(src: &'a str, syntax: &Syntax<'_>) -> Result<Self, ParseError> {
-        let err = match Node::parse(src, &State::new(syntax)) {
+        let err = match Node::many(src, &State::new(syntax)) {
             Ok((left, nodes)) => match left.is_empty() {
                 true => return Ok(Self { nodes }),
                 false => return Err(ParseError(format!("unable to parse template:\n\n{left:?}"))),
@@ -246,26 +246,6 @@ impl<'a> State<'a> {
         }
     }
 
-    fn take_content<'i>(&self, i: &'i str) -> IResult<&'i str, Node<'i>> {
-        let p_start = alt((
-            tag(self.syntax.block_start),
-            tag(self.syntax.comment_start),
-            tag(self.syntax.expr_start),
-        ));
-
-        let (i, _) = not(eof)(i)?;
-        let (i, content) = opt(recognize(skip_till(p_start)))(i)?;
-        let (i, content) = match content {
-            Some("") => {
-                // {block,comment,expr}_start follows immediately.
-                return Err(nom::Err::Error(error_position!(i, ErrorKind::TakeUntil)));
-            }
-            Some(content) => (i, content),
-            None => ("", i), // there is no {block,comment,expr}_start: take everything
-        };
-        Ok((i, split_ws_parts(content)))
-    }
-
     fn tag_block_start<'i>(&self, i: &'i str) -> IResult<&'i str, &'i str> {
         tag(self.syntax.block_start)(i)
     }
diff --git a/askama_parser/src/node.rs b/askama_parser/src/node.rs
index 8d8173d..cd71efc 100644
--- a/askama_parser/src/node.rs
+++ b/askama_parser/src/node.rs
@@ -3,7 +3,7 @@ use std::str;
 use nom::branch::alt;
 use nom::bytes::complete::{tag, take_until};
 use nom::character::complete::char;
-use nom::combinator::{complete, consumed, cut, map, opt, peek, value};
+use nom::combinator::{complete, consumed, cut, eof, map, not, opt, peek, recognize, value};
 use nom::error::{Error, ErrorKind};
 use nom::multi::{fold_many0, many0, many1, separated_list0, separated_list1};
 use nom::sequence::{delimited, pair, preceded, terminated, tuple};
@@ -35,9 +35,405 @@ pub enum Node<'a> {
     Continue(Ws),
 }
 
-impl Node<'_> {
-    pub(super) fn parse<'i>(i: &'i str, s: &State<'_>) -> IResult<&'i str, Vec<Node<'i>>> {
-        parse_template(i, s)
+impl<'a> Node<'a> {
+    pub(super) fn many(i: &'a str, s: &State<'_>) -> IResult<&'a str, Vec<Self>> {
+        many0(alt((
+            complete(|i| Self::content(i, s)),
+            complete(|i| Self::comment(i, s)),
+            complete(|i| Self::expr(i, s)),
+            complete(|i| Self::parse(i, s)),
+        )))(i)
+    }
+
+    fn content(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let p_start = alt((
+            tag(s.syntax.block_start),
+            tag(s.syntax.comment_start),
+            tag(s.syntax.expr_start),
+        ));
+
+        let (i, _) = not(eof)(i)?;
+        let (i, content) = opt(recognize(skip_till(p_start)))(i)?;
+        let (i, content) = match content {
+            Some("") => {
+                // {block,comment,expr}_start follows immediately.
+                return Err(nom::Err::Error(error_position!(i, ErrorKind::TakeUntil)));
+            }
+            Some(content) => (i, content),
+            None => ("", i), // there is no {block,comment,expr}_start: take everything
+        };
+        Ok((i, split_ws_parts(content)))
+    }
+
+    fn parse(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            |i| s.tag_block_start(i),
+            alt((
+                Self::call,
+                Self::r#let,
+                |i| Self::r#if(i, s),
+                |i| Self::r#for(i, s),
+                |i| Self::r#match(i, s),
+                Self::extends,
+                Self::include,
+                Self::import,
+                |i| Self::block(i, s),
+                |i| Self::r#macro(i, s),
+                |i| Self::raw(i, s),
+                |i| Self::r#break(i, s),
+                |i| Self::r#continue(i, s),
+            )),
+            cut(|i| s.tag_block_end(i)),
+        ));
+        let (i, (_, contents, _)) = p(i)?;
+        Ok((i, contents))
+    }
+
+    fn call(i: &'a str) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("call")),
+            cut(tuple((
+                opt(tuple((ws(identifier), ws(tag("::"))))),
+                ws(identifier),
+                opt(ws(Expr::parse_arguments)),
+                opt(Whitespace::parse),
+            ))),
+        ));
+        let (i, (pws, _, (scope, name, args, nws))) = p(i)?;
+        let scope = scope.map(|(scope, _)| scope);
+        let args = args.unwrap_or_default();
+        Ok((i, Self::Call(Ws(pws, nws), scope, name, args)))
+    }
+
+    fn r#let(i: &'a str) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            ws(alt((keyword("let"), keyword("set")))),
+            cut(tuple((
+                ws(Target::parse),
+                opt(tuple((ws(char('=')), ws(Expr::parse)))),
+                opt(Whitespace::parse),
+            ))),
+        ));
+        let (i, (pws, _, (var, val, nws))) = p(i)?;
+
+        Ok((
+            i,
+            if let Some((_, val)) = val {
+                Self::Let(Ws(pws, nws), var, val)
+            } else {
+                Self::LetDecl(Ws(pws, nws), var)
+            },
+        ))
+    }
+
+    fn r#if(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            cond_if,
+            cut(tuple((
+                opt(Whitespace::parse),
+                |i| s.tag_block_end(i),
+                cut(tuple((
+                    |i| Node::many(i, s),
+                    many0(|i| cond_block(i, s)),
+                    cut(tuple((
+                        |i| s.tag_block_start(i),
+                        opt(Whitespace::parse),
+                        ws(keyword("endif")),
+                        opt(Whitespace::parse),
+                    ))),
+                ))),
+            ))),
+        ));
+        let (i, (pws1, cond, (nws1, _, (block, elifs, (_, pws2, _, nws2))))) = p(i)?;
+
+        let mut res = vec![(Ws(pws1, nws1), Some(cond), block)];
+        res.extend(elifs);
+        Ok((i, Self::Cond(res, Ws(pws2, nws2))))
+    }
+
+    fn r#for(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let if_cond = preceded(ws(keyword("if")), cut(ws(Expr::parse)));
+        let else_block = |i| {
+            let mut p = preceded(
+                ws(keyword("else")),
+                cut(tuple((
+                    opt(Whitespace::parse),
+                    delimited(
+                        |i| s.tag_block_end(i),
+                        |i| Self::many(i, s),
+                        |i| s.tag_block_start(i),
+                    ),
+                    opt(Whitespace::parse),
+                ))),
+            );
+            let (i, (pws, nodes, nws)) = p(i)?;
+            Ok((i, (pws, nodes, nws)))
+        };
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("for")),
+            cut(tuple((
+                ws(Target::parse),
+                ws(keyword("in")),
+                cut(tuple((
+                    ws(Expr::parse),
+                    opt(if_cond),
+                    opt(Whitespace::parse),
+                    |i| s.tag_block_end(i),
+                    cut(tuple((
+                        |i| parse_loop_content(i, s),
+                        cut(tuple((
+                            |i| s.tag_block_start(i),
+                            opt(Whitespace::parse),
+                            opt(else_block),
+                            ws(keyword("endfor")),
+                            opt(Whitespace::parse),
+                        ))),
+                    ))),
+                ))),
+            ))),
+        ));
+        let (i, (pws1, _, (var, _, (iter, cond, nws1, _, (body, (_, pws2, else_block, _, nws2)))))) =
+            p(i)?;
+        let (nws3, else_block, pws3) = else_block.unwrap_or_default();
+        Ok((
+            i,
+            Self::Loop(Loop {
+                ws1: Ws(pws1, nws1),
+                var,
+                iter,
+                cond,
+                body,
+                ws2: Ws(pws2, nws3),
+                else_block,
+                ws3: Ws(pws3, nws2),
+            }),
+        ))
+    }
+
+    fn r#match(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("match")),
+            cut(tuple((
+                ws(Expr::parse),
+                opt(Whitespace::parse),
+                |i| s.tag_block_end(i),
+                cut(tuple((
+                    ws(many0(ws(value((), |i| Self::comment(i, s))))),
+                    many1(|i| when_block(i, s)),
+                    cut(tuple((
+                        opt(|i| match_else_block(i, s)),
+                        cut(tuple((
+                            ws(|i| s.tag_block_start(i)),
+                            opt(Whitespace::parse),
+                            ws(keyword("endmatch")),
+                            opt(Whitespace::parse),
+                        ))),
+                    ))),
+                ))),
+            ))),
+        ));
+        let (i, (pws1, _, (expr, nws1, _, (_, arms, (else_arm, (_, pws2, _, nws2)))))) = p(i)?;
+
+        let mut arms = arms;
+        if let Some(arm) = else_arm {
+            arms.push(arm);
+        }
+
+        Ok((i, Self::Match(Ws(pws1, nws1), expr, arms, Ws(pws2, nws2))))
+    }
+
+    fn extends(i: &'a str) -> IResult<&'a str, Self> {
+        let (i, (_, name)) = tuple((ws(keyword("extends")), ws(str_lit)))(i)?;
+        Ok((i, Self::Extends(name)))
+    }
+
+    fn include(i: &'a str) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("include")),
+            cut(pair(ws(str_lit), opt(Whitespace::parse))),
+        ));
+        let (i, (pws, _, (name, nws))) = p(i)?;
+        Ok((i, Self::Include(Ws(pws, nws), name)))
+    }
+
+    fn block(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let mut start = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("block")),
+            cut(tuple((ws(identifier), opt(Whitespace::parse), |i| {
+                s.tag_block_end(i)
+            }))),
+        ));
+        let (i, (pws1, _, (name, nws1, _))) = start(i)?;
+
+        let mut end = cut(tuple((
+            |i| Self::many(i, s),
+            cut(tuple((
+                |i| s.tag_block_start(i),
+                opt(Whitespace::parse),
+                ws(keyword("endblock")),
+                cut(tuple((opt(ws(keyword(name))), opt(Whitespace::parse)))),
+            ))),
+        )));
+        let (i, (contents, (_, pws2, _, (_, nws2)))) = end(i)?;
+
+        Ok((
+            i,
+            Self::BlockDef(Ws(pws1, nws1), name, contents, Ws(pws2, nws2)),
+        ))
+    }
+
+    fn import(i: &'a str) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("import")),
+            cut(tuple((
+                ws(str_lit),
+                ws(keyword("as")),
+                cut(pair(ws(identifier), opt(Whitespace::parse))),
+            ))),
+        ));
+        let (i, (pws, _, (name, _, (scope, nws)))) = p(i)?;
+        Ok((i, Self::Import(Ws(pws, nws), name, scope)))
+    }
+
+    fn r#macro(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let mut start = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("macro")),
+            cut(tuple((
+                ws(identifier),
+                opt(ws(parameters)),
+                opt(Whitespace::parse),
+                |i| s.tag_block_end(i),
+            ))),
+        ));
+        let (i, (pws1, _, (name, params, nws1, _))) = start(i)?;
+
+        let mut end = cut(tuple((
+            |i| Self::many(i, s),
+            cut(tuple((
+                |i| s.tag_block_start(i),
+                opt(Whitespace::parse),
+                ws(keyword("endmacro")),
+                cut(tuple((opt(ws(keyword(name))), opt(Whitespace::parse)))),
+            ))),
+        )));
+        let (i, (contents, (_, pws2, _, (_, nws2)))) = end(i)?;
+
+        assert_ne!(name, "super", "invalid macro name 'super'");
+
+        let params = params.unwrap_or_default();
+
+        Ok((
+            i,
+            Self::Macro(
+                name,
+                Macro {
+                    ws1: Ws(pws1, nws1),
+                    args: params,
+                    nodes: contents,
+                    ws2: Ws(pws2, nws2),
+                },
+            ),
+        ))
+    }
+
+    fn raw(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let endraw = tuple((
+            |i| s.tag_block_start(i),
+            opt(Whitespace::parse),
+            ws(keyword("endraw")),
+            opt(Whitespace::parse),
+            peek(|i| s.tag_block_end(i)),
+        ));
+
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("raw")),
+            cut(tuple((
+                opt(Whitespace::parse),
+                |i| s.tag_block_end(i),
+                consumed(skip_till(endraw)),
+            ))),
+        ));
+
+        let (_, (pws1, _, (nws1, _, (contents, (i, (_, pws2, _, nws2, _)))))) = p(i)?;
+        let (lws, val, rws) = match split_ws_parts(contents) {
+            Node::Lit(lws, val, rws) => (lws, val, rws),
+            _ => unreachable!(),
+        };
+        let ws1 = Ws(pws1, nws1);
+        let ws2 = Ws(pws2, nws2);
+        Ok((i, Self::Raw(ws1, lws, val, rws, ws2)))
+    }
+
+    fn r#break(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("break")),
+            opt(Whitespace::parse),
+        ));
+        let (j, (pws, _, nws)) = p(i)?;
+        if !s.is_in_loop() {
+            return Err(nom::Err::Failure(error_position!(i, ErrorKind::Tag)));
+        }
+        Ok((j, Self::Break(Ws(pws, nws))))
+    }
+
+    fn r#continue(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("continue")),
+            opt(Whitespace::parse),
+        ));
+        let (j, (pws, _, nws)) = p(i)?;
+        if !s.is_in_loop() {
+            return Err(nom::Err::Failure(error_position!(i, ErrorKind::Tag)));
+        }
+        Ok((j, Self::Continue(Ws(pws, nws))))
+    }
+
+    fn expr(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            |i| s.tag_expr_start(i),
+            cut(tuple((
+                opt(Whitespace::parse),
+                ws(Expr::parse),
+                opt(Whitespace::parse),
+                |i| s.tag_expr_end(i),
+            ))),
+        ));
+        let (i, (_, (pws, expr, nws, _))) = p(i)?;
+        Ok((i, Self::Expr(Ws(pws, nws), expr)))
+    }
+
+    fn comment(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            |i| s.tag_comment_start(i),
+            cut(tuple((
+                opt(Whitespace::parse),
+                |i| block_comment_body(i, s),
+                |i| s.tag_comment_end(i),
+            ))),
+        ));
+        let (i, (_, (pws, tail, _))) = p(i)?;
+        let nws = if tail.ends_with('-') {
+            Some(Whitespace::Suppress)
+        } else if tail.ends_with('+') {
+            Some(Whitespace::Preserve)
+        } else if tail.ends_with('~') {
+            Some(Whitespace::Minimize)
+        } else {
+            None
+        };
+        Ok((i, Self::Comment(Ws(pws, nws))))
     }
 }
 
@@ -213,23 +609,6 @@ fn parameters(i: &str) -> IResult<&str, Vec<&str>> {
     )(i)
 }
 
-fn block_call(i: &str) -> IResult<&str, Node<'_>> {
-    let mut p = tuple((
-        opt(Whitespace::parse),
-        ws(keyword("call")),
-        cut(tuple((
-            opt(tuple((ws(identifier), ws(tag("::"))))),
-            ws(identifier),
-            opt(ws(Expr::parse_arguments)),
-            opt(Whitespace::parse),
-        ))),
-    ));
-    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)))
-}
-
 fn cond_if(i: &str) -> IResult<&str, CondTest<'_>> {
     let mut p = preceded(
         ws(keyword("if")),
@@ -255,39 +634,13 @@ fn cond_block<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Cond<'a>> {
             opt(cond_if),
             opt(Whitespace::parse),
             |i| s.tag_block_end(i),
-            cut(|i| parse_template(i, s)),
+            cut(|i| Node::many(i, s)),
         ))),
     ));
     let (i, (_, pws, _, (cond, nws, _, block))) = p(i)?;
     Ok((i, (Ws(pws, nws), cond, block)))
 }
 
-fn block_if<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let mut p = tuple((
-        opt(Whitespace::parse),
-        cond_if,
-        cut(tuple((
-            opt(Whitespace::parse),
-            |i| s.tag_block_end(i),
-            cut(tuple((
-                |i| parse_template(i, s),
-                many0(|i| cond_block(i, s)),
-                cut(tuple((
-                    |i| s.tag_block_start(i),
-                    opt(Whitespace::parse),
-                    ws(keyword("endif")),
-                    opt(Whitespace::parse),
-                ))),
-            ))),
-        ))),
-    ));
-    let (i, (pws1, cond, (nws1, _, (block, elifs, (_, pws2, _, nws2))))) = p(i)?;
-
-    let mut res = vec![(Ws(pws1, nws1), Some(cond), block)];
-    res.extend(elifs);
-    Ok((i, Node::Cond(res, Ws(pws2, nws2))))
-}
-
 fn match_else_block<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, When<'a>> {
     let mut p = tuple((
         |i| s.tag_block_start(i),
@@ -296,7 +649,7 @@ fn match_else_block<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, When<'a>>
         cut(tuple((
             opt(Whitespace::parse),
             |i| s.tag_block_end(i),
-            cut(|i| parse_template(i, s)),
+            cut(|i| Node::many(i, s)),
         ))),
     ));
     let (i, (_, pws, _, (nws, _, block))) = p(i)?;
@@ -312,312 +665,20 @@ fn when_block<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, When<'a>> {
             ws(Target::parse),
             opt(Whitespace::parse),
             |i| s.tag_block_end(i),
-            cut(|i| parse_template(i, s)),
+            cut(|i| Node::many(i, s)),
         ))),
     ));
     let (i, (_, pws, _, (target, nws, _, block))) = p(i)?;
     Ok((i, (Ws(pws, nws), target, block)))
 }
 
-fn block_match<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let mut p = tuple((
-        opt(Whitespace::parse),
-        ws(keyword("match")),
-        cut(tuple((
-            ws(Expr::parse),
-            opt(Whitespace::parse),
-            |i| s.tag_block_end(i),
-            cut(tuple((
-                ws(many0(ws(value((), |i| block_comment(i, s))))),
-                many1(|i| when_block(i, s)),
-                cut(tuple((
-                    opt(|i| match_else_block(i, s)),
-                    cut(tuple((
-                        ws(|i| s.tag_block_start(i)),
-                        opt(Whitespace::parse),
-                        ws(keyword("endmatch")),
-                        opt(Whitespace::parse),
-                    ))),
-                ))),
-            ))),
-        ))),
-    ));
-    let (i, (pws1, _, (expr, nws1, _, (_, arms, (else_arm, (_, pws2, _, nws2)))))) = p(i)?;
-
-    let mut arms = arms;
-    if let Some(arm) = else_arm {
-        arms.push(arm);
-    }
-
-    Ok((i, Node::Match(Ws(pws1, nws1), expr, arms, Ws(pws2, nws2))))
-}
-
-fn block_let(i: &str) -> IResult<&str, Node<'_>> {
-    let mut p = tuple((
-        opt(Whitespace::parse),
-        ws(alt((keyword("let"), keyword("set")))),
-        cut(tuple((
-            ws(Target::parse),
-            opt(tuple((ws(char('=')), ws(Expr::parse)))),
-            opt(Whitespace::parse),
-        ))),
-    ));
-    let (i, (pws, _, (var, val, nws))) = p(i)?;
-
-    Ok((
-        i,
-        if let Some((_, val)) = val {
-            Node::Let(Ws(pws, nws), var, val)
-        } else {
-            Node::LetDecl(Ws(pws, nws), var)
-        },
-    ))
-}
-
 fn parse_loop_content<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Vec<Node<'a>>> {
     s.enter_loop();
-    let result = parse_template(i, s);
+    let result = Node::many(i, s);
     s.leave_loop();
     result
 }
 
-fn block_for<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let if_cond = preceded(ws(keyword("if")), cut(ws(Expr::parse)));
-    let else_block = |i| {
-        let mut p = preceded(
-            ws(keyword("else")),
-            cut(tuple((
-                opt(Whitespace::parse),
-                delimited(
-                    |i| s.tag_block_end(i),
-                    |i| parse_template(i, s),
-                    |i| s.tag_block_start(i),
-                ),
-                opt(Whitespace::parse),
-            ))),
-        );
-        let (i, (pws, nodes, nws)) = p(i)?;
-        Ok((i, (pws, nodes, nws)))
-    };
-    let mut p = tuple((
-        opt(Whitespace::parse),
-        ws(keyword("for")),
-        cut(tuple((
-            ws(Target::parse),
-            ws(keyword("in")),
-            cut(tuple((
-                ws(Expr::parse),
-                opt(if_cond),
-                opt(Whitespace::parse),
-                |i| s.tag_block_end(i),
-                cut(tuple((
-                    |i| parse_loop_content(i, s),
-                    cut(tuple((
-                        |i| s.tag_block_start(i),
-                        opt(Whitespace::parse),
-                        opt(else_block),
-                        ws(keyword("endfor")),
-                        opt(Whitespace::parse),
-                    ))),
-                ))),
-            ))),
-        ))),
-    ));
-    let (i, (pws1, _, (var, _, (iter, cond, nws1, _, (body, (_, pws2, else_block, _, nws2)))))) =
-        p(i)?;
-    let (nws3, else_block, pws3) = else_block.unwrap_or_default();
-    Ok((
-        i,
-        Node::Loop(Loop {
-            ws1: Ws(pws1, nws1),
-            var,
-            iter,
-            cond,
-            body,
-            ws2: Ws(pws2, nws3),
-            else_block,
-            ws3: Ws(pws3, nws2),
-        }),
-    ))
-}
-
-fn block_extends(i: &str) -> IResult<&str, Node<'_>> {
-    let (i, (_, name)) = tuple((ws(keyword("extends")), ws(str_lit)))(i)?;
-    Ok((i, Node::Extends(name)))
-}
-
-fn block_block<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let mut start = tuple((
-        opt(Whitespace::parse),
-        ws(keyword("block")),
-        cut(tuple((ws(identifier), opt(Whitespace::parse), |i| {
-            s.tag_block_end(i)
-        }))),
-    ));
-    let (i, (pws1, _, (name, nws1, _))) = start(i)?;
-
-    let mut end = cut(tuple((
-        |i| parse_template(i, s),
-        cut(tuple((
-            |i| s.tag_block_start(i),
-            opt(Whitespace::parse),
-            ws(keyword("endblock")),
-            cut(tuple((opt(ws(keyword(name))), opt(Whitespace::parse)))),
-        ))),
-    )));
-    let (i, (contents, (_, pws2, _, (_, nws2)))) = end(i)?;
-
-    Ok((
-        i,
-        Node::BlockDef(Ws(pws1, nws1), name, contents, Ws(pws2, nws2)),
-    ))
-}
-
-fn block_include(i: &str) -> IResult<&str, Node<'_>> {
-    let mut p = tuple((
-        opt(Whitespace::parse),
-        ws(keyword("include")),
-        cut(pair(ws(str_lit), opt(Whitespace::parse))),
-    ));
-    let (i, (pws, _, (name, nws))) = p(i)?;
-    Ok((i, Node::Include(Ws(pws, nws), name)))
-}
-
-fn block_import(i: &str) -> IResult<&str, Node<'_>> {
-    let mut p = tuple((
-        opt(Whitespace::parse),
-        ws(keyword("import")),
-        cut(tuple((
-            ws(str_lit),
-            ws(keyword("as")),
-            cut(pair(ws(identifier), opt(Whitespace::parse))),
-        ))),
-    ));
-    let (i, (pws, _, (name, _, (scope, nws)))) = p(i)?;
-    Ok((i, Node::Import(Ws(pws, nws), name, scope)))
-}
-
-fn block_macro<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let mut start = tuple((
-        opt(Whitespace::parse),
-        ws(keyword("macro")),
-        cut(tuple((
-            ws(identifier),
-            opt(ws(parameters)),
-            opt(Whitespace::parse),
-            |i| s.tag_block_end(i),
-        ))),
-    ));
-    let (i, (pws1, _, (name, params, nws1, _))) = start(i)?;
-
-    let mut end = cut(tuple((
-        |i| parse_template(i, s),
-        cut(tuple((
-            |i| s.tag_block_start(i),
-            opt(Whitespace::parse),
-            ws(keyword("endmacro")),
-            cut(tuple((opt(ws(keyword(name))), opt(Whitespace::parse)))),
-        ))),
-    )));
-    let (i, (contents, (_, pws2, _, (_, nws2)))) = end(i)?;
-
-    assert_ne!(name, "super", "invalid macro name 'super'");
-
-    let params = params.unwrap_or_default();
-
-    Ok((
-        i,
-        Node::Macro(
-            name,
-            Macro {
-                ws1: Ws(pws1, nws1),
-                args: params,
-                nodes: contents,
-                ws2: Ws(pws2, nws2),
-            },
-        ),
-    ))
-}
-
-fn block_raw<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let endraw = tuple((
-        |i| s.tag_block_start(i),
-        opt(Whitespace::parse),
-        ws(keyword("endraw")),
-        opt(Whitespace::parse),
-        peek(|i| s.tag_block_end(i)),
-    ));
-
-    let mut p = tuple((
-        opt(Whitespace::parse),
-        ws(keyword("raw")),
-        cut(tuple((
-            opt(Whitespace::parse),
-            |i| s.tag_block_end(i),
-            consumed(skip_till(endraw)),
-        ))),
-    ));
-
-    let (_, (pws1, _, (nws1, _, (contents, (i, (_, pws2, _, nws2, _)))))) = p(i)?;
-    let (lws, val, rws) = match split_ws_parts(contents) {
-        Node::Lit(lws, val, rws) => (lws, val, rws),
-        _ => unreachable!(),
-    };
-    let ws1 = Ws(pws1, nws1);
-    let ws2 = Ws(pws2, nws2);
-    Ok((i, Node::Raw(ws1, lws, val, rws, ws2)))
-}
-
-fn break_statement<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let mut p = tuple((
-        opt(Whitespace::parse),
-        ws(keyword("break")),
-        opt(Whitespace::parse),
-    ));
-    let (j, (pws, _, nws)) = p(i)?;
-    if !s.is_in_loop() {
-        return Err(nom::Err::Failure(error_position!(i, ErrorKind::Tag)));
-    }
-    Ok((j, Node::Break(Ws(pws, nws))))
-}
-
-fn continue_statement<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let mut p = tuple((
-        opt(Whitespace::parse),
-        ws(keyword("continue")),
-        opt(Whitespace::parse),
-    ));
-    let (j, (pws, _, nws)) = p(i)?;
-    if !s.is_in_loop() {
-        return Err(nom::Err::Failure(error_position!(i, ErrorKind::Tag)));
-    }
-    Ok((j, Node::Continue(Ws(pws, nws))))
-}
-
-fn block_node<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let mut p = tuple((
-        |i| s.tag_block_start(i),
-        alt((
-            block_call,
-            block_let,
-            |i| block_if(i, s),
-            |i| block_for(i, s),
-            |i| block_match(i, s),
-            block_extends,
-            block_include,
-            block_import,
-            |i| block_block(i, s),
-            |i| block_macro(i, s),
-            |i| block_raw(i, s),
-            |i| break_statement(i, s),
-            |i| continue_statement(i, s),
-        )),
-        cut(|i| s.tag_block_end(i)),
-    ));
-    let (i, (_, contents, _)) = p(i)?;
-    Ok((i, contents))
-}
-
 fn block_comment_body<'a>(mut i: &'a str, s: &State<'_>) -> IResult<&'a str, &'a str> {
     let mut level = 0;
     loop {
@@ -635,48 +696,3 @@ fn block_comment_body<'a>(mut i: &'a str, s: &State<'_>) -> IResult<&'a str, &'a
         }
     }
 }
-
-fn block_comment<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let mut p = tuple((
-        |i| s.tag_comment_start(i),
-        cut(tuple((
-            opt(Whitespace::parse),
-            |i| block_comment_body(i, s),
-            |i| s.tag_comment_end(i),
-        ))),
-    ));
-    let (i, (_, (pws, tail, _))) = p(i)?;
-    let nws = if tail.ends_with('-') {
-        Some(Whitespace::Suppress)
-    } else if tail.ends_with('+') {
-        Some(Whitespace::Preserve)
-    } else if tail.ends_with('~') {
-        Some(Whitespace::Minimize)
-    } else {
-        None
-    };
-    Ok((i, Node::Comment(Ws(pws, nws))))
-}
-
-fn expr_node<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Node<'a>> {
-    let mut p = tuple((
-        |i| s.tag_expr_start(i),
-        cut(tuple((
-            opt(Whitespace::parse),
-            ws(Expr::parse),
-            opt(Whitespace::parse),
-            |i| s.tag_expr_end(i),
-        ))),
-    ));
-    let (i, (_, (pws, expr, nws, _))) = p(i)?;
-    Ok((i, Node::Expr(Ws(pws, nws), expr)))
-}
-
-fn parse_template<'a>(i: &'a str, s: &State<'_>) -> IResult<&'a str, Vec<Node<'a>>> {
-    many0(alt((
-        complete(|i| s.take_content(i)),
-        complete(|i| block_comment(i, s)),
-        complete(|i| expr_node(i, s)),
-        complete(|i| block_node(i, s)),
-    )))(i)
-}