import "@std/mem"
import "@std/testing"

import "@source/diagnostics"
import "@source/strpool"
import "@source/lexer"
import "@source/ast"

parses_expression_precedence_through_tree_views test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source :: "value :: 1 + 2 * 3\n"
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)

    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(1, ast.package_decl_count(&tree))
    declaration :: ast.package_decl(&tree, 0)
    statement :: ast.statement_decl(&tree, declaration)
    try testing.expect_equal("value", ast.source_text(&tree, statement.name))
    try testing.expect_equal(ast.ExprKind.binary, ast.expr_kind(&tree, statement.initializer))
    add :: ast.binary_expr(&tree, statement.initializer)
    try testing.expect_equal(ast.BinaryOperator.add, add.operator)
    try testing.expect_equal(ast.ExprKind.literal_int, ast.expr_kind(&tree, add.left))
    try testing.expect_equal(ast.ExprKind.binary, ast.expr_kind(&tree, add.right))
    multiply :: ast.binary_expr(&tree, add.right)
    try testing.expect_equal(ast.BinaryOperator.multiply, multiply.operator)
    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
}

parses_grouped_expression_precedence test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source :: "value :: a + ((b - c)) * 2 / 3\n"
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)

    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
    try testing.expect_equal(1, ast.package_decl_count(&tree))
    statement :: ast.statement_decl(&tree, ast.package_decl(&tree, 0))
    add :: ast.binary_expr(&tree, statement.initializer)
    try testing.expect_equal(ast.BinaryOperator.add, add.operator)
    try testing.expect_equal("a", ast.source_text(&tree, ast.node_span(&tree, add.left)))
    divide :: ast.binary_expr(&tree, add.right)
    try testing.expect_equal(ast.BinaryOperator.divide, divide.operator)
    try testing.expect_equal("3", ast.source_text(&tree, ast.node_span(&tree, divide.right)))
    multiply :: ast.binary_expr(&tree, divide.left)
    try testing.expect_equal(ast.BinaryOperator.multiply, multiply.operator)
    try testing.expect_equal("2", ast.source_text(&tree, ast.node_span(&tree, multiply.right)))
    subtract :: ast.binary_expr(&tree, multiply.left)
    try testing.expect_equal(ast.BinaryOperator.subtract, subtract.operator)
    try testing.expect_equal("b", ast.source_text(&tree, ast.node_span(&tree, subtract.left)))
    try testing.expect_equal("c", ast.source_text(&tree, ast.node_span(&tree, subtract.right)))
}

parses_function_structure_through_tree_views test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `grouped proc(a, b T, c U) void {
        `    value int :: 1
        `}
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)

    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    declaration :: ast.package_decl(&tree, 0)
    try testing.expect_equal(ast.DeclKind.function, ast.decl_kind(&tree, declaration))
    function :: ast.function_decl(&tree, declaration)
    try testing.expect_equal("grouped", ast.source_text(&tree, function.name))
    try testing.expect_equal(3, ast.function_param_count(&tree, declaration))
    first :: ast.param(&tree, ast.function_param(&tree, declaration, 0))
    second :: ast.param(&tree, ast.function_param(&tree, declaration, 1))
    third :: ast.param(&tree, ast.function_param(&tree, declaration, 2))
    try testing.expect_equal("a", ast.source_text(&tree, first.name))
    try testing.expect_equal("b", ast.source_text(&tree, second.name))
    try testing.expect_equal("c", ast.source_text(&tree, third.name))
    try testing.expect_equal(first.type, second.type)
    try testing.expect(first.type != third.type)
    try testing.expect_equal(1, ast.block_statement_count(&tree, function.body))
    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
}

recovers_invalid_declaration_and_preserves_sibling test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source :: "@ broken\nvalid :: 1\n"
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)

    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(2, ast.package_decl_count(&tree))
    invalid_decl :: ast.package_decl(&tree, 0)
    valid_decl :: ast.package_decl(&tree, 1)
    try testing.expect_equal(ast.DeclKind.invalid, ast.decl_kind(&tree, invalid_decl))
    try testing.expect_equal(ast.DeclKind.statement, ast.decl_kind(&tree, valid_decl))
    invalid_view :: ast.invalid(&tree, invalid_decl)
    try testing.expect(diagnostics.get(&diagnostic_store, invalid_view.diagnostic) != null)
    valid_statement :: ast.statement_decl(&tree, valid_decl)
    try testing.expect_equal("valid", ast.source_text(&tree, valid_statement.name))
}

recovers_malformed_groups_and_preserves_following_statements test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    empty :: ()
        `    operand :: (1 + )
        `    missing :: (2
        `    valid :: (3)
        `}
        `after :: 4
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)

    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(3, diagnostics.count(&diagnostic_store))
    try testing.expect_equal(2, ast.package_decl_count(&tree))
    function :: ast.function_decl(&tree, ast.package_decl(&tree, 0))
    try testing.expect_equal(4, ast.block_statement_count(&tree, function.body))
    empty :: ast.statement_decl(&tree, ast.block_statement(&tree, function.body, 0))
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, empty.initializer))
    operand :: ast.statement_decl(&tree, ast.block_statement(&tree, function.body, 1))
    add :: ast.binary_expr(&tree, operand.initializer)
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, add.right))
    missing :: ast.statement_decl(&tree, ast.block_statement(&tree, function.body, 2))
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, missing.initializer))
    valid :: ast.statement_decl(&tree, ast.block_statement(&tree, function.body, 3))
    try testing.expect_equal(ast.ExprKind.literal_int, ast.expr_kind(&tree, valid.initializer))
    try testing.expect_equal("3", ast.source_text(&tree, ast.node_span(&tree, valid.initializer)))
    after :: ast.statement_decl(&tree, ast.package_decl(&tree, 1))
    try testing.expect_equal("after", ast.source_text(&tree, after.name))
    try testing.expect_equal("4", ast.source_text(&tree, ast.node_span(&tree, after.initializer)))
}

