aver-lang 0.27.0

#[allow(unused_imports)]
use crate::aver_generated::domain::ast::*;
#[allow(unused_imports)]
use crate::aver_generated::domain::parser_match::*;
#[allow(unused_imports)]
use crate::aver_generated::domain::token::*;
#[allow(unused_imports)]
use crate::*;

#[allow(non_camel_case_types)]
enum __MutualTco1 {
    ParseAddExprTail(aver_rt::AverList<Token>, aver_rt::AverInt, Expr),
    ParseAddExprRight(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        Expr,
        aver_rt::AverInt,
    ),
}

fn __mutual_tco_trampoline_1(
    mut __state: __MutualTco1,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco1::ParseAddExprTail(mut tokens, mut pos, mut left) => {
                crate::cancel_checkpoint();
                let nextPos = pos.add(&aver_rt::AverInt::from_i64(1));
                let t = crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone());
                match t {
                    crate::aver_generated::domain::token::Token::TkPlus => {
                        __MutualTco1::ParseAddExprRight(
                            tokens,
                            nextPos,
                            left,
                            aver_rt::AverInt::from_i64(0),
                        )
                    }
                    crate::aver_generated::domain::token::Token::TkMinus => {
                        __MutualTco1::ParseAddExprRight(
                            tokens,
                            nextPos,
                            left,
                            aver_rt::AverInt::from_i64(1),
                        )
                    }
                    _ => return Ok((left, pos)),
                }
            }
            __MutualTco1::ParseAddExprRight(mut tokens, mut pos, mut left, mut op) => {
                crate::cancel_checkpoint();
                let r = crate::aver_generated::domain::parser::expr::parseMulExpr(&tokens, pos)?;
                {
                    let (right, pos2) = r;
                    if (op == aver_rt::AverInt::from_i64(0)) {
                        __MutualTco1::ParseAddExprTail(
                            tokens,
                            pos2,
                            crate::aver_generated::domain::ast::Expr::ExprAdd(
                                std::sync::Arc::new(left),
                                std::sync::Arc::new(right),
                            ),
                        )
                    } else {
                        __MutualTco1::ParseAddExprTail(
                            tokens,
                            pos2,
                            crate::aver_generated::domain::ast::Expr::ExprSub(
                                std::sync::Arc::new(left),
                                std::sync::Arc::new(right),
                            ),
                        )
                    }
                }
            }
        };
    }
}

/// Continue parsing additive operators.
pub fn parseAddExprTail(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    left: &Expr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_1(__MutualTco1::ParseAddExprTail(
        tokens.clone(),
        pos,
        left.clone(),
    ))
}

/// Parse right side of additive op.
pub fn parseAddExprRight(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    left: &Expr,
    op: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_1(__MutualTco1::ParseAddExprRight(
        tokens.clone(),
        pos,
        left.clone(),
        op,
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco2 {
    ParseCallArgsList(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<Expr>,
    ),
    ParseCallArgsListTail(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<Expr>,
    ),
    ParseCallArgsAfterComma(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<Expr>,
    ),
    ParseCallArgsCheckNamed(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<Expr>,
        AverStr,
    ),
}

fn __mutual_tco_trampoline_2(
    mut __state: __MutualTco2,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco2::ParseCallArgsList(mut tokens, mut pos, mut name, mut acc) => {
                crate::cancel_checkpoint();
                let r = crate::aver_generated::domain::parser::expr::parseExpr(&tokens, pos)?;
                {
                    let (expr, pos2) = r;
                    __MutualTco2::ParseCallArgsListTail(
                        tokens,
                        pos2,
                        name,
                        aver_rt::AverList::prepend(expr, &acc),
                    )
                }
            }
            __MutualTco2::ParseCallArgsListTail(mut tokens, mut pos0, mut name, mut args) => {
                crate::cancel_checkpoint();
                let pos = crate::aver_generated::domain::parser::expr::skipNl(tokens.clone(), pos0);
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkComma => {
                        __MutualTco2::ParseCallArgsAfterComma(
                            tokens.clone(),
                            crate::aver_generated::domain::parser::expr::skipNl(
                                tokens,
                                pos.add(&aver_rt::AverInt::from_i64(1)),
                            ),
                            name,
                            args,
                        )
                    }
                    crate::aver_generated::domain::token::Token::TkRParen => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprCall(
                                name,
                                args.reverse(),
                            ),
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                        ));
                    }
                    _ => return Err(AverStr::from("Expected ',' or ')' in argument list")),
                }
            }
            __MutualTco2::ParseCallArgsAfterComma(mut tokens, mut pos, mut name, mut args) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkRParen => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprCall(
                                name,
                                args.reverse(),
                            ),
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                        ));
                    }
                    crate::aver_generated::domain::token::Token::TkIdent(field) => {
                        __MutualTco2::ParseCallArgsCheckNamed(tokens, pos, name, args, field)
                    }
                    _ => __MutualTco2::ParseCallArgsList(tokens, pos, name, args),
                }
            }
            __MutualTco2::ParseCallArgsCheckNamed(
                mut tokens,
                mut pos,
                mut name,
                mut args,
                mut field,
            ) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(
                    &tokens,
                    pos.add(&aver_rt::AverInt::from_i64(1)),
                ) {
                    crate::aver_generated::domain::token::Token::TkEq => {
                        return crate::aver_generated::domain::parser::expr::parseNamedArgs(
                            &tokens,
                            pos,
                            name,
                            &args,
                            &aver_rt::AverList::empty(),
                        );
                    }
                    _ => __MutualTco2::ParseCallArgsList(tokens, pos, name, args),
                }
            }
        };
    }
}

/// Parse comma-separated argument list.
pub fn parseCallArgsList(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
    acc: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_2(__MutualTco2::ParseCallArgsList(
        tokens.clone(),
        pos,
        name,
        acc.clone(),
    ))
}

/// After an argument: ',' for more or ')' to end. Detects named args (field = expr).
pub fn parseCallArgsListTail(
    tokens: &aver_rt::AverList<Token>,
    pos0: aver_rt::AverInt,
    name: AverStr,
    args: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_2(__MutualTco2::ParseCallArgsListTail(
        tokens.clone(),
        pos0,
        name,
        args.clone(),
    ))
}

/// After comma in call args: check if next is ident = (named arg) or regular expr.
pub fn parseCallArgsAfterComma(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
    args: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_2(__MutualTco2::ParseCallArgsAfterComma(
        tokens.clone(),
        pos,
        name,
        args.clone(),
    ))
}

/// Lookahead: if next token after ident is =, switch to named args mode.
pub fn parseCallArgsCheckNamed(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
    args: &aver_rt::AverList<Expr>,
    field: AverStr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_2(__MutualTco2::ParseCallArgsCheckNamed(
        tokens.clone(),
        pos,
        name,
        args.clone(),
        field,
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco3 {
    ParseFieldAccess(aver_rt::AverList<Token>, aver_rt::AverInt, Expr),
    ParseFieldAccessTail(aver_rt::AverList<Token>, aver_rt::AverInt, Expr),
}

fn __mutual_tco_trampoline_3(
    mut __state: __MutualTco3,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco3::ParseFieldAccess(mut tokens, mut pos, mut obj) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkIdent(field) => {
                        __MutualTco3::ParseFieldAccessTail(
                            tokens,
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                            crate::aver_generated::domain::ast::Expr::ExprFieldAccess(
                                std::sync::Arc::new(obj),
                                field,
                            ),
                        )
                    }
                    _ => return Err(AverStr::from("Expected field name after '.'")),
                }
            }
            __MutualTco3::ParseFieldAccessTail(mut tokens, mut pos, mut expr) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkDot => {
                        __MutualTco3::ParseFieldAccess(
                            tokens,
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                            expr,
                        )
                    }
                    _ => return Ok((expr, pos)),
                }
            }
        };
    }
}