parses_call_statements_and_postfix_precedence test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    ping()
        `    result int := -factory()(add(1, 2 * 3), (4 + 5),) + 6
        `    (handler)(result)
        `}
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
    function :: ast.function_decl(&tree, ast.package_decl(&tree, 0))
    try testing.expect_equal(3, ast.block_statement_count(&tree, function.body))
    ping_stmt :: ast.block_statement(&tree, function.body, 0)
    try testing.expect_equal(ast.StmtKind.expression, ast.stmt_kind(&tree, ping_stmt))
    ping :: ast.statement_expr(&tree, ping_stmt)
    try testing.expect_equal(ast.ExprKind.call, ast.expr_kind(&tree, ping))
    try testing.expect_equal(0, ast.call_arg_count(&tree, ping))
    try testing.expect_equal(
        "ping",
        ast.source_text(&tree, ast.node_span(&tree, ast.call_expr(&tree, ping).callee)),
    )
    try testing.expect_equal("ping()", ast.source_text(&tree, ast.call_expr(&tree, ping).span))

    result :: ast.statement_decl(&tree, ast.block_statement(&tree, function.body, 1))
    try testing.expect_equal(ast.Mutability.variable, result.mutability)
    add :: ast.binary_expr(&tree, result.initializer)
    try testing.expect_equal(ast.BinaryOperator.add, add.operator)
    try testing.expect_equal("6", ast.source_text(&tree, ast.node_span(&tree, add.right)))
    negate :: ast.unary_expr(&tree, add.left)
    call :: negate.operand
    try testing.expect_equal(2, ast.call_arg_count(&tree, call))
    factory :: ast.call_expr(&tree, call).callee
    try testing.expect_equal(0, ast.call_arg_count(&tree, factory))
    try testing.expect_equal(
        "factory",
        ast.source_text(&tree, ast.node_span(&tree, ast.call_expr(&tree, factory).callee)),
    )
    nested :: ast.call_arg(&tree, call, 0)
    try testing.expect_equal(2, ast.call_arg_count(&tree, nested))
    try testing.expect_equal(
        "add",
        ast.source_text(&tree, ast.node_span(&tree, ast.call_expr(&tree, nested).callee)),
    )
    try testing.expect_equal(
        "1",
        ast.source_text(&tree, ast.node_span(&tree, ast.call_arg(&tree, nested, 0))),
    )
    multiply :: ast.binary_expr(&tree, ast.call_arg(&tree, nested, 1))
    try testing.expect_equal(ast.BinaryOperator.multiply, multiply.operator)
    try testing.expect_equal("2", ast.source_text(&tree, ast.node_span(&tree, multiply.left)))
    try testing.expect_equal("3", ast.source_text(&tree, ast.node_span(&tree, multiply.right)))
    grouped :: ast.binary_expr(&tree, ast.call_arg(&tree, call, 1))
    try testing.expect_equal(ast.BinaryOperator.add, grouped.operator)
    try testing.expect_equal("4", ast.source_text(&tree, ast.node_span(&tree, grouped.left)))
    try testing.expect_equal("5", ast.source_text(&tree, ast.node_span(&tree, grouped.right)))

    handler :: ast.statement_expr(&tree, ast.block_statement(&tree, function.body, 2))
    try testing.expect_equal(
        "handler",
        ast.source_text(&tree, ast.node_span(&tree, ast.call_expr(&tree, handler).callee)),
    )
    try testing.expect_equal(1, ast.call_arg_count(&tree, handler))
    try testing.expect_equal(
        "result",
        ast.source_text(&tree, ast.node_span(&tree, ast.call_arg(&tree, handler, 0))),
    )
}

recovers_malformed_calls_and_preserves_siblings test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    bad(1 2)
        `    good()
        `    missing(1
        `    after :: 3
        `    holes(, 2)
        `}
        `tail :: f()
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(3, diagnostics.count(&diagnostic_store))
    try testing.expect_equal(2, ast.package_decl_count(&tree))
    function :: ast.function_decl(&tree, ast.package_decl(&tree, 0))
    try testing.expect_equal(5, ast.block_statement_count(&tree, function.body))
    for ([0, 2]) |index| {
        statement :: ast.block_statement(&tree, function.body, usize(index))
        try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, statement))
        try testing.expect(
            diagnostics.get(&diagnostic_store, ast.invalid(&tree, statement).diagnostic) != null,
        )
    }
    good :: ast.statement_expr(&tree, ast.block_statement(&tree, function.body, 1))
    try testing.expect_equal(
        "good",
        ast.source_text(&tree, ast.node_span(&tree, ast.call_expr(&tree, good).callee)),
    )
    after :: ast.statement_decl(&tree, ast.block_statement(&tree, function.body, 3))
    try testing.expect_equal("after", ast.source_text(&tree, after.name))
    holes :: ast.statement_expr(&tree, ast.block_statement(&tree, function.body, 4))
    try testing.expect_equal(2, ast.call_arg_count(&tree, holes))
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, ast.call_arg(&tree, holes, 0)))
    try testing.expect_equal(
        "2",
        ast.source_text(&tree, ast.node_span(&tree, ast.call_arg(&tree, holes, 1))),
    )
    tail :: ast.statement_decl(&tree, ast.package_decl(&tree, 1))
    try testing.expect_equal("tail", ast.source_text(&tree, tail.name))
    try testing.expect_equal(0, ast.call_arg_count(&tree, tail.initializer))
}

parses_return_boundaries_and_recovers_trailing_tokens test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `return 1
        `main proc() void {
        `    return
        `    2
        `    return (3 + 4)
        `    return 5 stray
        `    after :: 6
        `    return }
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(2, ast.package_decl_count(&tree))
    try testing.expect_equal(ast.DeclKind.invalid, ast.decl_kind(&tree, ast.package_decl(&tree, 0)))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 1)).body
    try testing.expect_equal(6, ast.block_statement_count(&tree, body))
    first :: ast.block_statement(&tree, body, 0)
    try testing.expect_equal(ast.StmtKind.return_stmt, ast.stmt_kind(&tree, first))
    try testing.expect(ast.return_stmt(&tree, first).value == null)
    try testing.expect_equal("return", ast.source_text(&tree, ast.return_stmt(&tree, first).span))
    try testing.expect_equal(ast.StmtKind.expression, ast.stmt_kind(&tree, ast.block_statement(&tree, body, 1)))
    grouped :: ast.return_stmt(&tree, ast.block_statement(&tree, body, 2))
    try testing.expect_equal("return (3 + 4)", ast.source_text(&tree, grouped.span))
    if (grouped.value) |value| {
        try testing.expect_equal(ast.ExprKind.binary, ast.expr_kind(&tree, value))
    } else {
        return .expectation_failed
    }
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, ast.block_statement(&tree, body, 3)))
    after :: ast.statement_decl(&tree, ast.block_statement(&tree, body, 4))
    try testing.expect_equal("after", ast.source_text(&tree, after.name))
    last :: ast.return_stmt(&tree, ast.block_statement(&tree, body, 5))
    try testing.expect(last.value == null)
    try testing.expect_equal("return", ast.source_text(&tree, last.span))
    try testing.expect_equal(2, diagnostics.count(&diagnostic_store))
}

parses_boolean_comparison_precedence_and_associativity test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `value :: -f() * 2 + 3 < 4 <= 5 > 6 >= 7 == true != false
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)
    different :: ast.binary_expr(&tree, ast.statement_decl(&tree, ast.package_decl(&tree, 0)).initializer)
    try testing.expect_equal(ast.BinaryOperator.not_equal, different.operator)
    try testing.expect_equal(ast.ExprKind.literal_bool, ast.expr_kind(&tree, different.right))
    try testing.expect_equal("false", ast.source_text(&tree, ast.node_span(&tree, different.right)))
    equal :: ast.binary_expr(&tree, different.left)
    try testing.expect_equal(ast.BinaryOperator.equal, equal.operator)
    try testing.expect_equal(ast.ExprKind.literal_bool, ast.expr_kind(&tree, equal.right))
    relation := equal.left
    operators [4]ast.BinaryOperator :: [.greater_equal, .greater, .less_equal, .less]
    for (operators) |operator| {
        binary :: ast.binary_expr(&tree, relation)
        try testing.expect_equal(operator, binary.operator)
        relation = binary.left
    }
    addition :: ast.binary_expr(&tree, relation)
    try testing.expect_equal(ast.BinaryOperator.add, addition.operator)
    product :: ast.binary_expr(&tree, addition.left)
    try testing.expect_equal(ast.BinaryOperator.multiply, product.operator)
    negate :: ast.unary_expr(&tree, product.left)
    try testing.expect_equal(ast.ExprKind.call, ast.expr_kind(&tree, negate.operand))
    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
}