/// Parse .field after an expression.
pub fn parseFieldAccess(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    obj: &Expr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_3(__MutualTco3::ParseFieldAccess(
        tokens.clone(),
        pos,
        obj.clone(),
    ))
}

/// Check for chained field access.
pub fn parseFieldAccessTail(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    expr: &Expr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_3(__MutualTco3::ParseFieldAccessTail(
        tokens.clone(),
        pos,
        expr.clone(),
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco4 {
    ParseInterpParts(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
    ParseInterpAfterExpr(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
    ParseInterpContinue(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
    ParseInterpAfterStr(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
}

fn __mutual_tco_trampoline_4(
    mut __state: __MutualTco4,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco4::ParseInterpParts(mut tokens, mut pos, mut acc) => {
                crate::cancel_checkpoint();
                let r = crate::aver_generated::domain::parser::expr::parseExpr(&tokens, pos)?;
                {
                    let (expr, pos2) = r;
                    __MutualTco4::ParseInterpAfterExpr(
                        tokens,
                        pos2,
                        aver_rt::AverList::prepend(expr, &acc),
                    )
                }
            }
            __MutualTco4::ParseInterpAfterExpr(mut tokens, mut pos, mut acc) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkInterpEnd => {
                        __MutualTco4::ParseInterpContinue(
                            tokens,
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                            acc,
                        )
                    }
                    _ => return Err(AverStr::from("Expected } in string interpolation")),
                }
            }
            __MutualTco4::ParseInterpContinue(mut tokens, mut pos, mut acc) => {
                crate::cancel_checkpoint();
                let nextPos = pos.add(&aver_rt::AverInt::from_i64(1));
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkStr(s) => {
                        __MutualTco4::ParseInterpAfterStr(
                            tokens,
                            nextPos,
                            aver_rt::AverList::prepend(
                                crate::aver_generated::domain::ast::Expr::ExprStr(s),
                                &acc,
                            ),
                        )
                    }
                    crate::aver_generated::domain::token::Token::TkInterpStart => {
                        __MutualTco4::ParseInterpParts(tokens, nextPos, acc)
                    }
                    _ => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprConcat(acc.reverse()),
                            pos,
                        ));
                    }
                }
            }
            __MutualTco4::ParseInterpAfterStr(mut tokens, mut pos, mut acc) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkInterpStart => {
                        __MutualTco4::ParseInterpParts(
                            tokens,
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                            acc,
                        )
                    }
                    _ => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprConcat(acc.reverse()),
                            pos,
                        ));
                    }
                }
            }
        };
    }
}

/// Parse interpolation parts: expressions between TkInterpStart/TkInterpEnd and TkStr segments.
pub fn parseInterpParts(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    acc: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_4(__MutualTco4::ParseInterpParts(
        tokens.clone(),
        pos,
        acc.clone(),
    ))
}

/// After interpolation expr: expect TkInterpEnd, then maybe more string.
pub fn parseInterpAfterExpr(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    acc: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_4(__MutualTco4::ParseInterpAfterExpr(
        tokens.clone(),
        pos,
        acc.clone(),
    ))
}

/// After }: next TkStr continues, or end of string.
pub fn parseInterpContinue(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    acc: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_4(__MutualTco4::ParseInterpContinue(
        tokens.clone(),
        pos,
        acc.clone(),
    ))
}

/// After string segment: more interpolation or end.
pub fn parseInterpAfterStr(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    acc: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_4(__MutualTco4::ParseInterpAfterStr(
        tokens.clone(),
        pos,
        acc.clone(),
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco5 {
    ParseListItems(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
    ParseListItemsTail(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
    ParseListAfterComma(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
}

fn __mutual_tco_trampoline_5(
    mut __state: __MutualTco5,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco5::ParseListItems(mut tokens, mut pos, mut acc) => {
                crate::cancel_checkpoint();
                let r = crate::aver_generated::domain::parser::expr::parseExpr(&tokens, pos)?;
                {
                    let (expr, pos2) = r;
                    __MutualTco5::ParseListItemsTail(
                        tokens,
                        pos2,
                        aver_rt::AverList::prepend(expr, &acc),
                    )
                }
            }
            __MutualTco5::ParseListItemsTail(mut tokens, mut pos0, mut items) => {
                crate::cancel_checkpoint();
                let pos = crate::aver_generated::domain::parser::expr::skipNl(tokens.clone(), pos0);
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkComma => {
                        __MutualTco5::ParseListAfterComma(
                            tokens.clone(),
                            crate::aver_generated::domain::parser::expr::skipNl(
                                tokens,
                                pos.add(&aver_rt::AverInt::from_i64(1)),
                            ),
                            items,
                        )
                    }
                    crate::aver_generated::domain::token::Token::TkRBracket => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprList(items.reverse()),
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                        ));
                    }
                    _ => return Err(AverStr::from("Expected ',' or ']' in list literal")),
                }
            }
            __MutualTco5::ParseListAfterComma(mut tokens, mut pos, mut items) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkRBracket => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprList(items),
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                        ));
                    }
                    _ => __MutualTco5::ParseListItems(tokens, pos, items),
                }
            }
        };
    }
}

/// Parse comma-separated list items.
pub fn parseListItems(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    acc: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_5(__MutualTco5::ParseListItems(
        tokens.clone(),
        pos,
        acc.clone(),
    ))
}

/// After a list item: ',' for more or ']' to end.
pub fn parseListItemsTail(
    tokens: &aver_rt::AverList<Token>,
    pos0: aver_rt::AverInt,
    items: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_5(__MutualTco5::ParseListItemsTail(
        tokens.clone(),
        pos0,
        items.clone(),
    ))
}