parses_factorial_and_canonical_conditional_arms test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `factorial proc(n int) int {
        `    if (n <= 1) return 1 else return n * factorial(n - 1)
        `}
        `main proc() int {
        `    if true {
        `        local :: factorial(5)
        `        if (false) return 0 else return local
        `    }
        `    else if ready() return 2 else { return 3 }
        `}
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)
    factorial :: ast.function_decl(&tree, ast.package_decl(&tree, 0))
    try testing.expect_equal(1, ast.block_statement_count(&tree, factorial.body))
    guard :: ast.if_stmt(&tree, ast.block_statement(&tree, factorial.body, 0))
    try testing.expect_equal("n <= 1", ast.source_text(&tree, ast.node_span(&tree, guard.condition)))
    try testing.expect_equal(1, ast.block_statement_count(&tree, guard.then_block))
    try testing.expect_equal("return 1", ast.source_text(&tree, ast.return_stmt(&tree, ast.block_statement(&tree, guard.then_block, 0)).span))
    try testing.expect_equal(1, ast.block_statement_count(&tree, guard.else_block?))
    try testing.expect_equal(ast.StmtKind.return_stmt, ast.stmt_kind(&tree, ast.block_statement(&tree, guard.else_block?, 0)))
    main :: ast.function_decl(&tree, ast.package_decl(&tree, 1))
    outer :: ast.if_stmt(&tree, ast.block_statement(&tree, main.body, 0))
    try testing.expect_equal(2, ast.block_statement_count(&tree, outer.then_block))
    try testing.expect_equal(ast.StmtKind.declaration, ast.stmt_kind(&tree, ast.block_statement(&tree, outer.then_block, 0)))
    nested :: ast.if_stmt(&tree, ast.block_statement(&tree, outer.then_block, 1))
    try testing.expect(nested.else_block != null)
    try testing.expect_equal(1, ast.block_statement_count(&tree, outer.else_block?))
    chain :: ast.if_stmt(&tree, ast.block_statement(&tree, outer.else_block?, 0))
    try testing.expect_equal(ast.ExprKind.call, ast.expr_kind(&tree, chain.condition))
    try testing.expect(chain.else_block != null)
    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
}

attaches_dangling_else_to_nearest_if test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source :: "main proc() int { if (true) if (false) return 1 else return 2 else return 3 }"
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    outer :: ast.if_stmt(&tree, ast.block_statement(&tree, body, 0))
    inner :: ast.if_stmt(&tree, ast.block_statement(&tree, outer.then_block, 0))
    inner_return :: ast.return_stmt(&tree, ast.block_statement(&tree, inner.else_block?, 0))
    outer_return :: ast.return_stmt(&tree, ast.block_statement(&tree, outer.else_block?, 0))
    try testing.expect_equal("2", ast.source_text(&tree, ast.node_span(&tree, inner_return.value?)))
    try testing.expect_equal("3", ast.source_text(&tree, ast.node_span(&tree, outer_return.value?)))
    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
}

recovers_conditional_conditions_and_arms_without_losing_siblings test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    if { good() } else { other() }
        `    if (true) else return
        `    if broken( { kept() }
        `    after :: 7
        `    return 1 else return 2
        `    final :: 8
        `}
        `tail :: 9
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)
    try testing.expect_equal(2, ast.package_decl_count(&tree))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    try testing.expect_equal(6, ast.block_statement_count(&tree, body))
    first :: ast.if_stmt(&tree, ast.block_statement(&tree, body, 0))
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, first.condition))
    condition_diagnostic :: diagnostics.get(&diagnostic_store, ast.invalid(&tree, first.condition).diagnostic)?
    try testing.expect_equal("{", ast.source_text(&tree, condition_diagnostic.span))
    try testing.expect_equal(1, ast.block_statement_count(&tree, first.then_block))
    second :: ast.if_stmt(&tree, ast.block_statement(&tree, body, 1))
    bad_arm :: ast.block_statement(&tree, second.then_block, 0)
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, bad_arm))
    arm_diagnostic :: diagnostics.get(&diagnostic_store, ast.invalid(&tree, bad_arm).diagnostic)?
    try testing.expect_equal("else", ast.source_text(&tree, arm_diagnostic.span))
    try testing.expect(second.else_block != null)
    third :: ast.if_stmt(&tree, ast.block_statement(&tree, body, 2))
    try testing.expect_equal(1, ast.block_statement_count(&tree, third.then_block))
    after :: ast.statement_decl(&tree, ast.block_statement(&tree, body, 3))
    try testing.expect_equal("after", ast.source_text(&tree, after.name))
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, ast.block_statement(&tree, body, 4)))
    final :: ast.statement_decl(&tree, ast.block_statement(&tree, body, 5))
    try testing.expect_equal("final", ast.source_text(&tree, final.name))
    try testing.expect_equal(4, diagnostics.count(&diagnostic_store))
}

recovers_invalid_guard_syntax_and_missing_arm_at_enclosing_brace test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() int {
        `    if true return 1 else return 2
        `    if (true junk) { kept() } else { other() }
        `    sibling :: 3
        `    if (false) }
        `tail :: 4
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)
    try testing.expect_equal(2, ast.package_decl_count(&tree))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    try testing.expect_equal(4, ast.block_statement_count(&tree, body))
    first :: ast.if_stmt(&tree, ast.block_statement(&tree, body, 0))
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, first.condition))
    guard_error :: diagnostics.get(&diagnostic_store, ast.invalid(&tree, first.condition).diagnostic)?
    try testing.expect_equal("return", ast.source_text(&tree, guard_error.span))
    try testing.expect(first.else_block != null)
    second :: ast.if_stmt(&tree, ast.block_statement(&tree, body, 1))
    try testing.expect_equal(1, ast.block_statement_count(&tree, second.then_block))
    try testing.expect(second.else_block != null)
    sibling :: ast.statement_decl(&tree, ast.block_statement(&tree, body, 2))
    try testing.expect_equal("sibling", ast.source_text(&tree, sibling.name))
    last :: ast.if_stmt(&tree, ast.block_statement(&tree, body, 3))
    missing :: ast.block_statement(&tree, last.then_block, 0)
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, missing))
    arm_error :: diagnostics.get(&diagnostic_store, ast.invalid(&tree, missing).diagnostic)?
    try testing.expect_equal("}", ast.source_text(&tree, arm_error.span))
    try testing.expect_equal(3, diagnostics.count(&diagnostic_store))
}