/// Allow a trailing comma before ']' in list literals.
pub fn parseListAfterComma(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    items: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_5(__MutualTco5::ParseListAfterComma(
        tokens.clone(),
        pos,
        items.clone(),
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco6 {
    ParseMapEntries(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
    ParseMapAfterKey(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
        Expr,
    ),
    ParseMapEntryTail(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
}

fn __mutual_tco_trampoline_6(
    mut __state: __MutualTco6,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco6::ParseMapEntries(mut tokens, mut pos, mut acc) => {
                crate::cancel_checkpoint();
                let kr = crate::aver_generated::domain::parser::expr::parseExpr(&tokens, pos)?;
                {
                    let (keyExpr, pos2) = kr;
                    __MutualTco6::ParseMapAfterKey(tokens, pos2, acc, keyExpr)
                }
            }
            __MutualTco6::ParseMapAfterKey(mut tokens, mut pos, mut acc, mut keyExpr) => {
                crate::cancel_checkpoint();
                let pos2 = crate::aver_generated::domain::parser_match::expect(
                    &tokens,
                    pos,
                    &crate::aver_generated::domain::token::Token::TkFatArrow,
                )?;
                let vr = crate::aver_generated::domain::parser::expr::parseExpr(&tokens, pos2)?;
                {
                    let (valExpr, pos3) = vr;
                    __MutualTco6::ParseMapEntryTail(
                        tokens,
                        pos3,
                        aver_rt::AverList::prepend(
                            crate::aver_generated::domain::ast::Expr::ExprTuple(
                                aver_rt::AverList::from_vec(vec![keyExpr, valExpr]),
                            ),
                            &acc,
                        ),
                    )
                }
            }
            __MutualTco6::ParseMapEntryTail(mut tokens, mut pos, mut acc) => {
                crate::cancel_checkpoint();
                let pos2 = crate::aver_generated::domain::parser::expr::skipNl(tokens.clone(), pos);
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos2.clone()) {
                    crate::aver_generated::domain::token::Token::TkComma => {
                        __MutualTco6::ParseMapEntries(
                            tokens.clone(),
                            crate::aver_generated::domain::parser::expr::skipNl(
                                tokens,
                                pos2.add(&aver_rt::AverInt::from_i64(1)),
                            ),
                            acc,
                        )
                    }
                    crate::aver_generated::domain::token::Token::TkRBrace => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprCall(
                                AverStr::from("Map.fromList"),
                                aver_rt::AverList::from_vec(vec![
                                    crate::aver_generated::domain::ast::Expr::ExprList(
                                        acc.reverse(),
                                    ),
                                ]),
                            ),
                            pos2.add(&aver_rt::AverInt::from_i64(1)),
                        ));
                    }
                    _ => return Err(AverStr::from("Expected ',' or '}' in map literal")),
                }
            }
        };
    }
}

/// Parse key => value pairs.
pub fn parseMapEntries(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    acc: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_6(__MutualTco6::ParseMapEntries(
        tokens.clone(),
        pos,
        acc.clone(),
    ))
}

/// After key, expect => then value.
pub fn parseMapAfterKey(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    acc: &aver_rt::AverList<Expr>,
    keyExpr: &Expr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_6(__MutualTco6::ParseMapAfterKey(
        tokens.clone(),
        pos,
        acc.clone(),
        keyExpr.clone(),
    ))
}

/// After entry: , for more or } to end.
pub fn parseMapEntryTail(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    acc: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_6(__MutualTco6::ParseMapEntryTail(
        tokens.clone(),
        pos,
        acc.clone(),
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco7 {
    ParseMatchArms(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        Expr,
        aver_rt::AverList<MatchArm>,
    ),
    ParseOneArm(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        Expr,
        aver_rt::AverList<MatchArm>,
    ),
    ParseOneArmBody(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        Expr,
        aver_rt::AverList<MatchArm>,
        Pattern,
    ),
}

fn __mutual_tco_trampoline_7(
    mut __state: __MutualTco7,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco7::ParseMatchArms(mut tokens, mut pos, mut subject, mut acc) => {
                crate::cancel_checkpoint();
                let pos2 =
                    crate::aver_generated::domain::parser_match::skipNewlines(tokens.clone(), pos);
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos2.clone()) {
                    crate::aver_generated::domain::token::Token::TkDedent => {
                        let __list_subject = acc.clone();
                        if __list_subject.is_empty() {
                            return Err(AverStr::from("Expected at least one match arm"));
                        } else {
                            return Ok((
                                crate::aver_generated::domain::ast::Expr::ExprMatch(
                                    std::sync::Arc::new(subject),
                                    acc.reverse(),
                                ),
                                pos2.add(&aver_rt::AverInt::from_i64(1)),
                            ));
                        }
                    }
                    crate::aver_generated::domain::token::Token::TkEof => {
                        let __list_subject = acc.clone();
                        if __list_subject.is_empty() {
                            return Err(AverStr::from("Expected at least one match arm"));
                        } else {
                            return Ok((
                                crate::aver_generated::domain::ast::Expr::ExprMatch(
                                    std::sync::Arc::new(subject),
                                    acc.reverse(),
                                ),
                                pos2,
                            ));
                        }
                    }
                    _ => __MutualTco7::ParseOneArm(tokens, pos2, subject, acc),
                }
            }
            __MutualTco7::ParseOneArm(mut tokens, mut pos, mut subject, mut acc) => {
                crate::cancel_checkpoint();
                let pr = crate::aver_generated::domain::parser_match::parsePattern(&tokens, pos)?;
                {
                    let (pat, pos2) = pr;
                    __MutualTco7::ParseOneArmBody(tokens, pos2, subject, acc, pat)
                }
            }
            __MutualTco7::ParseOneArmBody(mut tokens, mut pos, mut subject, mut acc, mut pat) => {
                crate::cancel_checkpoint();
                let pos2 = crate::aver_generated::domain::parser_match::expect(
                    &tokens,
                    pos,
                    &crate::aver_generated::domain::token::Token::TkArrow,
                )?;
                let er = crate::aver_generated::domain::parser::expr::parseExpr(&tokens, pos2)?;
                {
                    let (body, pos3) = er;
                    __MutualTco7::ParseMatchArms(
                        tokens.clone(),
                        crate::aver_generated::domain::parser_match::skipNewlines(tokens, pos3),
                        subject,
                        aver_rt::AverList::prepend(
                            crate::aver_generated::domain::ast::MatchArm {
                                pattern: pat,
                                body: body,
                                bindingSlots: HashMap::new(),
                            },
                            &acc,
                        ),
                    )
                }
            }
        };
    }
}

/// Parse match arms until DEDENT.
pub fn parseMatchArms(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    subject: &Expr,
    acc: &aver_rt::AverList<MatchArm>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_7(__MutualTco7::ParseMatchArms(
        tokens.clone(),
        pos,
        subject.clone(),
        acc.clone(),
    ))
}

/// Parse one match arm: pattern '->' expr NEWLINE
pub fn parseOneArm(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    subject: &Expr,
    acc: &aver_rt::AverList<MatchArm>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_7(__MutualTco7::ParseOneArm(
        tokens.clone(),
        pos,
        subject.clone(),
        acc.clone(),
    ))
}