parses_iterative_factorial_assignments_and_loop test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `factorial proc(n int) int {
        `    remaining := n
        `    product := 1
        `    while remaining > 1 {
        `        product = product * remaining
        `        remaining = remaining - 1
        `    }
        `    return product
        `}
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    try testing.expect_equal(4, ast.block_statement_count(&tree, body))
    loop_id :: ast.block_statement(&tree, body, 2)
    try testing.expect_equal(ast.StmtKind.while_stmt, ast.stmt_kind(&tree, loop_id))
    loop :: ast.while_stmt(&tree, loop_id)
    try testing.expect_equal(ast.BinaryOperator.greater, ast.binary_expr(&tree, loop.condition).operator)
    try testing.expect_equal(2, ast.block_statement_count(&tree, loop.body))
    update_id :: ast.block_statement(&tree, loop.body, 0)
    try testing.expect_equal(ast.StmtKind.assignment_stmt, ast.stmt_kind(&tree, update_id))
    update :: ast.assignment_stmt(&tree, update_id)
    try testing.expect_equal(ast.ExprKind.identifier, ast.expr_kind(&tree, update.target))
    try testing.expect_equal("product", ast.source_text(&tree, ast.node_span(&tree, update.target)))
    try testing.expect_equal(ast.BinaryOperator.multiply, ast.binary_expr(&tree, update.value).operator)
    decrement :: ast.assignment_stmt(&tree, ast.block_statement(&tree, loop.body, 1))
    try testing.expect_equal(ast.BinaryOperator.subtract, ast.binary_expr(&tree, decrement.value).operator)
}

parses_assignment_precedence_grouped_span_and_rhs_boundaries test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    value = (1 + 2 * 3)
        `    if (true) value = 4 else value = 5
        `    while ready() value = value - 1
        `    value = 6 }
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    try testing.expect_equal(4, ast.block_statement_count(&tree, body))
    assignment :: ast.assignment_stmt(&tree, ast.block_statement(&tree, body, 0))
    try testing.expect_equal("value = (1 + 2 * 3)", ast.source_text(&tree, assignment.span))
    add :: ast.binary_expr(&tree, assignment.value)
    try testing.expect_equal(ast.BinaryOperator.add, add.operator)
    try testing.expect_equal(ast.BinaryOperator.multiply, ast.binary_expr(&tree, add.right).operator)
    conditional :: ast.if_stmt(&tree, ast.block_statement(&tree, body, 1))
    first :: ast.assignment_stmt(&tree, ast.block_statement(&tree, conditional.then_block, 0))
    second :: ast.assignment_stmt(&tree, ast.block_statement(&tree, conditional.else_block?, 0))
    try testing.expect_equal("4", ast.source_text(&tree, ast.node_span(&tree, first.value)))
    try testing.expect_equal("5", ast.source_text(&tree, ast.node_span(&tree, second.value)))
    loop :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 2))
    try testing.expect_equal(ast.ExprKind.call, ast.expr_kind(&tree, loop.condition))
    try testing.expect_equal(1, ast.block_statement_count(&tree, loop.body))
    try testing.expect_equal(ast.StmtKind.assignment_stmt, ast.stmt_kind(&tree, ast.block_statement(&tree, loop.body, 0)))
    last :: ast.assignment_stmt(&tree, ast.block_statement(&tree, body, 3))
    try testing.expect_equal("6", ast.source_text(&tree, ast.node_span(&tree, last.value)))
}

parses_nested_loops_and_preserves_nearest_if_else test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    if (true) while (false) if (true) x = 1 else x = 2 else x = 3
        `    while (true) while (false) x = 4
        `    while (true) {
        `        while false { x = 5 }
        `    }
        `}
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    try testing.expect_equal(3, ast.block_statement_count(&tree, body))
    outer :: ast.if_stmt(&tree, ast.block_statement(&tree, body, 0))
    loop :: ast.while_stmt(&tree, ast.block_statement(&tree, outer.then_block, 0))
    inner :: ast.if_stmt(&tree, ast.block_statement(&tree, loop.body, 0))
    inner_else :: ast.assignment_stmt(&tree, ast.block_statement(&tree, inner.else_block?, 0))
    outer_else :: ast.assignment_stmt(&tree, ast.block_statement(&tree, outer.else_block?, 0))
    try testing.expect_equal("2", ast.source_text(&tree, ast.node_span(&tree, inner_else.value)))
    try testing.expect_equal("3", ast.source_text(&tree, ast.node_span(&tree, outer_else.value)))
    braceless :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 1))
    nested :: ast.while_stmt(&tree, ast.block_statement(&tree, braceless.body, 0))
    try testing.expect_equal(1, ast.block_statement_count(&tree, nested.body))
    braced :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 2))
    child :: ast.while_stmt(&tree, ast.block_statement(&tree, braced.body, 0))
    try testing.expect_equal(ast.ExprKind.literal_bool, ast.expr_kind(&tree, child.condition))
    try testing.expect_equal(1, ast.block_statement_count(&tree, child.body))
}

recovers_loop_guards_bodies_and_assignments_without_losing_braces test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    while { x = 1 }
        `    while true x = 2
        `    while broken( { x = 3 }
        `    x =
        `    x = 1 junk
        `    if (true) x = else x = 4
        `    kept :: 7
        `    while (false) }
        `tail :: 8
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect(diagnostics.count(&diagnostic_store) > 0)
    try testing.expect_equal(2, ast.package_decl_count(&tree))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    try testing.expect_equal(8, ast.block_statement_count(&tree, body))
    for 0..3 |index| {
        loop :: ast.while_stmt(&tree, ast.block_statement(&tree, body, usize(index)))
        try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, loop.condition))
        try testing.expect_equal(1, ast.block_statement_count(&tree, loop.body))
        try testing.expect_equal(ast.StmtKind.assignment_stmt, ast.stmt_kind(&tree, ast.block_statement(&tree, loop.body, 0)))
    }
    missing :: ast.assignment_stmt(&tree, ast.block_statement(&tree, body, 3))
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, missing.value))
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, ast.block_statement(&tree, body, 4)))
    conditional :: ast.if_stmt(&tree, ast.block_statement(&tree, body, 5))
    missing_arm :: ast.assignment_stmt(&tree, ast.block_statement(&tree, conditional.then_block, 0))
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, missing_arm.value))
    try testing.expect(conditional.else_block != null)
    kept :: ast.statement_decl(&tree, ast.block_statement(&tree, body, 6))
    try testing.expect_equal("kept", ast.source_text(&tree, kept.name))
    last :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 7))
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, ast.block_statement(&tree, last.body, 0)))
    tail :: ast.statement_decl(&tree, ast.package_decl(&tree, 1))
    try testing.expect_equal("tail", ast.source_text(&tree, tail.name))
}

rejects_top_level_assignment_loop_else_and_assignment_expressions test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `x = 1
        `main proc() void {
        `    while (true) x = 2 else x = 3
        `    x = y = 4
        `    kept :: 5
        `}
        `tail :: 6
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect(diagnostics.count(&diagnostic_store) > 0)
    try testing.expect_equal(3, ast.package_decl_count(&tree))
    try testing.expect_equal(ast.DeclKind.invalid, ast.decl_kind(&tree, ast.package_decl(&tree, 0)))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 1)).body
    try testing.expect_equal(4, ast.block_statement_count(&tree, body))
    loop :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 0))
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, ast.block_statement(&tree, loop.body, 0)))
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, ast.block_statement(&tree, body, 1)))
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, ast.block_statement(&tree, body, 2)))
    kept :: ast.statement_decl(&tree, ast.block_statement(&tree, body, 3))
    try testing.expect_equal("kept", ast.source_text(&tree, kept.name))
}