/// Parse arrow and body of a match arm.
pub fn parseOneArmBody(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    subject: &Expr,
    acc: &aver_rt::AverList<MatchArm>,
    pat: &Pattern,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_7(__MutualTco7::ParseOneArmBody(
        tokens.clone(),
        pos,
        subject.clone(),
        acc.clone(),
        pat.clone(),
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco8 {
    ParseMatchArmsFlat(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        Expr,
        aver_rt::AverList<MatchArm>,
    ),
    ParseOneArmFlat(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        Expr,
        aver_rt::AverList<MatchArm>,
    ),
    ParseOneArmFlatBody(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        Expr,
        aver_rt::AverList<MatchArm>,
        Pattern,
    ),
}

fn __mutual_tco_trampoline_8(
    mut __state: __MutualTco8,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco8::ParseMatchArmsFlat(mut tokens, mut pos, mut subject, mut acc) => {
                crate::cancel_checkpoint();
                if crate::aver_generated::domain::parser_match::isArmStart(&tokens, pos.clone()) {
                    __MutualTco8::ParseOneArmFlat(tokens, pos, subject, acc)
                } else {
                    {
                        let __list_subject = acc.clone();
                        if __list_subject.is_empty() {
                            return Err(AverStr::from("Expected at least one match arm"));
                        } else {
                            return Ok((
                                crate::aver_generated::domain::ast::Expr::ExprMatch(
                                    std::sync::Arc::new(subject),
                                    acc.reverse(),
                                ),
                                pos,
                            ));
                        }
                    }
                }
            }
            __MutualTco8::ParseOneArmFlat(mut tokens, mut pos, mut subject, mut acc) => {
                crate::cancel_checkpoint();
                let pr = crate::aver_generated::domain::parser_match::parsePattern(&tokens, pos)?;
                {
                    let (pat, pos2) = pr;
                    __MutualTco8::ParseOneArmFlatBody(tokens, pos2, subject, acc, pat)
                }
            }
            __MutualTco8::ParseOneArmFlatBody(
                mut tokens,
                mut pos,
                mut subject,
                mut acc,
                mut pat,
            ) => {
                crate::cancel_checkpoint();
                let pos2 = crate::aver_generated::domain::parser_match::expect(
                    &tokens,
                    pos,
                    &crate::aver_generated::domain::token::Token::TkArrow,
                )?;
                let er = crate::aver_generated::domain::parser::expr::parseExpr(&tokens, pos2)?;
                {
                    let (body, pos3) = er;
                    __MutualTco8::ParseMatchArmsFlat(
                        tokens.clone(),
                        crate::aver_generated::domain::parser_match::skipNewlines(tokens, pos3),
                        subject,
                        aver_rt::AverList::prepend(
                            crate::aver_generated::domain::ast::MatchArm {
                                pattern: pat,
                                body: body,
                                bindingSlots: HashMap::new(),
                            },
                            &acc,
                        ),
                    )
                }
            }
        };
    }
}

/// Parse match arms without INDENT/DEDENT (fallback for flat token streams).
pub fn parseMatchArmsFlat(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    subject: &Expr,
    acc: &aver_rt::AverList<MatchArm>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_8(__MutualTco8::ParseMatchArmsFlat(
        tokens.clone(),
        pos,
        subject.clone(),
        acc.clone(),
    ))
}

/// Parse one arm and continue in flat mode.
pub fn parseOneArmFlat(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    subject: &Expr,
    acc: &aver_rt::AverList<MatchArm>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_8(__MutualTco8::ParseOneArmFlat(
        tokens.clone(),
        pos,
        subject.clone(),
        acc.clone(),
    ))
}

/// Parse arrow and body, then continue flat.
pub fn parseOneArmFlatBody(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    subject: &Expr,
    acc: &aver_rt::AverList<MatchArm>,
    pat: &Pattern,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_8(__MutualTco8::ParseOneArmFlatBody(
        tokens.clone(),
        pos,
        subject.clone(),
        acc.clone(),
        pat.clone(),
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco9 {
    ParseMulExprTail(aver_rt::AverList<Token>, aver_rt::AverInt, Expr),
    ParseMulExprRight(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        Expr,
        aver_rt::AverInt,
    ),
}

fn __mutual_tco_trampoline_9(
    mut __state: __MutualTco9,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco9::ParseMulExprTail(mut tokens, mut pos, mut left) => {
                crate::cancel_checkpoint();
                let nextPos = pos.add(&aver_rt::AverInt::from_i64(1));
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkStar => {
                        __MutualTco9::ParseMulExprRight(
                            tokens,
                            nextPos,
                            left,
                            aver_rt::AverInt::from_i64(0),
                        )
                    }
                    crate::aver_generated::domain::token::Token::TkSlash => {
                        __MutualTco9::ParseMulExprRight(
                            tokens,
                            nextPos,
                            left,
                            aver_rt::AverInt::from_i64(1),
                        )
                    }
                    _ => return Ok((left, pos)),
                }
            }
            __MutualTco9::ParseMulExprRight(mut tokens, mut pos, mut left, mut op) => {
                crate::cancel_checkpoint();
                let r = crate::aver_generated::domain::parser::expr::parseAtom(&tokens, pos)?;
                {
                    let (right, pos2) = r;
                    if (op == aver_rt::AverInt::from_i64(0)) {
                        __MutualTco9::ParseMulExprTail(
                            tokens,
                            pos2,
                            crate::aver_generated::domain::ast::Expr::ExprMul(
                                std::sync::Arc::new(left),
                                std::sync::Arc::new(right),
                            ),
                        )
                    } else {
                        __MutualTco9::ParseMulExprTail(
                            tokens,
                            pos2,
                            crate::aver_generated::domain::ast::Expr::ExprDiv(
                                std::sync::Arc::new(left),
                                std::sync::Arc::new(right),
                            ),
                        )
                    }
                }
            }
        };
    }
}

/// Continue parsing multiplicative operators.
pub fn parseMulExprTail(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    left: &Expr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_9(__MutualTco9::ParseMulExprTail(
        tokens.clone(),
        pos,
        left.clone(),
    ))
}

/// Parse right side of mul/div op.
pub fn parseMulExprRight(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    left: &Expr,
    op: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_9(__MutualTco9::ParseMulExprRight(
        tokens.clone(),
        pos,
        left.clone(),
        op,
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco10 {
    ParseNamedArgs(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<Expr>,
        aver_rt::AverList<(AverStr, Expr)>,
    ),
    ParseNamedArgField(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<Expr>,
        aver_rt::AverList<(AverStr, Expr)>,
        AverStr,
    ),
    ParseNamedArgsTail(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<Expr>,
        aver_rt::AverList<(AverStr, Expr)>,
    ),
}

fn __mutual_tco_trampoline_10(
    mut __state: __MutualTco10,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco10::ParseNamedArgs(
                mut tokens,
                mut pos,
                mut name,
                mut positionalArgs,
                mut namedAcc,
            ) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkIdent(field) => {
                        __MutualTco10::ParseNamedArgField(
                            tokens,
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                            name,
                            positionalArgs,
                            namedAcc,
                            field,
                        )
                    }
                    crate::aver_generated::domain::token::Token::TkRParen => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprCall(
                                name,
                                aver_rt::AverList::concat(
                                    &positionalArgs.reverse(),
                                    &aver_rt::AverList::from_vec(vec![
                                        crate::aver_generated::domain::ast::Expr::ExprRecord(
                                            AverStr::from("_named"),
                                            namedAcc.reverse(),
                                        ),
                                    ]),
                                ),
                            ),
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                        ));
                    }
                    _ => {
                        return Err(AverStr::from(
                            "Expected field name or ')' in named arguments",
                        ));
                    }
                }
            }
            __MutualTco10::ParseNamedArgField(
                mut tokens,
                mut pos,
                mut name,
                mut positionalArgs,
                mut namedAcc,
                mut field,
            ) => {
                crate::cancel_checkpoint();
                let pos2 = crate::aver_generated::domain::parser_match::expect(
                    &tokens,
                    pos,
                    &crate::aver_generated::domain::token::Token::TkEq,
                )?;
                let r = crate::aver_generated::domain::parser::expr::parseExpr(&tokens, pos2)?;
                {
                    let (expr, pos3) = r;
                    __MutualTco10::ParseNamedArgsTail(
                        tokens,
                        pos3,
                        name,
                        positionalArgs,
                        aver_rt::AverList::prepend((field, expr), &namedAcc),
                    )
                }
            }
            __MutualTco10::ParseNamedArgsTail(
                mut tokens,
                mut pos0,
                mut name,
                mut positionalArgs,
                mut namedAcc,
            ) => {
                crate::cancel_checkpoint();
                let pos = crate::aver_generated::domain::parser::expr::skipNl(tokens.clone(), pos0);
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkComma => {
                        __MutualTco10::ParseNamedArgs(
                            tokens.clone(),
                            crate::aver_generated::domain::parser::expr::skipNl(
                                tokens,
                                pos.add(&aver_rt::AverInt::from_i64(1)),
                            ),
                            name,
                            positionalArgs,
                            namedAcc,
                        )
                    }
                    crate::aver_generated::domain::token::Token::TkRParen => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprCall(
                                name,
                                aver_rt::AverList::concat(
                                    &positionalArgs.reverse(),
                                    &aver_rt::AverList::from_vec(vec![
                                        crate::aver_generated::domain::ast::Expr::ExprRecord(
                                            AverStr::from("_named"),
                                            namedAcc.reverse(),
                                        ),
                                    ]),
                                ),
                            ),
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                        ));
                    }
                    _ => return Err(AverStr::from("Expected ',' or ')' in named arguments")),
                }
            }
        };
    }
}

/// Parse field = expr pairs for named/record-update args.
pub fn parseNamedArgs(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
    positionalArgs: &aver_rt::AverList<Expr>,
    namedAcc: &aver_rt::AverList<(AverStr, Expr)>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_10(__MutualTco10::ParseNamedArgs(
        tokens.clone(),
        pos,
        name,
        positionalArgs.clone(),
        namedAcc.clone(),
    ))
}

/// Parse = expr after field name in named args.
pub fn parseNamedArgField(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
    positionalArgs: &aver_rt::AverList<Expr>,
    namedAcc: &aver_rt::AverList<(AverStr, Expr)>,
    field: AverStr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_10(__MutualTco10::ParseNamedArgField(
        tokens.clone(),
        pos,
        name,
        positionalArgs.clone(),
        namedAcc.clone(),
        field,
    ))
}

/// After named arg: ',' for more or ')' to end.
pub fn parseNamedArgsTail(
    tokens: &aver_rt::AverList<Token>,
    pos0: aver_rt::AverInt,
    name: AverStr,
    positionalArgs: &aver_rt::AverList<Expr>,
    namedAcc: &aver_rt::AverList<(AverStr, Expr)>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_10(__MutualTco10::ParseNamedArgsTail(
        tokens.clone(),
        pos0,
        name,
        positionalArgs.clone(),
        namedAcc.clone(),
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco11 {
    ParseRecordFields(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<(AverStr, Expr)>,
    ),
    ParseRecordField(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<(AverStr, Expr)>,
        AverStr,
    ),
    ParseRecordFieldsTail(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<(AverStr, Expr)>,
    ),
    ParseRecordAfterComma(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        AverStr,
        aver_rt::AverList<(AverStr, Expr)>,
    ),
}

fn __mutual_tco_trampoline_11(
    mut __state: __MutualTco11,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco11::ParseRecordFields(mut tokens, mut pos, mut name, mut acc) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkIdent(field) => {
                        __MutualTco11::ParseRecordField(
                            tokens,
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                            name,
                            acc,
                            field,
                        )
                    }
                    _ => return Err(AverStr::from("Expected field name in record constructor")),
                }
            }
            __MutualTco11::ParseRecordField(mut tokens, mut pos, mut name, mut acc, mut field) => {
                crate::cancel_checkpoint();
                let pos2 = crate::aver_generated::domain::parser_match::expect(
                    &tokens,
                    pos,
                    &crate::aver_generated::domain::token::Token::TkEq,
                )?;
                let r = crate::aver_generated::domain::parser::expr::parseExpr(&tokens, pos2)?;
                {
                    let (expr, pos3) = r;
                    __MutualTco11::ParseRecordFieldsTail(
                        tokens,
                        pos3,
                        name,
                        aver_rt::AverList::prepend((field, expr), &acc),
                    )
                }
            }
            __MutualTco11::ParseRecordFieldsTail(mut tokens, mut pos, mut name, mut fields) => {
                crate::cancel_checkpoint();
                let pos2 = crate::aver_generated::domain::parser::expr::skipNl(tokens.clone(), pos);
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos2.clone()) {
                    crate::aver_generated::domain::token::Token::TkComma => {
                        __MutualTco11::ParseRecordAfterComma(
                            tokens.clone(),
                            crate::aver_generated::domain::parser::expr::skipNl(
                                tokens,
                                pos2.add(&aver_rt::AverInt::from_i64(1)),
                            ),
                            name,
                            fields,
                        )
                    }
                    crate::aver_generated::domain::token::Token::TkRParen => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprRecord(
                                name,
                                fields.reverse(),
                            ),
                            pos2.add(&aver_rt::AverInt::from_i64(1)),
                        ));
                    }
                    _ => return Err(AverStr::from("Expected ',' or ')' in record constructor")),
                }
            }
            __MutualTco11::ParseRecordAfterComma(mut tokens, mut pos, mut name, mut fields) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkRParen => {
                        return Ok((
                            crate::aver_generated::domain::ast::Expr::ExprRecord(name, fields),
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                        ));
                    }
                    _ => __MutualTco11::ParseRecordFields(tokens, pos, name, fields),
                }
            }
        };
    }
}

/// Parse record fields: field = expr, ...
pub fn parseRecordFields(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
    acc: &aver_rt::AverList<(AverStr, Expr)>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_11(__MutualTco11::ParseRecordFields(
        tokens.clone(),
        pos,
        name,
        acc.clone(),
    ))
}

/// Parse = expr after field name.
pub fn parseRecordField(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
    acc: &aver_rt::AverList<(AverStr, Expr)>,
    field: AverStr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_11(__MutualTco11::ParseRecordField(
        tokens.clone(),
        pos,
        name,
        acc.clone(),
        field,
    ))
}

/// After a field: ',' for more or ')' to end.
pub fn parseRecordFieldsTail(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
    fields: &aver_rt::AverList<(AverStr, Expr)>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_11(__MutualTco11::ParseRecordFieldsTail(
        tokens.clone(),
        pos,
        name,
        fields.clone(),
    ))
}

/// Allow a trailing comma before ')' in record constructors.
pub fn parseRecordAfterComma(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
    fields: &aver_rt::AverList<(AverStr, Expr)>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_11(__MutualTco11::ParseRecordAfterComma(
        tokens.clone(),
        pos,
        name,
        fields.clone(),
    ))
}