recovers_nested_braces_in_malformed_loop_body_and_assignment test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    while (true) @ {
        `        bad()
        `    }
        `    x = {
        `        bad()
        `    }
        `    kept :: 7
        `}
        `tail :: 8
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect(diagnostics.count(&diagnostic_store) > 0)
    try testing.expect_equal(2, ast.package_decl_count(&tree))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    try testing.expect_equal(3, ast.block_statement_count(&tree, body))
    loop :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 0))
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, ast.block_statement(&tree, loop.body, 0)))
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, ast.block_statement(&tree, body, 1)))
    kept :: ast.statement_decl(&tree, ast.block_statement(&tree, body, 2))
    try testing.expect_equal("kept", ast.source_text(&tree, kept.name))
    tail :: ast.statement_decl(&tree, ast.package_decl(&tree, 1))
    try testing.expect_equal("tail", ast.source_text(&tree, tail.name))
}

parses_logical_precedence_and_associativity test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source :: "value :: !probe() == a + b * c < d and e and f or g or h\n"
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
    value :: ast.statement_decl(&tree, ast.package_decl(&tree, 0))
    outer_or :: ast.binary_expr(&tree, value.initializer)
    try testing.expect_equal(ast.BinaryOperator.logical_or, outer_or.operator)
    try testing.expect_equal("h", ast.source_text(&tree, ast.node_span(&tree, outer_or.right)))
    inner_or :: ast.binary_expr(&tree, outer_or.left)
    try testing.expect_equal(ast.BinaryOperator.logical_or, inner_or.operator)
    outer_and :: ast.binary_expr(&tree, inner_or.left)
    try testing.expect_equal(ast.BinaryOperator.logical_and, outer_and.operator)
    try testing.expect_equal("f", ast.source_text(&tree, ast.node_span(&tree, outer_and.right)))
    inner_and :: ast.binary_expr(&tree, outer_and.left)
    try testing.expect_equal(ast.BinaryOperator.logical_and, inner_and.operator)
    equality :: ast.binary_expr(&tree, inner_and.left)
    try testing.expect_equal(ast.BinaryOperator.equal, equality.operator)
    logical_not :: ast.unary_expr(&tree, equality.left)
    try testing.expect_equal(ast.UnaryOperator.logical_not, logical_not.operator)
    try testing.expect_equal(ast.ExprKind.call, ast.expr_kind(&tree, logical_not.operand))
    try testing.expect_equal("!probe()", ast.source_text(&tree, logical_not.span))
    comparison :: ast.binary_expr(&tree, equality.right)
    try testing.expect_equal(ast.BinaryOperator.less, comparison.operator)
    addition :: ast.binary_expr(&tree, comparison.left)
    try testing.expect_equal(ast.BinaryOperator.add, addition.operator)
    multiply :: ast.binary_expr(&tree, addition.right)
    try testing.expect_equal(ast.BinaryOperator.multiply, multiply.operator)
}

parses_right_associative_mixed_prefix_operators test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source :: "value :: !-!probe()\nother :: -!false\n"
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
    value :: ast.statement_decl(&tree, ast.package_decl(&tree, 0))
    first :: ast.unary_expr(&tree, value.initializer)
    second :: ast.unary_expr(&tree, first.operand)
    third :: ast.unary_expr(&tree, second.operand)
    try testing.expect_equal(ast.UnaryOperator.logical_not, first.operator)
    try testing.expect_equal(ast.UnaryOperator.negate, second.operator)
    try testing.expect_equal(ast.UnaryOperator.logical_not, third.operator)
    try testing.expect_equal(ast.ExprKind.call, ast.expr_kind(&tree, third.operand))
    try testing.expect_equal("!-!probe()", ast.source_text(&tree, first.span))
    try testing.expect_equal("-!probe()", ast.source_text(&tree, second.span))
    other :: ast.statement_decl(&tree, ast.package_decl(&tree, 1))
    negate :: ast.unary_expr(&tree, other.initializer)
    try testing.expect_equal(ast.UnaryOperator.negate, negate.operator)
    try testing.expect_equal(ast.UnaryOperator.logical_not, ast.unary_expr(&tree, negate.operand).operator)
}