#[allow(non_camel_case_types)]
enum __MutualTco12 {
    ParseTupleRest(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
    ParseTupleRestTail(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
    ParseTupleAfterComma(
        aver_rt::AverList<Token>,
        aver_rt::AverInt,
        aver_rt::AverList<Expr>,
    ),
}

fn __mutual_tco_trampoline_12(
    mut __state: __MutualTco12,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    loop {
        __state = match __state {
            __MutualTco12::ParseTupleRest(mut tokens, mut pos, mut acc) => {
                crate::cancel_checkpoint();
                let r = crate::aver_generated::domain::parser::expr::parseExpr(&tokens, pos)?;
                {
                    let (expr, pos2) = r;
                    __MutualTco12::ParseTupleRestTail(
                        tokens,
                        pos2,
                        aver_rt::AverList::prepend(expr, &acc),
                    )
                }
            }
            __MutualTco12::ParseTupleRestTail(mut tokens, mut pos0, mut items) => {
                crate::cancel_checkpoint();
                let pos = crate::aver_generated::domain::parser::expr::skipNl(tokens.clone(), pos0);
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkComma => {
                        __MutualTco12::ParseTupleAfterComma(
                            tokens.clone(),
                            crate::aver_generated::domain::parser::expr::skipNl(
                                tokens,
                                pos.add(&aver_rt::AverInt::from_i64(1)),
                            ),
                            items,
                        )
                    }
                    crate::aver_generated::domain::token::Token::TkRParen => {
                        return crate::aver_generated::domain::parser::expr::finishTupleOrProduct(
                            &tokens,
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                            &items.reverse(),
                        );
                    }
                    _ => return Err(AverStr::from("Expected ')' or ',' in tuple")),
                }
            }
            __MutualTco12::ParseTupleAfterComma(mut tokens, mut pos, mut items) => {
                crate::cancel_checkpoint();
                match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
                    crate::aver_generated::domain::token::Token::TkRParen => {
                        return crate::aver_generated::domain::parser::expr::finishTupleOrProduct(
                            &tokens,
                            pos.add(&aver_rt::AverInt::from_i64(1)),
                            &items,
                        );
                    }
                    _ => __MutualTco12::ParseTupleRest(tokens, pos, items),
                }
            }
        };
    }
}

/// Parse remaining tuple elements after first comma.
pub fn parseTupleRest(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    acc: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_12(__MutualTco12::ParseTupleRest(
        tokens.clone(),
        pos,
        acc.clone(),
    ))
}

/// After tuple element: ',' for more or ')' to end.
pub fn parseTupleRestTail(
    tokens: &aver_rt::AverList<Token>,
    pos0: aver_rt::AverInt,
    items: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_12(__MutualTco12::ParseTupleRestTail(
        tokens.clone(),
        pos0,
        items.clone(),
    ))
}

/// Allow a trailing comma before ')' in tuples.
pub fn parseTupleAfterComma(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    items: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    __mutual_tco_trampoline_12(__MutualTco12::ParseTupleAfterComma(
        tokens.clone(),
        pos,
        items.clone(),
    ))
}

/// Parse an expression: comparison level, then optional ? postfix.
pub fn parseExpr(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let r = crate::aver_generated::domain::parser::expr::parseCmpExpr(tokens, pos)?;
    {
        let (expr, pos2) = r;
        Ok(crate::aver_generated::domain::parser::expr::parsePostfixQuestion(tokens, pos2, &expr))
    }
}

/// Check for postfix ? (error propagation).
pub fn parsePostfixQuestion(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    expr: &Expr,
) -> (Expr, aver_rt::AverInt) {
    crate::cancel_checkpoint();
    match crate::aver_generated::domain::parser_match::tokenAt(tokens, pos.clone()) {
        crate::aver_generated::domain::token::Token::TkQuestion => (
            crate::aver_generated::domain::ast::Expr::ExprPropagate(std::sync::Arc::new(
                expr.clone(),
            )),
            pos.add(&aver_rt::AverInt::from_i64(1)),
        ),
        _ => (expr.clone(), pos),
    }
}

/// Parse comparison: addExpr (('==' | '<' | '>') addExpr)?
pub fn parseCmpExpr(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let r = crate::aver_generated::domain::parser::expr::parseAddExpr(tokens, pos)?;
    {
        let (left, pos2) = r;
        crate::aver_generated::domain::parser::expr::parseCmpExprTail(tokens, pos2, &left)
    }
}

/// Check for comparison operator.
pub fn parseCmpExprTail(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    left: &Expr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let nextPos = pos.add(&aver_rt::AverInt::from_i64(1));
    match crate::aver_generated::domain::parser_match::tokenAt(tokens, pos.clone()) {
        crate::aver_generated::domain::token::Token::TkEqEq => {
            crate::aver_generated::domain::parser::expr::parseCmpExprRight(
                tokens,
                nextPos,
                left,
                aver_rt::AverInt::from_i64(0),
            )
        }
        crate::aver_generated::domain::token::Token::TkNeq => {
            crate::aver_generated::domain::parser::expr::parseCmpExprRight(
                tokens,
                nextPos,
                left,
                aver_rt::AverInt::from_i64(1),
            )
        }
        crate::aver_generated::domain::token::Token::TkLt => {
            crate::aver_generated::domain::parser::expr::parseCmpExprRight(
                tokens,
                nextPos,
                left,
                aver_rt::AverInt::from_i64(2),
            )
        }
        crate::aver_generated::domain::token::Token::TkGt => {
            crate::aver_generated::domain::parser::expr::parseCmpExprRight(
                tokens,
                nextPos,
                left,
                aver_rt::AverInt::from_i64(3),
            )
        }
        crate::aver_generated::domain::token::Token::TkLte => {
            crate::aver_generated::domain::parser::expr::parseCmpExprRight(
                tokens,
                nextPos,
                left,
                aver_rt::AverInt::from_i64(4),
            )
        }
        crate::aver_generated::domain::token::Token::TkGte => {
            crate::aver_generated::domain::parser::expr::parseCmpExprRight(
                tokens,
                nextPos,
                left,
                aver_rt::AverInt::from_i64(5),
            )
        }
        _ => Ok((left.clone(), pos)),
    }
}

/// Parse right side of comparison.
pub fn parseCmpExprRight(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    left: &Expr,
    op: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let r = crate::aver_generated::domain::parser::expr::parseAddExpr(tokens, pos)?;
    {
        let (right, pos2) = r;
        crate::aver_generated::domain::parser::expr::buildCmpExpr(left, &right, pos2, op)
    }
}

/// Build comparison AST node from op code.
#[inline(always)]
pub fn buildCmpExpr(
    left: &Expr,
    right: &Expr,
    pos: aver_rt::AverInt,
    op: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    {
        let __dispatch_subject = op;
        if __dispatch_subject == aver_rt::AverInt::from_i64(0) {
            Ok((
                crate::aver_generated::domain::ast::Expr::ExprEq(
                    std::sync::Arc::new(left.clone()),
                    std::sync::Arc::new(right.clone()),
                ),
                pos,
            ))
        } else {
            if __dispatch_subject == aver_rt::AverInt::from_i64(1) {
                Ok((
                    crate::aver_generated::domain::ast::Expr::ExprNeq(
                        std::sync::Arc::new(left.clone()),
                        std::sync::Arc::new(right.clone()),
                    ),
                    pos,
                ))
            } else {
                if __dispatch_subject == aver_rt::AverInt::from_i64(2) {
                    Ok((
                        crate::aver_generated::domain::ast::Expr::ExprLt(
                            std::sync::Arc::new(left.clone()),
                            std::sync::Arc::new(right.clone()),
                        ),
                        pos,
                    ))
                } else {
                    if __dispatch_subject == aver_rt::AverInt::from_i64(3) {
                        Ok((
                            crate::aver_generated::domain::ast::Expr::ExprGt(
                                std::sync::Arc::new(left.clone()),
                                std::sync::Arc::new(right.clone()),
                            ),
                            pos,
                        ))
                    } else {
                        if __dispatch_subject == aver_rt::AverInt::from_i64(4) {
                            Ok((
                                crate::aver_generated::domain::ast::Expr::ExprLte(
                                    std::sync::Arc::new(left.clone()),
                                    std::sync::Arc::new(right.clone()),
                                ),
                                pos,
                            ))
                        } else {
                            if __dispatch_subject == aver_rt::AverInt::from_i64(5) {
                                Ok((
                                    crate::aver_generated::domain::ast::Expr::ExprGte(
                                        std::sync::Arc::new(left.clone()),
                                        std::sync::Arc::new(right.clone()),
                                    ),
                                    pos,
                                ))
                            } else {
                                Err(AverStr::from("unknown cmp operator"))
                            }
                        }
                    }
                }
            }
        }
    }
}

/// Parse additive: mulExpr (('+' | '-') mulExpr)*
pub fn parseAddExpr(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let r = crate::aver_generated::domain::parser::expr::parseMulExpr(tokens, pos)?;
    {
        let (expr, pos2) = r;
        crate::aver_generated::domain::parser::expr::parseAddExprTail(tokens, pos2, &expr)
    }
}

/// Parse multiplicative: atom ('*' atom)*
pub fn parseMulExpr(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let r = crate::aver_generated::domain::parser::expr::parseAtom(tokens, pos)?;
    {
        let (expr, pos2) = r;
        crate::aver_generated::domain::parser::expr::parseMulExprTail(tokens, pos2, &expr)
    }
}

/// Parse atomic expression: literal, variable, call, match, or parenthesized.
pub fn parseAtom(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let nextPos = pos.add(&aver_rt::AverInt::from_i64(1));
    let t = crate::aver_generated::domain::parser_match::tokenAt(tokens, pos);
    match t.clone() {
        crate::aver_generated::domain::token::Token::TkMinus => {
            crate::aver_generated::domain::parser::expr::parseNegAtom(tokens, nextPos)
        }
        crate::aver_generated::domain::token::Token::TkInt(n) => Ok((
            crate::aver_generated::domain::ast::Expr::ExprInt(n),
            nextPos,
        )),
        crate::aver_generated::domain::token::Token::TkFloat(f) => Ok((
            crate::aver_generated::domain::ast::Expr::ExprFloat(f),
            nextPos,
        )),
        crate::aver_generated::domain::token::Token::TkStr(s) => {
            crate::aver_generated::domain::parser::expr::parseStringOrInterp(tokens, nextPos, s)
        }
        crate::aver_generated::domain::token::Token::TkTrue => Ok((
            crate::aver_generated::domain::ast::Expr::ExprBool(true),
            nextPos,
        )),
        crate::aver_generated::domain::token::Token::TkFalse => Ok((
            crate::aver_generated::domain::ast::Expr::ExprBool(false),
            nextPos,
        )),
        crate::aver_generated::domain::token::Token::TkLBracket => {
            crate::aver_generated::domain::parser::expr::parseListExpr(tokens, nextPos)
        }
        crate::aver_generated::domain::token::Token::TkLBrace => {
            crate::aver_generated::domain::parser::expr::parseMapLiteral(tokens, nextPos)
        }
        crate::aver_generated::domain::token::Token::TkLParen => {
            crate::aver_generated::domain::parser::expr::parseParenExpr(tokens, nextPos)
        }
        crate::aver_generated::domain::token::Token::TkMatch => {
            crate::aver_generated::domain::parser::expr::parseMatchExpr(tokens, nextPos)
        }
        crate::aver_generated::domain::token::Token::TkIdent(name) => {
            crate::aver_generated::domain::parser::expr::parseIdentOrCall(tokens, nextPos, name)
        }
        _ => Err(aver_rt::AverStr::from({
            let mut __b = {
                let mut __b = aver_rt::Buffer::with_capacity(
                    (aver_rt::AverInt::from_i64(41)).to_usize().unwrap_or(0),
                );
                __b.push_str(&AverStr::from("Expected expression, got "));
                __b
            };
            __b.push_str(&aver_rt::AverStr::from(aver_rt::aver_display(
                &(crate::aver_generated::domain::token::tokenRepr(&t)),
            )));
            __b
        })),
    }
}

/// Parse map literal into Map.fromList call.
pub fn parseMapLiteral(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let pos2 = crate::aver_generated::domain::parser::expr::skipNl(tokens.clone(), pos);
    match crate::aver_generated::domain::parser_match::tokenAt(tokens, pos2.clone()) {
        crate::aver_generated::domain::token::Token::TkRBrace => Ok((
            crate::aver_generated::domain::ast::Expr::ExprCall(
                AverStr::from("Map.fromList"),
                aver_rt::AverList::from_vec(vec![
                    crate::aver_generated::domain::ast::Expr::ExprList(aver_rt::AverList::empty()),
                ]),
            ),
            pos2.add(&aver_rt::AverInt::from_i64(1)),
        )),
        _ => crate::aver_generated::domain::parser::expr::parseMapEntries(
            tokens,
            pos2,
            &aver_rt::AverList::empty(),
        ),
    }
}

/// Parse unary minus into the first-class Expr.ExprNeg node.
pub fn parseNegAtom(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let r = crate::aver_generated::domain::parser::expr::parseAtom(tokens, pos)?;
    {
        let (expr, pos2) = r;
        Ok((
            crate::aver_generated::domain::ast::Expr::ExprNeg(std::sync::Arc::new(expr)),
            pos2,
        ))
    }
}

/// After TkStr: check for interpolation (TkInterpStart) or plain string.
pub fn parseStringOrInterp(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    prefix: AverStr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    match crate::aver_generated::domain::parser_match::tokenAt(tokens, pos.clone()) {
        crate::aver_generated::domain::token::Token::TkInterpStart => {
            crate::aver_generated::domain::parser::expr::parseInterpParts(
                tokens,
                pos.add(&aver_rt::AverInt::from_i64(1)),
                &aver_rt::AverList::from_vec(vec![
                    crate::aver_generated::domain::ast::Expr::ExprStr(prefix),
                ]),
            )
        }
        _ => Ok((
            crate::aver_generated::domain::ast::Expr::ExprStr(prefix),
            pos,
        )),
    }
}

/// Parse list literal: [expr, expr, ...] or [].
pub fn parseListExpr(
    tokens: &aver_rt::AverList<Token>,
    pos0: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let pos = crate::aver_generated::domain::parser::expr::skipNl(tokens.clone(), pos0);
    match crate::aver_generated::domain::parser_match::tokenAt(tokens, pos.clone()) {
        crate::aver_generated::domain::token::Token::TkRBracket => Ok((
            crate::aver_generated::domain::ast::Expr::ExprList(aver_rt::AverList::empty()),
            pos.add(&aver_rt::AverInt::from_i64(1)),
        )),
        _ => crate::aver_generated::domain::parser::expr::parseListItems(
            tokens,
            pos,
            &aver_rt::AverList::empty(),
        ),
    }
}