parses_logical_expressions_in_all_expression_positions test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `global :: (
        `    false
        `    and absent
        `)
        `main proc() bool {
        `    value := (
        `        true
        `        or absent
        `    )
        `    value = (
        `        !
        `        value
        `        and ready(
        `        )
        `    )
        `    !value
        `    if (
        `        !value
        `        or ready()
        `    ) { value = false }
        `    while (
        `        value
        `        and !done()
        `    ) { value = false }
        `    return (
        `        choose(
        `            (
        `                value
        `                or false
        `            ),
        `            nested(
        `                !value
        `                and true
        `            ),
        `        )
        `    )
        `}
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
    global :: ast.statement_decl(&tree, ast.package_decl(&tree, 0))
    global_and :: ast.binary_expr(&tree, global.initializer)
    try testing.expect_equal(ast.BinaryOperator.logical_and, global_and.operator)
    try testing.expect_equal("absent", ast.source_text(&tree, ast.node_span(&tree, global_and.right)))
    function :: ast.function_decl(&tree, ast.package_decl(&tree, 1))
    try testing.expect_equal(6, ast.block_statement_count(&tree, function.body))
    local :: ast.statement_decl(&tree, ast.block_statement(&tree, function.body, 0))
    try testing.expect_equal(ast.BinaryOperator.logical_or, ast.binary_expr(&tree, local.initializer).operator)
    assignment :: ast.assignment_stmt(&tree, ast.block_statement(&tree, function.body, 1))
    try testing.expect_equal(ast.BinaryOperator.logical_and, ast.binary_expr(&tree, assignment.value).operator)
    expression :: ast.statement_expr(&tree, ast.block_statement(&tree, function.body, 2))
    try testing.expect_equal(ast.UnaryOperator.logical_not, ast.unary_expr(&tree, expression).operator)
    conditional :: ast.if_stmt(&tree, ast.block_statement(&tree, function.body, 3))
    try testing.expect_equal(ast.BinaryOperator.logical_or, ast.binary_expr(&tree, conditional.condition).operator)
    loop :: ast.while_stmt(&tree, ast.block_statement(&tree, function.body, 4))
    try testing.expect_equal(ast.BinaryOperator.logical_and, ast.binary_expr(&tree, loop.condition).operator)
    returned :: ast.return_stmt(&tree, ast.block_statement(&tree, function.body, 5)).value?
    try testing.expect_equal(2, ast.call_arg_count(&tree, returned))
    first_argument :: ast.call_arg(&tree, returned, 0)
    try testing.expect_equal(ast.BinaryOperator.logical_or, ast.binary_expr(&tree, first_argument).operator)
    nested :: ast.call_arg(&tree, returned, 1)
    nested_argument :: ast.call_arg(&tree, nested, 0)
    try testing.expect_equal(ast.BinaryOperator.logical_and, ast.binary_expr(&tree, nested_argument).operator)
}

multiline_group_errors_preserve_statement_boundaries test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    value := (
        `        1 +
        `    next int :: 2
        `    value = 3
        `    return (
        `        true
        `}
        `tail :: 9
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(3, diagnostics.count(&diagnostic_store))
    try testing.expect_equal(2, ast.package_decl_count(&tree))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    try testing.expect_equal(4, ast.block_statement_count(&tree, body))
    next :: ast.statement_decl(&tree, ast.block_statement(&tree, body, 1))
    try testing.expect_equal("next", ast.source_text(&tree, next.name))
    assignment :: ast.assignment_stmt(&tree, ast.block_statement(&tree, body, 2))
    try testing.expect_equal("3", ast.source_text(&tree, ast.node_span(&tree, assignment.value)))
    try testing.expect_equal(ast.StmtKind.return_stmt, ast.stmt_kind(&tree, ast.block_statement(&tree, body, 3)))
    tail :: ast.statement_decl(&tree, ast.package_decl(&tree, 1))
    try testing.expect_equal("tail", ast.source_text(&tree, tail.name))
}

recovers_missing_logical_operands_and_preserves_enclosing_nodes test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() bool {
        `    first :: true and
        `    second :: true and or false
        `    third :: choose(!, false or)
        `    if ! { return false }
        `    return true or }
        `after :: true
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)

    try testing.expect_equal(6, diagnostics.count(&diagnostic_store))
    try testing.expect_equal(2, ast.package_decl_count(&tree))
    function :: ast.function_decl(&tree, ast.package_decl(&tree, 0))
    try testing.expect_equal(5, ast.block_statement_count(&tree, function.body))
    first :: ast.statement_decl(&tree, ast.block_statement(&tree, function.body, 0))
    first_and :: ast.binary_expr(&tree, first.initializer)
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, first_and.right))
    second :: ast.statement_decl(&tree, ast.block_statement(&tree, function.body, 1))
    second_or :: ast.binary_expr(&tree, second.initializer)
    try testing.expect_equal(ast.BinaryOperator.logical_or, second_or.operator)
    second_and :: ast.binary_expr(&tree, second_or.left)
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, second_and.right))
    try testing.expect_equal(ast.ExprKind.literal_bool, ast.expr_kind(&tree, second_or.right))
    third :: ast.statement_decl(&tree, ast.block_statement(&tree, function.body, 2))
    try testing.expect_equal(2, ast.call_arg_count(&tree, third.initializer))
    missing_prefix :: ast.unary_expr(&tree, ast.call_arg(&tree, third.initializer, 0))
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, missing_prefix.operand))
    missing_rhs :: ast.binary_expr(&tree, ast.call_arg(&tree, third.initializer, 1))
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, missing_rhs.right))
    conditional :: ast.if_stmt(&tree, ast.block_statement(&tree, function.body, 3))
    try testing.expect_equal(1, ast.block_statement_count(&tree, conditional.then_block))
    returned :: ast.return_stmt(&tree, ast.block_statement(&tree, function.body, 4)).value?
    try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, ast.binary_expr(&tree, returned).right))
    after :: ast.statement_decl(&tree, ast.package_decl(&tree, 1))
    try testing.expect_equal("after", ast.source_text(&tree, after.name))
}