/// Parse parenthesized expression or tuple.
pub fn parseParenExpr(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let r = crate::aver_generated::domain::parser::expr::parseExpr(tokens, pos)?;
    {
        let (expr, pos2) = r;
        match crate::aver_generated::domain::parser_match::tokenAt(tokens, pos2.clone()) {
            crate::aver_generated::domain::token::Token::TkComma => {
                crate::aver_generated::domain::parser::expr::parseTupleRest(
                    tokens,
                    pos2.add(&aver_rt::AverInt::from_i64(1)),
                    &aver_rt::AverList::from_vec(vec![expr]),
                )
            }
            crate::aver_generated::domain::token::Token::TkRParen => {
                Ok((expr, pos2.add(&aver_rt::AverInt::from_i64(1))))
            }
            _ => Err(AverStr::from("Expected ')' or ',' after expression")),
        }
    }
}

/// After tuple closing ')': check for ?! or ! postfix to form independent product.
pub fn finishTupleOrProduct(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    items: &aver_rt::AverList<Expr>,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    match crate::aver_generated::domain::parser_match::tokenAt(tokens, pos.clone()) {
        crate::aver_generated::domain::token::Token::TkQuestion => {
            match crate::aver_generated::domain::parser_match::tokenAt(
                tokens,
                pos.add(&aver_rt::AverInt::from_i64(1)),
            ) {
                crate::aver_generated::domain::token::Token::TkBang => Ok((
                    crate::aver_generated::domain::ast::Expr::ExprIndependentProduct(
                        items.clone(),
                        true,
                    ),
                    pos.add(&aver_rt::AverInt::from_i64(2)),
                )),
                _ => Ok((
                    crate::aver_generated::domain::ast::Expr::ExprTuple(items.clone()),
                    pos,
                )),
            }
        }
        crate::aver_generated::domain::token::Token::TkBang => {
            match crate::aver_generated::domain::parser_match::tokenAt(
                tokens,
                pos.add(&aver_rt::AverInt::from_i64(1)),
            ) {
                crate::aver_generated::domain::token::Token::TkLBracket => Ok((
                    crate::aver_generated::domain::ast::Expr::ExprTuple(items.clone()),
                    pos,
                )),
                _ => Ok((
                    crate::aver_generated::domain::ast::Expr::ExprIndependentProduct(
                        items.clone(),
                        false,
                    ),
                    pos.add(&aver_rt::AverInt::from_i64(1)),
                )),
            }
        }
        _ => Ok((
            crate::aver_generated::domain::ast::Expr::ExprTuple(items.clone()),
            pos,
        )),
    }
}

/// After reading an identifier: call, record constructor, field access, or variable?
pub fn parseIdentOrCall(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let nextPos = pos.add(&aver_rt::AverInt::from_i64(1));
    match crate::aver_generated::domain::parser_match::tokenAt(tokens, pos.clone()) {
        crate::aver_generated::domain::token::Token::TkLParen => {
            crate::aver_generated::domain::parser::expr::chainFieldAccess(tokens, nextPos, name)
        }
        crate::aver_generated::domain::token::Token::TkDot => {
            crate::aver_generated::domain::parser::expr::parseFieldAccess(
                tokens,
                nextPos,
                &crate::aver_generated::domain::ast::Expr::ExprVar(name),
            )
        }
        _ => Ok((crate::aver_generated::domain::ast::Expr::ExprVar(name), pos)),
    }
}

/// Parse call/record then chain .field access if present.
pub fn chainFieldAccess(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let r = crate::aver_generated::domain::parser::expr::parseCallOrRecord(tokens, pos, name)?;
    {
        let (expr, pos2) = r;
        crate::aver_generated::domain::parser::expr::parseFieldAccessTail(tokens, pos2, &expr)
    }
}

/// Skip newlines and indents inside parenthesized expressions.
pub fn skipNl(mut tokens: aver_rt::AverList<Token>, mut pos: aver_rt::AverInt) -> aver_rt::AverInt {
    loop {
        crate::cancel_checkpoint();
        let nextPos = pos.add(&aver_rt::AverInt::from_i64(1));
        match crate::aver_generated::domain::parser_match::tokenAt(&tokens, pos.clone()) {
            crate::aver_generated::domain::token::Token::TkNewline => {
                let __tco1 = nextPos;
                pos = __tco1;
                continue;
            }
            crate::aver_generated::domain::token::Token::TkIndent => {
                let __tco1 = nextPos;
                pos = __tco1;
                continue;
            }
            crate::aver_generated::domain::token::Token::TkDedent => {
                let __tco1 = nextPos;
                pos = __tco1;
                continue;
            }
            _ => {
                return pos;
            }
        }
    }
}

/// After '(': is this a function call f(args) or record Foo(field = val)?
pub fn parseCallOrRecord(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let pos2 = crate::aver_generated::domain::parser::expr::skipNl(tokens.clone(), pos);
    match crate::aver_generated::domain::parser_match::tokenAt(tokens, pos2.clone()) {
        crate::aver_generated::domain::token::Token::TkRParen => Ok((
            crate::aver_generated::domain::ast::Expr::ExprCall(name, aver_rt::AverList::empty()),
            pos2.add(&aver_rt::AverInt::from_i64(1)),
        )),
        crate::aver_generated::domain::token::Token::TkIdent(first) => {
            crate::aver_generated::domain::parser::expr::parseCallOrRecordLookahead(
                tokens, pos2, name, first,
            )
        }
        _ => crate::aver_generated::domain::parser::expr::parseCallArgsList(
            tokens,
            pos2,
            name,
            &aver_rt::AverList::empty(),
        ),
    }
}

/// Lookahead after first ident in parens: '=' means record, otherwise call.
pub fn parseCallOrRecordLookahead(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    name: AverStr,
    first: AverStr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    match crate::aver_generated::domain::parser_match::tokenAt(
        tokens,
        pos.add(&aver_rt::AverInt::from_i64(1)),
    ) {
        crate::aver_generated::domain::token::Token::TkEq => {
            crate::aver_generated::domain::parser::expr::parseRecordFields(
                tokens,
                pos,
                name,
                &aver_rt::AverList::empty(),
            )
        }
        _ => crate::aver_generated::domain::parser::expr::parseCallArgsList(
            tokens,
            pos,
            name,
            &aver_rt::AverList::empty(),
        ),
    }
}

/// Parse: match expr NEWLINE INDENT arms DEDENT. Called after TkMatch is consumed.
pub fn parseMatchExpr(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let r = crate::aver_generated::domain::parser::expr::parseExpr(tokens, pos)?;
    {
        let (subject, pos2) = r;
        crate::aver_generated::domain::parser::expr::parseMatchAfterSubject(tokens, pos2, &subject)
    }
}

/// Skip newlines, consume INDENT, then parse arms.
pub fn parseMatchAfterSubject(
    tokens: &aver_rt::AverList<Token>,
    pos: aver_rt::AverInt,
    subject: &Expr,
) -> Result<(Expr, aver_rt::AverInt), AverStr> {
    crate::cancel_checkpoint();
    let pos2 = crate::aver_generated::domain::parser_match::skipNewlines(tokens.clone(), pos);
    match crate::aver_generated::domain::parser_match::tokenAt(tokens, pos2.clone()) {
        crate::aver_generated::domain::token::Token::TkIndent => {
            crate::aver_generated::domain::parser::expr::parseMatchArms(
                tokens,
                pos2.add(&aver_rt::AverInt::from_i64(1)),
                subject,
                &aver_rt::AverList::empty(),
            )
        }
        _ => crate::aver_generated::domain::parser::expr::parseMatchArmsFlat(
            tokens,
            pos2,
            subject,
            &aver_rt::AverList::empty(),
        ),
    }
}