parses_leaf_loop_controls_and_nearest_else test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    while (true) {
        `        if (true) if (false) break else continue
        `        while (false) continue
        `        break
        `    }
        `    while (false) if (true) break else continue
        `}
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)
    try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    try testing.expect_equal(2, ast.block_statement_count(&tree, body))
    loop :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 0))
    try testing.expect_equal(3, ast.block_statement_count(&tree, loop.body))
    outer_if :: ast.if_stmt(&tree, ast.block_statement(&tree, loop.body, 0))
    try testing.expect(outer_if.else_block == null)
    inner_if :: ast.if_stmt(&tree, ast.block_statement(&tree, outer_if.then_block, 0))
    transfer :: ast.block_statement(&tree, inner_if.then_block, 0)
    try testing.expect_equal(ast.StmtKind.break_stmt, ast.stmt_kind(&tree, transfer))
    try testing.expect_equal("break", ast.source_text(&tree, ast.node_span(&tree, transfer)))
    if (inner_if.else_block) |other| {
        alternate :: ast.block_statement(&tree, other, 0)
        try testing.expect_equal(ast.StmtKind.continue_stmt, ast.stmt_kind(&tree, alternate))
        try testing.expect_equal("continue", ast.source_text(&tree, ast.node_span(&tree, alternate)))
    } else return .expectation_failed
    nested :: ast.while_stmt(&tree, ast.block_statement(&tree, loop.body, 1))
    try testing.expect_equal(ast.StmtKind.continue_stmt, ast.stmt_kind(&tree, ast.block_statement(&tree, nested.body, 0)))
    braceless :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 1))
    conditional :: ast.if_stmt(&tree, ast.block_statement(&tree, braceless.body, 0))
    try testing.expect(conditional.else_block != null)
}

rejects_control_tails_and_preserves_following_declarations test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `break
        `continue
        `bad :: break
        `bad_continue :: continue
        `main proc() void {
        `    while (true) {
        `        break 1
        `        first :: 1
        `        continue label
        `        second :: 2
        `        if (true) break label else continue
        `        if (true) continue 2 else break
        `        break 3 }
        `    after :: 3
        `}
        `last :: 4
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)
    try testing.expect_equal(9, diagnostics.count(&diagnostic_store))
    try testing.expect_equal(6, ast.package_decl_count(&tree))
    for (usize(0)..usize(2)) |index| try testing.expect_equal(ast.DeclKind.invalid, ast.decl_kind(&tree, ast.package_decl(&tree, index)))
    for (usize(2)..usize(4)) |index| {
        declaration :: ast.package_decl(&tree, index)
        try testing.expect_equal(ast.DeclKind.statement, ast.decl_kind(&tree, declaration))
        try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, ast.statement_decl(&tree, declaration).initializer))
    }
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 4)).body
    try testing.expect_equal(2, ast.block_statement_count(&tree, body))
    loop :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 0))
    try testing.expect_equal(7, ast.block_statement_count(&tree, loop.body))
    for ([usize(1), usize(3)]) |index| {
        try testing.expect_equal(ast.StmtKind.declaration, ast.stmt_kind(&tree, ast.block_statement(&tree, loop.body, index)))
    }
    conditional :: ast.if_stmt(&tree, ast.block_statement(&tree, loop.body, 4))
    try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, ast.block_statement(&tree, conditional.then_block, 0)))
    if (conditional.else_block) |other| {
        try testing.expect_equal(ast.StmtKind.continue_stmt, ast.stmt_kind(&tree, ast.block_statement(&tree, other, 0)))
    } else return .expectation_failed
    try testing.expect_equal(ast.StmtKind.declaration, ast.stmt_kind(&tree, ast.block_statement(&tree, body, 1)))
    try testing.expect_equal(ast.DeclKind.statement, ast.decl_kind(&tree, ast.package_decl(&tree, 5)))
}

preserves_control_bodies_after_malformed_guards test {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)
    diagnostic_store := diagnostics.init(mem.c_allocator)
    defer diagnostics.deinit(&diagnostic_store)
    source ::
        `main proc() void {
        `    while (true break
        `    while predicate( continue
        `    while (true) { continue }
        `    after :: 1
        `}
    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)
    try lexer.scan(&scan_state, source, &diagnostic_store)
    tree := try parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
    defer ast.deinit(&tree)
    try testing.expect_equal(2, diagnostics.count(&diagnostic_store))
    body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
    try testing.expect_equal(4, ast.block_statement_count(&tree, body))
    expected [3]ast.StmtKind :: [.break_stmt, .continue_stmt, .continue_stmt]
    for (expected) |kind, index| {
        loop :: ast.while_stmt(&tree, ast.block_statement(&tree, body, index))
        try testing.expect_equal(kind, ast.stmt_kind(&tree, ast.block_statement(&tree, loop.body, 0)))
        if (index < 2) try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, loop.condition))
    }
    try testing.expect_equal(ast.StmtKind.declaration, ast.stmt_kind(&tree, ast.block_statement(&tree, body, 3)))
}