radiance · Radiance self-hosting compiler

compiler/ lib/ examples/ std/ arch/ char/ collections/ graph/ lang/ alloc/ ast/ gen/ il/ module/ parser/ tests.rad 138.8 KiB resolver/ scanner/ alloc.rad 7.1 KiB ast.rad 26.9 KiB gen.rad 513 B il.rad 20.4 KiB lower.rad 321.7 KiB module.rad 17.3 KiB package.rad 1.3 KiB parser.rad 92.2 KiB resolver.rad 511.1 KiB scanner.rad 17.9 KiB sexpr.rad 6.7 KiB strings.rad 2.2 KiB types.rad 1.6 KiB sys/ arch.rad 68 B char.rad 855 B collections.rad 39 B fmt.rad 8.3 KiB graph.rad 4.3 KiB intrinsics.rad 467 B io.rad 1.7 KiB lang.rad 276 B mem.rad 2.3 KiB sys.rad 179 B testing.rad 2.4 KiB tests.rad 15.7 KiB vec.rad 3.2 KiB std.rad 299 B scripts/ seed/ sublime/ test/ vim/ .gitignore 336 B .gitsigners 112 B CELL_PERMISSIONS 6.8 KiB CONTRIBUTING 2.1 KiB LICENSE 1.1 KiB Makefile 5.4 KiB README 2.5 KiB STYLE 2.5 KiB std.lib 1.5 KiB std.lib.test 808 B
lib/std/lang/parser/tests.rad 138.8 KiB raw
//! Parser tests.

use std::mem;
use std::fmt;
use std::testing;
use std::lang::ast;
use std::lang::alloc;
use std::lang::sexpr;
use std::lang::ast::printer;
use std::lang::scanner;
use std::lang::strings;

/// Allocated nodes publish immutable pointers with stable metadata and edges.
@test unsafe fn testAstNodePublication() throws (testing::TestError) {
    static STORAGE: [u8; 4096] = [0; 4096];
    let mut arena = ast::nodeArena(&mut STORAGE[..]);
    let allocate: unsafe fn(&mut ast::NodeArena, ast::Span, ast::NodeValue) -> *ast::Node = ast::allocNode;
    let synthesize: unsafe fn(&mut ast::NodeArena, ast::NodeValue) -> *ast::Node = ast::synthNode;
    let leaf = allocate(&mut arena, ast::Span { offset: 9, length: 4 }, ast::NodeValue::Bool(true));
    let root = synthesize(&mut arena, ast::NodeValue::ExprStmt(leaf));
    assert leaf.id == 0;
    assert leaf.span.offset == 9;
    assert leaf.span.length == 4;
    assert root.id == 1;
    assert root.span.offset == 0;
    assert root.span.length == 0;
    let case ast::NodeValue::ExprStmt(child) = root.value else throw testing::TestError::Failed;
    assert child == leaf;
    assert arena.nextId == 2;
}

/// Unified arena size.
constant ARENA_SIZE: u32 = 2097152;
/// Unified arena storage for all AST allocations.
static ARENA_STORAGE: [u8; ARENA_SIZE] = [0; ARENA_SIZE];
/// String pool.
unsafe static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Assert that a node is an identifier with the given name.
fn expectIdent(node: *ast::Node, name: *[u8])
    throws (testing::TestError)
{
    let case ast::NodeValue::Ident(n) = node.value
        if mem::eq(n, name)
        else throw testing::TestError::Failed;
}

/// Assert that a node is a type identifier with the given name.
fn expectTypeIdent(node: *ast::Node, name: *[u8])
    throws (testing::TestError)
{
    let case ast::NodeValue::TypeSig(ts) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Nominal(ident) = ts
        else throw testing::TestError::Failed;

    try expectIdent(ident, name);
}

/// Assert that a node is a number literal with the given text.
fn expectNumber(node: *ast::Node, text: *[u8])
    throws (testing::TestError)
{
    let case ast::NodeValue::Number(n) = node.value
        if mem::eq(n.text, text)
        else throw testing::TestError::Failed;
}

/// Assert that a node is a range literal with the given optional bounds.
fn expectRangeNumbers(node: *ast::Node, start: ?*[u8], end: ?*[u8])
    throws (testing::TestError)
{
    let case ast::NodeValue::Range(range) = node.value
        else throw testing::TestError::Failed;

    if let text = start {
        let startNode = range.start
            else throw testing::TestError::Failed;
        try expectNumber(startNode, text);
    } else {
        try testing::expect(range.start == nil);
    }
    if let text = end {
        let endNode = range.end
            else throw testing::TestError::Failed;
        try expectNumber(endNode, text);
    } else {
        try testing::expect(range.end == nil);
    }
}

/// Token operations use the parser's checked pool borrow.
fn checkTokenOperations 'pool (p: &mut super::Parser 'pool) throws (testing::TestError) {
    super::advance(p);
    let name = try super::expect(p, scanner::TokenKind::Ident, "expected name") catch {
        throw testing::TestError::Failed;
    };
    try testing::expectBytesEq(name, "alpha");
    try testing::expect(super::consume(p, scanner::TokenKind::Comma));
    try testing::expect(not super::consume(p, scanner::TokenKind::Comma));
    try testing::expect(super::check(p, scanner::TokenKind::Ident));
    super::advance(p);
    try testing::expect(super::check(p, scanner::TokenKind::Eof));
}

/// Scanner state can advance without an unsafe token operation.
@test unsafe fn testSafeTokenOperations() throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
        let mut parser = super::mkParser(scanner::SourceLoc::String, "alpha, beta", arenaRef, poolRef);
        try checkTokenOperations(&mut parser);
    }
}

/// Parse multiple statements from a string.
unsafe fn parseStmtsStr(input: *[u8]) -> *ast::Node
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
        let mut parser = super::mkParser(scanner::SourceLoc::String, input, arenaRef, poolRef);
        return try super::parseModule(&mut parser) catch {
            throw testing::TestError::Failed;
        };
    }
}

/// Parse a single type from a string.
unsafe fn parseTypeStr(input: *[u8]) -> *ast::Node
    throws (super::ParseError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
        let mut parser = super::mkParser(scanner::SourceLoc::String, input, arenaRef, poolRef);
        super::advance(&mut parser);
        let root = try super::parseType(&mut parser);
        try super::expect(&mut parser, scanner::TokenKind::Eof, "expected end of type");

        return root;
    }
}

/// Parse a single expression from a string.
export unsafe fn parseExprStr(input: *[u8]) -> *ast::Node
    throws (super::ParseError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
        let mut parser = super::mkParser(scanner::SourceLoc::String, input, arenaRef, poolRef);
        super::advance(&mut parser);
        return try super::parseExpr(&mut parser);
    }
}

/// Parse a single statement from a string.
unsafe fn parseStmtStr(input: *[u8]) -> *ast::Node
    throws (super::ParseError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
        let mut parser = super::mkParser(scanner::SourceLoc::String, input, arenaRef, poolRef);
        super::advance(&mut parser);
        let root = try super::parseStmt(&mut parser);
        while super::consume(&mut parser, scanner::TokenKind::Semicolon) {}
        try super::expect(&mut parser, scanner::TokenKind::Eof, "expected end of statement");

        return root;
    }
}

/// Parse an expression expected to be a number literal and return its payload.
unsafe fn parseNumberLiteral(text: *[u8]) -> fmt::IntLiteral
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
        let mut parser = super::mkParser(scanner::SourceLoc::String, text, arenaRef, poolRef);
        super::advance(&mut parser);

        let node = try! super::parseExpr(&mut parser);

        if not super::check(&parser, scanner::TokenKind::Eof) {
            throw testing::TestError::Failed;
        }
        let case ast::NodeValue::Number(lit) = node.value
            else throw testing::TestError::Failed;

        return lit;
    }
}

/// Ensure that parsing the supplied literal source fails.
unsafe fn expectNumberLiteralFail(text: *[u8])
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
        let mut parser = super::mkParser(scanner::SourceLoc::String, text, arenaRef, poolRef);
        super::advance(&mut parser);

        try super::parseExpr(&mut parser) catch {
            return;
        };
        if not super::check(&parser, scanner::TokenKind::Eof) {
            return;
        }
        throw testing::TestError::Failed;
    }
}

/// Assert that a node is a type signature matching the expected type.
fn expectType(node: *ast::Node, type: ast::TypeSig)
    throws (testing::TestError)
{
    let case ast::NodeValue::TypeSig(t) = node.value
        if (t == type)
        else throw testing::TestError::Failed;
}

/// Assert that a node is an integer type with the expected width and sign.
fn expectIntType(node: *ast::Node, expectedWidth: u32, expectedSign: ast::Signedness)
    throws (testing::TestError)
{
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;

    let case ast::TypeSig::Integer { width, sign } = sig
        else throw testing::TestError::Failed;

    try testing::expect(width == expectedWidth);
    try testing::expect(sign == expectedSign);
}

/// Extract a union variant and verify its name and index.
/// Returns the payload's fields slice for further checking with `expectField`.
fn expectVariant(varNode: *ast::Node, name: *[u8], index: u32) -> ?*[*ast::Node]
    throws (testing::TestError)
{
    let case ast::NodeValue::UnionDeclVariant(v) = varNode.value
        else throw testing::TestError::Failed;
    try expectIdent(v.name, name);
    try testing::expect(v.index == index);
    try testing::expect(v.value == nil);

    let payloadType = v.type else return nil;
    let case ast::NodeValue::TypeSig(sig) = payloadType.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Record { fields, .. } = sig
        else throw testing::TestError::Failed;

    return fields;
}

/// Check a record field has the expected name and type signature.
fn expectFieldSig(
    fields: *[*ast::Node], index: u32, name: ?*[u8], sig: ast::TypeSig
) throws (testing::TestError) {
    let fieldNode = fields[index];
    let case ast::NodeValue::RecordField { field, type: fieldType, .. } = fieldNode.value
        else throw testing::TestError::Failed;

    if let expectedName = name {
        let actualName = field else throw testing::TestError::Failed;
        try expectIdent(actualName, expectedName);
    } else {
        try testing::expect(field == nil);
    }
    try expectType(fieldType, sig);
}

/// Assert that a block's first statement is an expression statement with the expected value.
fn expectBlockExprStmt(blk: *ast::Node, expected: ast::NodeValue)
    throws (testing::TestError)
{
    let stmt = try getBlockFirstStmt(blk);
    let case ast::NodeValue::ExprStmt(expr) = stmt.value
        else throw testing::TestError::Failed;

    if let case ast::NodeValue::Ident(e) = expected {
        if let case ast::NodeValue::Ident(a) = expr.value {
            if mem::eq(e, a) {
                return;
            } else {
                throw testing::TestError::Failed;
            }
        }
    }
    panic "expectBlockExprStmt: comparing values we don't know how to compare";
}

/// Get the first statement from a block node.
export fn getBlockFirstStmt(blk: *ast::Node) -> *ast::Node
    throws (testing::TestError)
{
    let case ast::NodeValue::Block(block) = blk.value
        else throw testing::TestError::Failed;

    if block.statements.len == 0 {
        throw testing::TestError::Failed;
    }
    return block.statements[0];
}

/// Get the last statement from a block node.
export fn getBlockLastStmt(blk: *ast::Node) -> *ast::Node
    throws (testing::TestError)
{
    let case ast::NodeValue::Block(block) = blk.value
        else throw testing::TestError::Failed;

    if block.statements.len == 0 {
        throw testing::TestError::Failed;
    }
    return block.statements[block.statements.len - 1];
}

/// Test parsing boolean literals (`true` and `false`).
@test unsafe fn testParseBool() throws (testing::TestError) {
    let r1 = try! parseExprStr("true");
    let case ast::NodeValue::Bool(v1) = r1.value if v1
        else throw testing::TestError::Failed;

    let r2 = try! parseExprStr("false");
    let case ast::NodeValue::Bool(v2) = r2.value if not v2
        else throw testing::TestError::Failed;
}

/// Test parsing number literals.
@test unsafe fn testParseNumber() throws (testing::TestError) {
    let r1 = try! parseExprStr("4519");
    try expectNumber(r1, "4519");
}

/// Verify that decimal literals record magnitude and base metadata.
@test unsafe fn testParseDecimalLiteralMetadata() throws (testing::TestError) {
    let lit = try parseNumberLiteral("1234");
    try testing::expect(lit.magnitude == 1234);
    try testing::expect(lit.radix == fmt::Radix::Decimal);
}

/// Verify that hexadecimal literals record magnitude and radix metadata.
@test unsafe fn testParseNumberMetadata() throws (testing::TestError) {
    let lit = try parseNumberLiteral("0xFF");
    try testing::expect(lit.magnitude == 0xFF);
    try testing::expect(lit.radix == fmt::Radix::Hex);
}

/// Verify that binary literals capture their radix.
@test unsafe fn testParseBinaryLiteralMetadata() throws (testing::TestError) {
    let lit = try parseNumberLiteral("0b1010");
    try testing::expect(lit.magnitude == 0b1010);
    try testing::expect(lit.radix == fmt::Radix::Binary);
}

/// Negative literals parse as unary negation of an unsigned number.
@test unsafe fn testParseNegativeLiteral() throws (testing::TestError) {
    let node = try! parseExprStr("-99");
    let case ast::NodeValue::UnOp(neg) = node.value
        else throw testing::TestError::Failed;
    try testing::expect(neg.op == ast::UnaryOp::Neg);
    let case ast::NodeValue::Number(lit) = neg.value.value
        else throw testing::TestError::Failed;
    try testing::expect(lit.magnitude == 99);
}

/// Unary plus is not part of the expression grammar.
@test unsafe fn testRejectUnaryPlus() throws (testing::TestError) {
    try expectNumberLiteralFail("+1");
    try expectNumberLiteralFail("+value");
    try expectNumberLiteralFail("+(value)");
}

/// Range expressions parse with explicit start and end bounds.
@test unsafe fn testParseRangeExpr() throws (testing::TestError) {
    let node = try! parseExprStr("0..5");
    try expectRangeNumbers(node, "0", "5");
}

/// Range expressions allow a missing end bound.
@test unsafe fn testParseRangeExprNoEnd() throws (testing::TestError) {
    let node = try! parseExprStr("0..");
    try expectRangeNumbers(node, "0", nil);
}

/// Range expressions allow a missing start bound.
@test unsafe fn testParseRangeExprNoStart() throws (testing::TestError) {
    let node = try! parseExprStr("..5");
    try expectRangeNumbers(node, nil, "5");
}

/// Literals with out-of-range digits for their base are rejected.
@test unsafe fn testParseInvalidIntLiteral() throws (testing::TestError) {
    // 2^64 overflows u64.
    try expectNumberLiteralFail("18446744073709551616");
    try expectNumberLiteralFail("0x10000000000000000");
    try expectNumberLiteralFail("0x1G");
    try expectNumberLiteralFail("0b102");
}

/// Test parsing nil literal.
@test unsafe fn testParseNil() throws (testing::TestError) {
    let r1 = try! parseExprStr("nil");
    let case ast::NodeValue::Nil = r1.value
        else throw testing::TestError::Failed;
}

/// Test parsing undefined literal.
@test unsafe fn testParseUndefined() throws (testing::TestError) {
    let r1 = try! parseExprStr("undefined");
    let case ast::NodeValue::Undef = r1.value
        else throw testing::TestError::Failed;
}

/// Test parsing character literals.
@test unsafe fn testParseChar() throws (testing::TestError) {
    let r1 = try! parseExprStr("'a'");
    let case ast::NodeValue::Char(c1) = r1.value if c1 == 'a'
        else throw testing::TestError::Failed;

    let r2 = try! parseExprStr("'\\n'");
    let case ast::NodeValue::Char(c2) = r2.value if c2 == '\n'
        else throw testing::TestError::Failed;

    let r3 = try! parseExprStr("'\\t'");
    let case ast::NodeValue::Char(c3) = r3.value if c3 == '\t'
        else throw testing::TestError::Failed;
}

/// Test parsing string literals.
@test unsafe fn testParseString() throws (testing::TestError) {
    let r1 = try! parseExprStr("\"hello\"");
    let case ast::NodeValue::String(s1) = r1.value if mem::eq(s1, "hello")
        else throw testing::TestError::Failed;

    let r2 = try! parseExprStr("\"\"");
    let case ast::NodeValue::String(s2) = r2.value if s2.len == 0
        else throw testing::TestError::Failed;
}

/// Test string escape sequence processing.
@test unsafe fn testParseStringEscape() throws (testing::TestError) {
    // Tab and newline.
    let r1 = try! parseExprStr("\"hello\\tworld\\n\"");
    let case ast::NodeValue::String(s1) = r1.value if s1.len == 12
        else throw testing::TestError::Failed;
    if s1[5] <> '\t' {
        throw testing::TestError::Failed;
    }
    if s1[11] <> '\n' {
        throw testing::TestError::Failed;
    }

    // Escaped quote.
    let r2 = try! parseExprStr("\"\\\"\"");
    let case ast::NodeValue::String(s2) = r2.value if s2.len == 1
        else throw testing::TestError::Failed;
    if s2[0] <> '"' {
        throw testing::TestError::Failed;
    }

    // Escaped backslash.
    let r3 = try! parseExprStr("\"\\\\\"");
    let case ast::NodeValue::String(s3) = r3.value if s3.len == 1
        else throw testing::TestError::Failed;
    if s3[0] <> '\\' {
        throw testing::TestError::Failed;
    }

    // Mixed escapes.
    let r4 = try! parseExprStr("\"a\\nb\\tc\"");
    let case ast::NodeValue::String(s4) = r4.value if s4.len == 5
        else throw testing::TestError::Failed;
    if s4[0] <> 'a' {
        throw testing::TestError::Failed;
    }
    if s4[1] <> '\n' {
        throw testing::TestError::Failed;
    }
    if s4[2] <> 'b' {
        throw testing::TestError::Failed;
    }
    if s4[3] <> '\t' {
        throw testing::TestError::Failed;
    }
    if s4[4] <> 'c' {
        throw testing::TestError::Failed;
    }
}

/// Test parsing placeholder/underscore.
@test unsafe fn testParsePlaceholder() throws (testing::TestError) {
    let r1 = try! parseExprStr("_");
    let case ast::NodeValue::Placeholder = r1.value
        else throw testing::TestError::Failed;
}

/// Test parsing array literals.
@test unsafe fn testParseArrayLiteral() throws (testing::TestError) {
    let r1 = try! parseExprStr("[]");
    let case ast::NodeValue::ArrayLit(items1) = r1.value if items1.len == 0
        else throw testing::TestError::Failed;

    let r2 = try! parseExprStr("[1]");
    let case ast::NodeValue::ArrayLit(items2) = r2.value if items2.len == 1
        else throw testing::TestError::Failed;

    let r3 = try! parseExprStr("[1, 2, 3]");
    let case ast::NodeValue::ArrayLit(items3) = r3.value if items3.len == 3
        else throw testing::TestError::Failed;
}

/// Test parsing array repeat literals.
@test unsafe fn testParseArrayRepeatLiteral() throws (testing::TestError) {
    let r1 = try! parseExprStr("[42; 10]");
    let case ast::NodeValue::ArrayRepeatLit(a) = r1.value
        else throw testing::TestError::Failed;

    try expectNumber(a.item, "42");
    try expectNumber(a.count, "10");
}

/// Test parsing a simple `if` statement without an `else` clause.
@test unsafe fn testParseIf() throws (testing::TestError) {
    let r1 = try parseStmtStr("if condition { body; }") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::If(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.condition, "condition");
    try expectBlockExprStmt(n.thenBranch, ast::NodeValue::Ident("body"));
    try testing::expect(n.elseBranch == nil);
}

/// Test parsing an `if-else` statement.
@test unsafe fn testParseIfElse() throws (testing::TestError) {
    let r1 = try! parseStmtStr("if condition { left; } else { right; }") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::If(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.condition, "condition");
    try expectBlockExprStmt(n.thenBranch, ast::NodeValue::Ident("left"));

    let elseBranch = n.elseBranch
        else throw testing::TestError::Failed;

    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("right"));
}

/// Test parsing an `if-else if-else` chain.
@test unsafe fn testParseIfElseIf() throws (testing::TestError) {
    let root = try! parseStmtStr("if x { a; } else if y { b; } else { c; }") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::If(top) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(top.condition, "x");
    try expectBlockExprStmt(top.thenBranch, ast::NodeValue::Ident("a"));

    let topElse = top.elseBranch
        else throw testing::TestError::Failed;
    let nested = try getBlockFirstStmt(topElse);
    let case ast::NodeValue::If(inner) = nested.value
        else throw testing::TestError::Failed;

    try expectIdent(inner.condition, "y");
    try expectBlockExprStmt(inner.thenBranch, ast::NodeValue::Ident("b"));

    let innerElse = inner.elseBranch
        else throw testing::TestError::Failed;
    try expectBlockExprStmt(innerElse, ast::NodeValue::Ident("c"));
}

/// Test parsing a block with multiple statements where the last lacks a semicolon.
@test unsafe fn testParseBlockMultiStmt() throws (testing::TestError) {
    let root = try! parseStmtStr("{ first; second; third }");
    let case ast::NodeValue::Block(body) = root.value
        else throw testing::TestError::Failed;
    try testing::expect(body.statements.len == 3);

    let firstStmt = body.statements[0];
    let case ast::NodeValue::ExprStmt(firstExpr) = firstStmt.value
        else throw testing::TestError::Failed;
    try expectIdent(firstExpr, "first");

    let secondStmt = body.statements[1];
    let case ast::NodeValue::ExprStmt(secondExpr) = secondStmt.value
        else throw testing::TestError::Failed;
    try expectIdent(secondExpr, "second");

    let thirdStmt = body.statements[2];
    let case ast::NodeValue::ExprStmt(thirdExpr) = thirdStmt.value
        else throw testing::TestError::Failed;
    try expectIdent(thirdExpr, "third");
}

/// Test parsing a block that keeps a trailing `;` delimiter.
@test unsafe fn testParseBlockTrailingSemicolon() throws (testing::TestError) {
    let root = try! parseStmtStr("if cond { only; }") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::If(node) = root.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::Block(body) = node.thenBranch.value
        else throw testing::TestError::Failed;
    try testing::expect(body.statements.len == 1);

    let stmt = body.statements[0];
    let case ast::NodeValue::ExprStmt(expr) = stmt.value
        else throw testing::TestError::Failed;
    try expectIdent(expr, "only");
}

/// Test that missing delimiters between block statements produce an error.
@test unsafe fn testParseBlockMissingDelimiter() throws (testing::TestError) {
    let parsed: ?*ast::Node =
        try? parseStmtStr("if cond { first second }");
    try testing::expect(parsed == nil);
}

/// Test parsing a `let` binding without a type annotation.
@test unsafe fn testParseLet() throws (testing::TestError) {
    let r1 = try! parseStmtStr("let x = y;") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::Let(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.ident, "x");
    try expectIdent(n.value, "y");
    try testing::expect(not n.mutable);
    try testing::expect(n.type == nil);
}

/// Test parsing a `let` binding with a type annotation.
@test unsafe fn testParseLetTyped() throws (testing::TestError) {
    let r1 = try! parseStmtStr("let x: i32 = y;");
    let case ast::NodeValue::Let(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.ident, "x");
    try expectIdent(n.value, "y");
    try testing::expect(not n.mutable);

    let type = n.type
        else throw testing::TestError::Failed;
    try expectType(type, ast::TypeSig::Integer {
        width: 4, sign: ast::Signedness::Signed
    });
}

/// Test parsing a `let` binding with alignment modifier.
@test unsafe fn testParseLetAlign() throws (testing::TestError) {
    let r1 = try! parseStmtStr("let x: i32 align(16) = 13;");
    let case ast::NodeValue::Let(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.ident, "x");
    try expectNumber(n.value, "13");
    try testing::expect(not n.mutable);

    let type = n.type
        else throw testing::TestError::Failed;
    try expectType(type, ast::TypeSig::Integer {
        width: 4, sign: ast::Signedness::Signed
    });

    let alignment = n.alignment
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Align(a) = alignment.value
        else throw testing::TestError::Failed;
    try expectNumber(a, "16");
}

/// Test parsing let-else statement.
@test unsafe fn testParseLetElse() throws (testing::TestError) {
    let root = try! parseStmtStr("let x = opt else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(letElse.pattern.pattern, "x");

    let case ast::NodeValue::Block(elseBlock) = letElse.elseBranch.value
        else throw testing::TestError::Failed;
    try testing::expect(elseBlock.statements.len == 1);
}

/// Test parsing let-else with single statement.
@test unsafe fn testParseLetElseSingleStmt() throws (testing::TestError) {
    let root = try! parseStmtStr("let y = val else return;");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(letElse.pattern.pattern, "y");

    let case ast::NodeValue::Return(_) = letElse.elseBranch.value
        else throw testing::TestError::Failed;
}

/// Test parsing let-else with expression branch.
@test unsafe fn testParseLetElseExpr() throws (testing::TestError) {
    let root = try! parseStmtStr("let z = opt else y;");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(letElse.pattern.pattern, "z");
    try expectIdent(letElse.elseBranch, "y");
}

/// Test parsing let-case-else statement.
@test unsafe fn testParseLetCaseElse() throws (testing::TestError) {
    let root = try! parseStmtStr("let case Variant(x) = opt else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(letElse.pattern.guard == nil);
}

/// Test parsing let-case-else with guard.
@test unsafe fn testParseLetCaseElseWithGuard() throws (testing::TestError) {
    let root = try! parseStmtStr("let case Variant(x) = opt if x > 0 else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(letElse.pattern.guard <> nil);

    let guardNode = letElse.pattern.guard else throw testing::TestError::Failed;
    let case ast::NodeValue::BinOp(cmp) = guardNode.value
        else throw testing::TestError::Failed;
    try testing::expect(cmp.op == ast::BinaryOp::Gt);
}

/// Test parsing a `let mut` declaration.
@test unsafe fn testParseMut() throws (testing::TestError) {
    let r1 = try! parseStmtStr("let mut x = 42;");
    let case ast::NodeValue::Let(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.ident, "x");
    try expectNumber(n.value, "42");
    try testing::expect(n.mutable);
    try testing::expect(n.type == nil);
}

/// Test parsing a `let mut` declaration with type annotation.
@test unsafe fn testParseMutTyped() throws (testing::TestError) {
    let r1 = try! parseStmtStr("let mut x: i32 = 42;");
    let case ast::NodeValue::Let(n) = r1.value
        else throw testing::TestError::Failed;

    try expectIdent(n.ident, "x");
    try expectNumber(n.value, "42");
    try testing::expect(n.mutable);

    let type = n.type
        else throw testing::TestError::Failed;
    try expectType(type, ast::TypeSig::Integer {
        width: 4, sign: ast::Signedness::Signed
    });
}

/// Test parsing a `constant` declaration.
@test unsafe fn testParseConst() throws (testing::TestError) {
    let node = try! parseStmtStr("constant ANSWER: i32 = 42;");
    let case ast::NodeValue::ConstDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.ident, "ANSWER");
    try expectType(decl.type, ast::TypeSig::Integer {
        width: 4, sign: ast::Signedness::Signed
    });
    try expectNumber(decl.value, "42");
}

/// Test parsing a `static` declaration.
@test unsafe fn testParseStatic() throws (testing::TestError) {
    let node = try! parseStmtStr("static COUNTER: i32 = 0;");
    let case ast::NodeValue::StaticDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.ident, "COUNTER");
    try expectType(decl.type, ast::TypeSig::Integer {
        width: 4, sign: ast::Signedness::Signed
    });
    try expectNumber(decl.value, "0");
}

/// Test parsing a `use` declaration.
@test unsafe fn testParseUse() throws (testing::TestError) {
    let node = try! parseStmtStr("use module::item;");
    let case ast::NodeValue::Use(decl) = node.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::ScopeAccess(scope) = decl.path.value
        else throw testing::TestError::Failed;

    try expectIdent(scope.parent, "module");
    try expectIdent(scope.child, "item");
}

/// Test parsing a `mod` declaration.
@test unsafe fn testParseMod() throws (testing::TestError) {
    let node = try! parseStmtStr("mod io;");
    let case ast::NodeValue::Mod(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "io");
    try testing::expect(decl.attrs == nil);
}

/// Test parsing a module declaration with attributes.
@test unsafe fn testParseModAttributes() throws (testing::TestError) {
    let node = try! parseStmtStr("export mod io;");
    let case ast::NodeValue::Mod(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "io");
    let attrs = decl.attrs
        else throw testing::TestError::Failed;

    try testing::expect(attrs.list.len == 1);

    let case ast::NodeValue::Attribute(attr) = attrs.list[0].value
        else throw testing::TestError::Failed;

    try testing::expect(attr == ast::Attribute::Export);
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Export));
}

/// Test parsing an optional type.
@test unsafe fn testParseTypeOptional() throws (testing::TestError) {
    let node = try! parseTypeStr("?i32");
    let case ast::NodeValue::TypeSig(optional) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Optional(opt) = optional
        else throw testing::TestError::Failed;

    try expectIntType(opt, 4, ast::Signedness::Signed);
}

/// Parse an `i32` pointer type and verify its class and mutability.
unsafe fn expectI32Pointer(
    source: *[u8],
    class: ast::PointerClass,
    mutable: bool,
) throws (testing::TestError) {
    let node = try! parseTypeStr(source);
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Pointer {
        class: actualClass, valueType, mutable: actualMutable,
    } = sig else throw testing::TestError::Failed;

    assert actualClass == class;
    try expectIntType(valueType, 4, ast::Signedness::Signed);
    assert actualMutable == mutable;
}

/// Test parsing a mutable owned pointer.
@test unsafe fn testParseTypePointer() throws (testing::TestError) {
    try expectI32Pointer("*mut i32", ast::PointerClass::Owned, true);
}

/// Test parsing an immutable owned pointer.
@test unsafe fn testParseTypePointerImmutable() throws (testing::TestError) {
    try expectI32Pointer("*i32", ast::PointerClass::Owned, false);
}

/// Test parsing immutable and mutable references.
@test unsafe fn testParseTypeRef() throws (testing::TestError) {
    try expectI32Pointer("&i32", ast::PointerClass::Ref, false);
    try expectI32Pointer("&mut i32", ast::PointerClass::Ref, true);
}

/// Test parsing immutable and mutable unsafe pointers.
@test unsafe fn testParseTypeUnsafePointer() throws (testing::TestError) {
    try expectI32Pointer("*unsafe i32", ast::PointerClass::Unsafe, false);
    try expectI32Pointer("*unsafe mut i32", ast::PointerClass::Unsafe, true);
}

/// Test parsing a slice type.
@test unsafe fn testParseTypeSlice() throws (testing::TestError) {
    let node = try! parseTypeStr("*[u8]");
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Slice { class, itemType, mutable } = sig
        else throw testing::TestError::Failed;

    assert class == ast::PointerClass::Owned;
    try expectIntType(itemType, 1, ast::Signedness::Unsigned);
    assert not mutable;
}

/// Test parsing a mutable slice type.
@test unsafe fn testParseTypeSliceMutable() throws (testing::TestError) {
    let node = try! parseTypeStr("*mut [u8]");
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Slice { class, itemType, mutable } = sig
        else throw testing::TestError::Failed;

    assert class == ast::PointerClass::Owned;
    try expectIntType(itemType, 1, ast::Signedness::Unsigned);
    assert mutable;
}

/// Test parsing reference and unsafe slice classes.
@test unsafe fn testParseTypeSliceClasses() throws (testing::TestError) {
    let refNode = try! parseTypeStr("&[u8]");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Slice {
        class: refClass, ..
    }) = refNode.value else throw testing::TestError::Failed;
    assert refClass == ast::PointerClass::Ref;

    let unsafeNode = try! parseTypeStr("*unsafe [u8]");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Slice {
        class: unsafeClass, ..
    }) = unsafeNode.value else throw testing::TestError::Failed;
    assert unsafeClass == ast::PointerClass::Unsafe;
}

/// Test parsing trait object pointer classes.
@test unsafe fn testParseTypeTraitObjectClasses() throws (testing::TestError) {
    let ownedNode = try! parseTypeStr("*opaque Read");
    let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
        class: ownedClass, ..
    }) = ownedNode.value else throw testing::TestError::Failed;
    assert ownedClass == ast::PointerClass::Owned;

    let refNode = try! parseTypeStr("&opaque Read");
    let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
        class: refClass, ..
    }) = refNode.value else throw testing::TestError::Failed;
    assert refClass == ast::PointerClass::Ref;

    let unsafeNode = try! parseTypeStr("*unsafe opaque Read");
    let case ast::NodeValue::TypeSig(ast::TypeSig::TraitObject {
        class: unsafeClass, ..
    }) = unsafeNode.value else throw testing::TestError::Failed;
    assert unsafeClass == ast::PointerClass::Unsafe;
}

/// Test parsing an array type.
@test unsafe fn testParseTypeArray() throws (testing::TestError) {
    let node = try! parseTypeStr("[i32; 4]");
    let case ast::NodeValue::TypeSig(sig) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Array { itemType, length } = sig
        else throw testing::TestError::Failed;

    try expectIntType(itemType, 4, ast::Signedness::Signed);
    try expectNumber(length, "4");
}

/// Test parsing a named record declaration without derives.
/// Opaque record modifiers preserve exports, regions, and ownership markers.
@test unsafe fn testParseOpaqueRecord() throws (testing::TestError) {
    for source, i in [
        "opaque record R { value: u32 }",
        "export opaque record R: 'r + Copy { value: &'r u32 }",
        "opaque record R: Copy(u32);",
    ] {
        let node = try! parseStmtStr(source);
        let case ast::NodeValue::RecordDecl(decl) = node.value else throw testing::TestError::Failed;
        let attrs = decl.attrs else throw testing::TestError::Failed;
        assert ast::attributesContains(&attrs, ast::Attribute::Opaque);
        assert ast::attributesContains(&attrs, ast::Attribute::Export) == (i == 1);
        assert decl.labeled == (i <> 2);
        assert decl.fields.len == 1;
        assert decl.regions.len == (1 if i == 1 else 0);
        assert decl.derives.len == (0 if i == 0 else 1);
        static PRINT_STORAGE: [u8; 4096] = [0; 4096];
        let mut printArena = alloc::new(&mut PRINT_STORAGE[..]);
        let printed = printer::toExpr(&mut printArena, node);
        let case sexpr::Expr::Block { name, .. } = printed else throw testing::TestError::Failed;
        assert name == "opaque-record";
    }
    for source in [
        "opaque fn f() {}",
        "opaque union R { Value }",
        "opaque opaque record R {}",
        "opaque export record R {}",
    ] {
        let parsed = try? parseStmtStr(source);
        assert parsed == nil;
    }
}

@test unsafe fn testParseRecordDecl() throws (testing::TestError) {
    let node = try! parseStmtStr("record R { x: bool, y: i32 }");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "R");
    try testing::expect(decl.derives.len == 0);
    try testing::expect(decl.fields.len == 2);

    try expectFieldSig(decl.fields, 0, "x", ast::TypeSig::Bool);
    try expectFieldSig(decl.fields, 1, "y", ast::TypeSig::Integer {
        width: 4,
        sign: ast::Signedness::Signed,
    });
}

/// Test parsing a record declaration with derives.
@test unsafe fn testParseRecordDeclDerives() throws (testing::TestError) {
    let node = try! parseStmtStr("record R: Eq + Debug { field: i32 }");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "R");
    try testing::expect(decl.derives.len == 2);
    try expectIdent(decl.derives[0], "Eq");
    try expectIdent(decl.derives[1], "Debug");
}

/// Test parsing a record declaration with field initializers.
@test unsafe fn testParseRecordDeclFieldDefaults() throws (testing::TestError) {
    let node = try! parseStmtStr("record Config { size: opaque = 42, flag: bool = true }");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Config");
    try testing::expect(decl.derives.len == 0);
    try testing::expect(decl.fields.len == 2);

    try expectFieldSig(decl.fields, 0, "size", ast::TypeSig::Opaque);
    try expectFieldSig(decl.fields, 1, "flag", ast::TypeSig::Bool);

    // Check default values.
    let case ast::NodeValue::RecordField { value: val0, .. } = decl.fields[0].value
        else throw testing::TestError::Failed;
    let v0 = val0 else throw testing::TestError::Failed;
    try expectNumber(v0, "42");

    let case ast::NodeValue::RecordField { value: val1, .. } = decl.fields[1].value
        else throw testing::TestError::Failed;
    let v1 = val1 else throw testing::TestError::Failed;
    let case ast::NodeValue::Bool(flagValue) = v1.value
        else throw testing::TestError::Failed;
    try testing::expect(flagValue);
}

/// Test parsing an unlabeled record declaration.
@test unsafe fn testParseTupleRecordDecl() throws (testing::TestError) {
    let node = try! parseStmtStr("record Pair(bool, i32);");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Pair");
    try testing::expect(not decl.labeled);
    try testing::expect(decl.derives.len == 0);
    try testing::expect(decl.fields.len == 2);

    try expectFieldSig(decl.fields, 0, nil, ast::TypeSig::Bool);
    try expectFieldSig(decl.fields, 1, nil, ast::TypeSig::Integer {
        width: 4,
        sign: ast::Signedness::Signed,
    });
}

/// Test parsing a single-field unlabeled record.
@test unsafe fn testParseTupleRecordSingleField() throws (testing::TestError) {
    let node = try! parseStmtStr("record R(bool);");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "R");
    try testing::expect(not decl.labeled);
    try testing::expect(decl.fields.len == 1);

    try expectFieldSig(decl.fields, 0, nil, ast::TypeSig::Bool);
}

/// Test parsing empty record literals.
@test unsafe fn testParseEmptyRecordLiteral() throws (testing::TestError) {
    let r1 = try! parseExprStr("{}");
    let case ast::NodeValue::RecordLit(lit) = r1.value
        else throw testing::TestError::Failed;

    try testing::expect(lit.typeName == nil);
    try testing::expect(lit.fields.len == 0);

    let r2 = try! parseExprStr("Point {}");
    let case ast::NodeValue::RecordLit(lit2) = r2.value
        else throw testing::TestError::Failed;

    let typeName = lit2.typeName else throw testing::TestError::Failed;
    try expectIdent(typeName, "Point");
    try testing::expect(lit2.fields.len == 0);
}

/// Test parsing a function type with parameters and return type.
@test unsafe fn testParseTypeFn() throws (testing::TestError) {
    let node = try! parseTypeStr("fn (i32, *u8) -> bool");
    let case ast::NodeValue::TypeSig(sigValue) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Fn { sig, .. } = sigValue
        else throw testing::TestError::Failed;

    try testing::expect(sig.params.len == 2);

    let param0 = sig.params[0];
    try expectIntType(param0, 4, ast::Signedness::Signed);

    let param1 = sig.params[1];
    let case ast::NodeValue::TypeSig(p1) = param1.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Pointer { valueType: ptrTarget, .. } = p1
        else throw testing::TestError::Failed;
    try expectIntType(ptrTarget, 1, ast::Signedness::Unsigned);

    try testing::expect(sig.returnType <> nil);
}

/// Test parsing a function type with a throws clause.
@test unsafe fn testParseTypeFnThrows() throws (testing::TestError) {
    let node = try! parseTypeStr("fn (i32) -> bool throws (Error, Other)");
    let case ast::NodeValue::TypeSig(sigValue) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Fn { sig, .. } = sigValue
        else throw testing::TestError::Failed;

    try testing::expect(sig.params.len == 1);
    try expectIntType(sig.params[0], 4, ast::Signedness::Signed);

    try testing::expect(sig.throwList.len == 2);
    try expectTypeIdent(sig.throwList[0], "Error");
    try expectTypeIdent(sig.throwList[1], "Other");

    let returnType = sig.returnType
        else throw testing::TestError::Failed;
    try expectType(returnType, ast::TypeSig::Bool);
}

/// Test parsing a function declaration without parameters.
@test unsafe fn testParseFnDeclEmpty() throws (testing::TestError) {
    let node = try! parseStmtStr("fn main() {}");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "main");
    try testing::expect(decl.sig.params.len == 0);
    try testing::expect(decl.sig.returnType == nil);
    try testing::expect(decl.attrs == nil);

    let body = decl.body else throw testing::TestError::Failed;
    let case ast::NodeValue::Block(_) = body.value
        else throw testing::TestError::Failed;
}

/// Test parsing a function declaration with parameters and return type.
@test unsafe fn testParseFnDeclParams() throws (testing::TestError) {
    let node = try! parseStmtStr("fn add(x: i32, y: *u8) -> bool {}");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "add");
    try testing::expect(decl.sig.params.len == 2);

    {
        let param0 = decl.sig.params[0];
        let case ast::NodeValue::FnParam(p0) = param0.value
            else throw testing::TestError::Failed;
        try expectIdent(p0.name, "x");
        try expectIntType(p0.type, 4, ast::Signedness::Signed);
    }
    {
        let param1 = decl.sig.params[1];
        let case ast::NodeValue::FnParam(p1) = param1.value
            else throw testing::TestError::Failed;
        try expectIdent(p1.name, "y");
        let case ast::NodeValue::TypeSig(sig1) = p1.type.value
            else throw testing::TestError::Failed;
        let case ast::TypeSig::Pointer { valueType, .. } = sig1
            else throw testing::TestError::Failed;
        try expectIntType(valueType, 1, ast::Signedness::Unsigned);
    }
    {
        let returnType = decl.sig.returnType
            else throw testing::TestError::Failed;
        try expectType(returnType, ast::TypeSig::Bool);

        let body = decl.body else throw testing::TestError::Failed;
        let case ast::NodeValue::Block(_) = body.value
            else throw testing::TestError::Failed;
    }
}

/// Test parsing a function declaration with a throws clause.
@test unsafe fn testParseFnDeclThrows() throws (testing::TestError) {
    let node = try! parseStmtStr("fn handle() throws (Error, Crash) {}");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "handle");
    try testing::expect(decl.sig.returnType == nil);

    try testing::expect(decl.sig.throwList.len == 2);
    try expectTypeIdent(decl.sig.throwList[0], "Error");
    try expectTypeIdent(decl.sig.throwList[1], "Crash");

    let body = decl.body else throw testing::TestError::Failed;
    let case ast::NodeValue::Block(_) = body.value
        else throw testing::TestError::Failed;
}

/// Test scanning source-level `void` produces an identifier, not a type keyword.
@test unsafe fn testParseTypeVoidRejected() throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
        let mut parser = super::mkParser(scanner::SourceLoc::String, "void", arenaRef, poolRef);
        super::advance(&mut parser);
        try testing::expect(super::check(&parser, scanner::TokenKind::Ident));
    }
}

/// Test parsing the unsafe function modifier.
@test unsafe fn testParseUnsafeFnDecl() throws (testing::TestError) {
    let node = try! parseStmtStr("unsafe fn run() {}");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;
    let attrs = decl.attrs
        else throw testing::TestError::Failed;

    try testing::expect(attrs.list.len == 1);
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Unsafe));
}

/// Test rejecting `unsafe` on declarations where it has no semantics.
@test unsafe fn testParseUnsafeUnsupportedDecl() throws (testing::TestError) {
    let recordDecl: ?*ast::Node = try? parseStmtStr("unsafe record R {}");
    try testing::expect(recordDecl == nil);
    let constDecl: ?*ast::Node = try? parseStmtStr("unsafe constant X = 1;");
    try testing::expect(constDecl == nil);
}

/// Test unsafe method declarations.
@test unsafe fn testParseUnsafeMethods() throws (testing::TestError) {
    let instanceNode = try! parseStmtStr(
        "instance Read for Value { unsafe fn (value: &Value) get() {} }"
    );
    let case ast::NodeValue::InstanceDecl { methods, .. } = instanceNode.value
        else throw testing::TestError::Failed;
    try testing::expect(methods.len == 1);
    let case ast::NodeValue::MethodDecl { modifiers, .. } = methods[0].value
        else throw testing::TestError::Failed;
    let attrs = modifiers.attrs;
    let methodAttrs = attrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&methodAttrs, ast::Attribute::Unsafe);

    static printStorage: [u8; 4096] = undefined;
    let mut printArena = alloc::new(&mut printStorage[..]);
    let methodExpr = printer::toExpr(&mut printArena, methods[0]);
    let case sexpr::Expr::Block { items: methodItems, .. } = methodExpr
        else throw testing::TestError::Failed;
    let case sexpr::Expr::List {
        head: methodAttrsHead, tail: printedMethodAttrs, ..
    } = methodItems[0] else throw testing::TestError::Failed;
    assert mem::eq(methodAttrsHead, "attrs");
    let case sexpr::Expr::Sym(methodAttr) = printedMethodAttrs[0]
        else throw testing::TestError::Failed;
    assert mem::eq(methodAttr, "@unsafe");

    let traitNode = try! parseStmtStr(
        "trait Read { unsafe fn (&Read) get(); }"
    );
    let case ast::NodeValue::TraitDecl { methods: traitMethods, .. } = traitNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TraitMethodSig {
        modifiers: traitModifiers, ..
    } = traitMethods[0].value else throw testing::TestError::Failed;
    let traitAttrs = traitModifiers.attrs;
    let traitMethodAttrs = traitAttrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&traitMethodAttrs, ast::Attribute::Unsafe);

    let traitMethodExpr = printer::toExpr(&mut printArena, traitMethods[0]);
    let case sexpr::Expr::List { tail: traitMethodItems, .. } = traitMethodExpr
        else throw testing::TestError::Failed;
    let case sexpr::Expr::List {
        head: traitAttrsHead, tail: printedTraitAttrs, ..
    } = traitMethodItems[0] else throw testing::TestError::Failed;
    assert mem::eq(traitAttrsHead, "attrs");
    let case sexpr::Expr::Sym(traitAttr) = printedTraitAttrs[0]
        else throw testing::TestError::Failed;
    assert mem::eq(traitAttr, "@unsafe");
}

/// Test region parameters on methods, trait methods, and instances.
@test unsafe fn testParseRegionalMethods() throws (testing::TestError) {
    let instanceNode = try! parseStmtStr(
        "instance Read for View 'view { fn (view: &View 'view) get 'method () -> &'method u32 { panic; } }"
    );
    let case ast::NodeValue::InstanceDecl { regions, methods, .. } = instanceNode.value
        else throw testing::TestError::Failed;
    try testing::expect(regions.len == 1 and methods.len == 1);
    let case ast::NodeValue::MethodDecl { modifiers, .. } = methods[0].value
        else throw testing::TestError::Failed;
    try testing::expect(modifiers.regions.len == 1);

    let traitNode = try! parseStmtStr(
        "trait Read { fn (&Read) get 'method () -> &'method u32; }"
    );
    let case ast::NodeValue::TraitDecl { methods: traitMethods, .. } = traitNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TraitMethodSig { modifiers: traitModifiers, .. } = traitMethods[0].value
        else throw testing::TestError::Failed;
    try testing::expect(traitModifiers.regions.len == 1);
}

/// Test parsing a function declaration with attributes.
@test unsafe fn testParseFnDeclAttributes() throws (testing::TestError) {
    let node = try! parseStmtStr("export fn run();");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "run");

    let attrs = decl.attrs
        else throw testing::TestError::Failed;

    try testing::expect(attrs.list.len == 2);

    let case ast::NodeValue::Attribute(attr0) = attrs.list[0].value
        else throw testing::TestError::Failed;
    try testing::expect(attr0 == ast::Attribute::Export);

    let case ast::NodeValue::Attribute(attr1) = attrs.list[1].value
        else throw testing::TestError::Failed;
    try testing::expect(attr1 == ast::Attribute::Extern);

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Export));
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Extern));
    try testing::expect(decl.body == nil);
}

/// Test parsing a top-level function declaration with inferred extern from `;`.
@test unsafe fn testParseFnDeclInferredExtern() throws (testing::TestError) {
    let node = try! parseStmtStr("fn run();");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "run");

    let attrs = decl.attrs
        else throw testing::TestError::Failed;

    try testing::expect(attrs.list.len == 1);

    let case ast::NodeValue::Attribute(attr0) = attrs.list[0].value
        else throw testing::TestError::Failed;
    try testing::expect(attr0 == ast::Attribute::Extern);

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Extern));
    try testing::expect(decl.body == nil);
}

/// Test parsing a top-level exported function declaration with inferred extern from `;`.
@test unsafe fn testParseFnDeclExportInferredExtern() throws (testing::TestError) {
    let node = try! parseStmtStr("export fn run();");
    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "run");

    let attrs = decl.attrs
        else throw testing::TestError::Failed;

    try testing::expect(attrs.list.len == 2);

    let case ast::NodeValue::Attribute(attr0) = attrs.list[0].value
        else throw testing::TestError::Failed;
    try testing::expect(attr0 == ast::Attribute::Export);

    let case ast::NodeValue::Attribute(attr1) = attrs.list[1].value
        else throw testing::TestError::Failed;
    try testing::expect(attr1 == ast::Attribute::Extern);

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Export));
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Extern));
    try testing::expect(decl.body == nil);
}

/// Test parsing a scoped identifier type.
@test unsafe fn testParseTypeScopedIdent() throws (testing::TestError) {
    let node = try! parseTypeStr("module::Type");
    let case ast::NodeValue::TypeSig(ts) = node.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Nominal(name) = ts
        else throw testing::TestError::Failed;
    let case ast::NodeValue::ScopeAccess(access) = name.value
        else throw testing::TestError::Failed;

    try expectIdent(access.parent, "module");
    try expectIdent(access.child, "Type");
}

/// Test parsing the `bool` type.
@test unsafe fn testParseTypeBool() throws (testing::TestError) {
    let node = try! parseTypeStr("bool");
    try expectType(node, ast::TypeSig::Bool);
}

/// Test parsing an unsigned integer type.
@test unsafe fn testParseTypeUnsigned() throws (testing::TestError) {
    let node = try! parseTypeStr("u8");
    try expectType(node, ast::TypeSig::Integer {
        width: 1,
        sign: ast::Signedness::Unsigned,
    });
}

/// Test parsing a simple `if let` statement without guard or else.
@test unsafe fn testParseIfLet() throws (testing::TestError) {
    let root = try! parseStmtStr("if let value = opt { body; }");
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "value");
    try expectIdent(node.pattern.scrutinee, "opt");

    try testing::expect(node.pattern.guard == nil);
    try expectBlockExprStmt(node.thenBranch, ast::NodeValue::Ident("body"));
    try testing::expect(node.elseBranch == nil);
}

/// Test parsing an `if let` statement with guard and else branches.
@test unsafe fn testParseIfLetGuardElse() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "if let value = opt; guard { body; } else { alt; }"
    );
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "value");
    try expectIdent(node.pattern.scrutinee, "opt");

    let guard = node.pattern.guard
        else throw testing::TestError::Failed;
    try expectIdent(guard, "guard");

    try expectBlockExprStmt(node.thenBranch, ast::NodeValue::Ident("body"));

    let elseBranch = node.elseBranch
        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing an `if let` statement with an `else if` chain.
@test unsafe fn testParseIfLetElseIf() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "if let value = opt { body; } else if cond { alt; }"
    );
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "value");

    let elseBranch = node.elseBranch
        else throw testing::TestError::Failed;

    let nested = try getBlockFirstStmt(elseBranch);
    let case ast::NodeValue::If(inner) = nested.value
        else throw testing::TestError::Failed;

    try expectIdent(inner.condition, "cond");
    try expectBlockExprStmt(inner.thenBranch, ast::NodeValue::Ident("alt"));
    try testing::expect(inner.elseBranch == nil);
}

/// Test parsing `if let mut` binding.
@test unsafe fn testParseIfLetMut() throws (testing::TestError) {
    let root = try! parseStmtStr("if let mut value = opt { body; }");
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "value");
    try expectIdent(node.pattern.scrutinee, "opt");
    try testing::expect(node.pattern.mutable);
    try testing::expect(node.pattern.guard == nil);
    try expectBlockExprStmt(node.thenBranch, ast::NodeValue::Ident("body"));
    try testing::expect(node.elseBranch == nil);
}

/// Test parsing `let mut ... else` binding.
@test unsafe fn testParseLetMutElse() throws (testing::TestError) {
    let root = try! parseStmtStr("let mut x = opt else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(letElse.pattern.pattern, "x");
    try testing::expect(letElse.pattern.mutable);
}

/// Test that `if let` without `mut` is not mutable.
@test unsafe fn testParseIfLetNotMutable() throws (testing::TestError) {
    let root = try! parseStmtStr("if let value = opt { body; }");
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(not node.pattern.mutable);
}

/// Test that `let ... else` without `mut` is not mutable.
@test unsafe fn testParseLetElseNotMutable() throws (testing::TestError) {
    let root = try! parseStmtStr("let x = opt else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(not letElse.pattern.mutable);
}

/// Test parsing a simple `if let case` statement.
@test unsafe fn testParseIfCase() throws (testing::TestError) {
    let root = try! parseStmtStr("if let case pat = value { body; }");
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "pat");
    try expectIdent(node.pattern.scrutinee, "value");
    try testing::expect(node.pattern.guard == nil);
    try expectBlockExprStmt(node.thenBranch, ast::NodeValue::Ident("body"));
    try testing::expect(node.elseBranch == nil);
}

/// Test parsing an `if let case` statement with guard and else branches.
@test unsafe fn testParseIfCaseGuardElse() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "if let case pat = value; guard { body; } else { alt; }"
    );
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "pat");
    try expectIdent(node.pattern.scrutinee, "value");

    let guard = node.pattern.guard
        else throw testing::TestError::Failed;
    try expectIdent(guard, "guard");

    try expectBlockExprStmt(node.thenBranch, ast::NodeValue::Ident("body"));

    let elseBranch = node.elseBranch
        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing an `if let case` statement with an `else if` chain.
@test unsafe fn testParseIfCaseElseIf() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "if let case pat = value { body; } else if cond { alt; }"
    );
    let case ast::NodeValue::IfLet(node) = root.value
        else throw testing::TestError::Failed;

    let elseBranch = node.elseBranch
        else throw testing::TestError::Failed;

    let nested = try getBlockFirstStmt(elseBranch);
    let case ast::NodeValue::If(inner) = nested.value
        else throw testing::TestError::Failed;

    try expectIdent(inner.condition, "cond");
    try expectBlockExprStmt(inner.thenBranch, ast::NodeValue::Ident("alt"));
    try testing::expect(inner.elseBranch == nil);
}

/// Test parsing a simple `while` loop without an `else` branch.
@test unsafe fn testParseWhile() throws (testing::TestError) {
    let root = try! parseStmtStr("while cond { body; }");
    let case ast::NodeValue::While(loopNode) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(loopNode.condition, "cond");
    try expectBlockExprStmt(loopNode.body, ast::NodeValue::Ident("body"));
    try testing::expect(loopNode.elseBranch == nil);
}

/// Test parsing a `while` loop with an `else` branch.
@test unsafe fn testParseWhileElse() throws (testing::TestError) {
    let root = try! parseStmtStr("while cond { body; } else { alt; }");
    let case ast::NodeValue::While(loopNode) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(loopNode.condition, "cond");
    try expectBlockExprStmt(loopNode.body, ast::NodeValue::Ident("body"));

    let elseBranch = loopNode.elseBranch
        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing a simple `while let case` loop.
@test unsafe fn testParseWhileCase() throws (testing::TestError) {
    let root = try! parseStmtStr("while let case pat = value { body; }");
    let case ast::NodeValue::WhileLet(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.pattern.pattern, "pat");
    try expectIdent(node.pattern.scrutinee, "value");
    try testing::expect(node.pattern.guard == nil);
    try expectBlockExprStmt(node.body, ast::NodeValue::Ident("body"));
    try testing::expect(node.elseBranch == nil);
}

/// Test parsing a `while let case` loop with guard and else branches.
@test unsafe fn testParseWhileCaseGuardElse() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "while let case pat = value; guard { body; } else { alt; }"
    );
    let case ast::NodeValue::WhileLet(node) = root.value
        else throw testing::TestError::Failed;

    let guard = node.pattern.guard
        else throw testing::TestError::Failed;
    try expectIdent(guard, "guard");

    try expectBlockExprStmt(node.body, ast::NodeValue::Ident("body"));

    let elseBranch = node.elseBranch
        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing a simple `try` expression without catch.
@test unsafe fn testParseTry() throws (testing::TestError) {
    let root = try! parseExprStr("try value");
    let case ast::NodeValue::Try(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.expr, "value");
    try testing::expect(node.catches.len == 0);
    try testing::expect(not node.shouldPanic);
}

/// Test that `try?` consumes a unary operand.
@test unsafe fn testParseTryOptionalUnary() throws (testing::TestError) {
    let root = try! parseExprStr("try? -value");
    let case ast::NodeValue::Try(node) = root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::UnOp(neg) = node.expr.value
        else throw testing::TestError::Failed;
    try testing::expect(neg.op == ast::UnaryOp::Neg);
    try expectIdent(neg.value, "value");
    try testing::expect(node.returnsOptional);
}

/// Test parsing a `try!` expression that panics on error.
@test unsafe fn testParseTryBang() throws (testing::TestError) {
    let root = try! parseExprStr("try! value");
    let case ast::NodeValue::Try(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.expr, "value");
    try testing::expect(node.catches.len == 0);
    try testing::expect(node.shouldPanic);
}

/// Test parsing a `try` expression with a `catch` block.
@test unsafe fn testParseTryCatchBlock() throws (testing::TestError) {
    let root = try! parseExprStr("try value catch { alt; }");
    let case ast::NodeValue::Try(node) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(node.expr, "value");
    try testing::expect(node.catches.len == 1);

    let case ast::NodeValue::CatchClause(clause) = node.catches[0].value
        else throw testing::TestError::Failed;
    try testing::expect(clause.binding == nil);
    try testing::expect(clause.typeNode == nil);
    try expectBlockExprStmt(clause.body, ast::NodeValue::Ident("alt"));
}

/// Test that `catch` without a block is rejected.
@test unsafe fn testParseTryCatchExprRejected() throws (testing::TestError) {
    let parsed: ?*ast::Node = try? parseExprStr("try value catch alternate");
    try testing::expect(parsed == nil);
}

/// Test parsing a `break` statement.
@test unsafe fn testParseBreak() throws (testing::TestError) {
    let root = try! parseStmtStr("break");
    let case ast::NodeValue::Break= root.value
        else throw testing::TestError::Failed;
}

/// Test parsing a `continue` statement.
@test unsafe fn testParseContinue() throws (testing::TestError) {
    let root = try! parseStmtStr("continue");
    let case ast::NodeValue::Continue= root.value
        else throw testing::TestError::Failed;
}

/// Test parsing a `return` statement without value.
@test unsafe fn testParseReturnVoid() throws (testing::TestError) {
    let root = try! parseStmtStr("return");
    let case ast::NodeValue::Return(retValue) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(retValue == nil);
}

/// Test parsing a `return` statement with a value.
@test unsafe fn testParseReturnValue() throws (testing::TestError) {
    let root = try! parseStmtStr("return result");
    let case ast::NodeValue::Return(retValue) = root.value
        else throw testing::TestError::Failed;

    let value = retValue
        else throw testing::TestError::Failed;
    try expectIdent(value, "result");
}

/// Test parsing a `throw` statement.
@test unsafe fn testParseThrow() throws (testing::TestError) {
    let root = try! parseStmtStr("throw error");
    let case ast::NodeValue::Throw(throwExpr) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(throwExpr, "error");
}

/// Test parsing a `panic` statement without a message.
@test unsafe fn testParsePanicEmpty() throws (testing::TestError) {
    let root = try! parseStmtStr("panic");
    let case ast::NodeValue::Panic(panicMsg) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(panicMsg == nil);
}

/// Test parsing a `panic` statement with a message.
@test unsafe fn testParsePanicMessage() throws (testing::TestError) {
    let root = try! parseStmtStr("panic \"something went wrong\"");
    let case ast::NodeValue::Panic(panicMsg) = root.value
        else throw testing::TestError::Failed;

    let message = panicMsg
        else throw testing::TestError::Failed;
    let case ast::NodeValue::String(msgStr) = message.value if mem::eq(msgStr, "something went wrong")
        else throw testing::TestError::Failed;
}

/// Test parsing a `panic` statement with braces.
@test unsafe fn testParsePanicBraces() throws (testing::TestError) {
    let root = try! parseStmtStr("panic { \"error\" }");
    let case ast::NodeValue::Panic(panicMsg) = root.value
        else throw testing::TestError::Failed;

    let message = panicMsg
        else throw testing::TestError::Failed;
    let case ast::NodeValue::String(msgStr) = message.value if mem::eq(msgStr, "error")
        else throw testing::TestError::Failed;
}

/// Test parsing a simple `match` statement with one case.
@test unsafe fn testParseMatchSingle() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { case pattern => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(sw.subject, "subject");
    try testing::expect(sw.prongs.len == 1);

    let caseNode = sw.prongs[0];
    let case ast::NodeValue::MatchProng(prong) = caseNode.value
        else throw testing::TestError::Failed;

    let case ast::ProngArm::Case(patterns) = prong.arm
        else throw testing::TestError::Failed;
    try testing::expect(patterns.len == 1);
    try expectIdent(patterns[0], "pattern");
    try testing::expect(prong.guard == nil);

    let case ast::NodeValue::ExprStmt(bodyStmt) = prong.body.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Ident(name) = bodyStmt.value
        if mem::eq(name, "body")
        else throw testing::TestError::Failed;
}

/// Test parsing a `match` case with guard and multiple patterns.
@test unsafe fn testParseMatchGuard() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "match subject { case left, right if cond => handle }"
    );
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;

    let case ast::ProngArm::Case(patterns) = prong.arm
        else throw testing::TestError::Failed;
    try testing::expect(patterns.len == 2);
    try expectIdent(patterns[0], "left");
    try expectIdent(patterns[1], "right");

    let guard = prong.guard
        else throw testing::TestError::Failed;
    try expectIdent(guard, "cond");
}

/// Test parsing `match` prongs whose bodies omit trailing semicolons.
@test unsafe fn testParseMatchReturnNoSemicolon() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "match subject { case First => return, case Second => return }"
    );
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 2);

    let firstCaseNode = sw.prongs[0];
    let case ast::NodeValue::MatchProng(firstProng) = firstCaseNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Return(firstRetVal) = firstProng.body.value
        else throw testing::TestError::Failed;
    try testing::expect(firstRetVal == nil);

    let secondCaseNode = sw.prongs[1];
    let case ast::NodeValue::MatchProng(secondProng) = secondCaseNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Return(secondRetVal) = secondProng.body.value
        else throw testing::TestError::Failed;
    try testing::expect(secondRetVal == nil);
}

/// Test parsing a `match` statement with multiple branches.
@test unsafe fn testParseMatchMultipleCases() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "match subject { case First => first, case Second => second }"
    );
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 2);
    {
        let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
            else throw testing::TestError::Failed;
        let case ast::ProngArm::Case(patterns) = prong.arm
            else throw testing::TestError::Failed;
        try testing::expect(patterns.len == 1);
        try expectIdent(patterns[0], "First");
        let case ast::NodeValue::ExprStmt(stmt) = prong.body.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Ident(val) = stmt.value
            if mem::eq(val, "first")
            else throw testing::TestError::Failed;
    } {
        let case ast::NodeValue::MatchProng(prong) = sw.prongs[1].value
            else throw testing::TestError::Failed;
        let case ast::ProngArm::Case(pats) = prong.arm
            else throw testing::TestError::Failed;

        try testing::expect(pats.len == 1);
        try expectIdent(pats[0], "Second");

        let case ast::NodeValue::ExprStmt(stmt) = prong.body.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Ident(val) = stmt.value
            if mem::eq(val, "second")
            else throw testing::TestError::Failed;
    }
}

/// Test parsing a `match` case whose body is a block.
@test unsafe fn testParseMatchProngBlock() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { case Pattern => { body; } }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    try expectBlockExprStmt(prong.body, ast::NodeValue::Ident("body"));
}

/// Test parsing a `match` statement with an `else` case.
@test unsafe fn testParseMatchElse() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { else => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    // Else prong has no pattern.
    let case ast::ProngArm::Else = prong.arm
        else throw testing::TestError::Failed;
    try testing::expect(prong.guard == nil);

    let case ast::NodeValue::ExprStmt(bodyStmt) = prong.body.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Ident(name) = bodyStmt.value
        if mem::eq(name, "body")
        else throw testing::TestError::Failed;
}

/// Test parsing a `match` statement with a binding prong.
@test unsafe fn testParseMatchBinding() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { x => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    // Binding prong has single identifier pattern.
    let case ast::ProngArm::Binding(pat) = prong.arm
        else throw testing::TestError::Failed;
    try expectIdent(pat, "x");
    try testing::expect(prong.guard == nil);

    let case ast::NodeValue::ExprStmt(bodyStmt) = prong.body.value
        else throw testing::TestError::Failed;
    try expectIdent(bodyStmt, "body");
}

/// Test parsing a `match` statement with a guarded binding prong.
@test unsafe fn testParseMatchBindingGuard() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { x if x > 0 => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    // Binding prong has single identifier pattern.
    let case ast::ProngArm::Binding(pat) = prong.arm
        else throw testing::TestError::Failed;
    try expectIdent(pat, "x");

    let guard = prong.guard else throw testing::TestError::Failed;
    let case ast::NodeValue::BinOp(binop) = guard.value
        else throw testing::TestError::Failed;
    try testing::expect(binop.op == ast::BinaryOp::Gt);
}

/// Test parsing a `match` statement with a `_` wildcard.
@test unsafe fn testParseMatchWildcard() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { _ => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    // Wildcard binding prong has single placeholder pattern.
    let case ast::ProngArm::Binding(pat) = prong.arm
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Placeholder = pat.value
        else throw testing::TestError::Failed;
    try testing::expect(prong.guard == nil);

    let case ast::NodeValue::ExprStmt(bodyStmt) = prong.body.value
        else throw testing::TestError::Failed;
    try expectIdent(bodyStmt, "body");
}

/// Test parsing a `match` statement with a guarded `_` wildcard.
@test unsafe fn testParseMatchWildcardGuard() throws (testing::TestError) {
    let root = try! parseStmtStr("match subject { _ if cond => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    // Guarded wildcard binding prong has single placeholder pattern.
    let case ast::ProngArm::Binding(pat) = prong.arm
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Placeholder = pat.value
        else throw testing::TestError::Failed;

    let guard = prong.guard else throw testing::TestError::Failed;
    try expectIdent(guard, "cond");
    let case ast::NodeValue::ExprStmt(bodyStmt) = prong.body.value
        else throw testing::TestError::Failed;
    try expectIdent(bodyStmt, "body");
}

/// Test parsing a `while let` loop with guard and else branches.
@test unsafe fn testParseWhileLet() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "while let value = opt; guard { body; } else { alt; }"
    );
    let case ast::NodeValue::WhileLet(loopNode) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(loopNode.pattern.pattern, "value");
    try expectIdent(loopNode.pattern.scrutinee, "opt");

    let guard = loopNode.pattern.guard
        else throw testing::TestError::Failed;
    try expectIdent(guard, "guard");

    try expectBlockExprStmt(loopNode.body, ast::NodeValue::Ident("body"));

    let elseBranch = loopNode.elseBranch
        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing a simple `loop` statement.
@test unsafe fn testParseLoop() throws (testing::TestError) {
    let root = try! parseStmtStr("loop { body; }");
    let case ast::NodeValue::Loop(loopBody) = root.value
        else throw testing::TestError::Failed;

    try expectBlockExprStmt(loopBody, ast::NodeValue::Ident("body"));
}

/// Test parsing a `for` loop without index or else branches.
@test unsafe fn testParseFor() throws (testing::TestError) {
    let root = try! parseStmtStr("for item in items { body; }");
    let case ast::NodeValue::For(loopNode) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(loopNode.binding, "item");
    try testing::expect(loopNode.index == nil);

    try expectIdent(loopNode.iterable, "items");
    try expectBlockExprStmt(loopNode.body, ast::NodeValue::Ident("body"));
    try testing::expect(loopNode.elseBranch == nil);
}

/// Test parsing a `for` loop over a range expression.
@test unsafe fn testParseForRangeIterable() throws (testing::TestError) {
    let root = try! parseStmtStr("for item in 0..5 {}");
    let case ast::NodeValue::For(loopNode) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(loopNode.binding, "item");
    try testing::expect(loopNode.index == nil);
    try expectRangeNumbers(loopNode.iterable, "0", "5");

    let case ast::NodeValue::Block(body) = loopNode.body.value
        else throw testing::TestError::Failed;
    try testing::expect(body.statements.len == 0);
    try testing::expect(loopNode.elseBranch == nil);
}

/// Test parsing a `for` loop with index and else branches.
@test unsafe fn testParseForIndexElse() throws (testing::TestError) {
    let root = try! parseStmtStr(
        "for value, idx in items { body; } else { alt; }"
    );
    let case ast::NodeValue::For(loopNode) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(loopNode.binding, "value");

    let index = loopNode.index
        else throw testing::TestError::Failed;
    try expectIdent(index, "idx");

    try expectIdent(loopNode.iterable, "items");
    try expectBlockExprStmt(loopNode.body, ast::NodeValue::Ident("body"));

    let elseBranch = loopNode.elseBranch
        else throw testing::TestError::Failed;
    try expectBlockExprStmt(elseBranch, ast::NodeValue::Ident("alt"));
}

/// Test parsing field access expression.
@test unsafe fn testParseFieldAccess() throws (testing::TestError) {
    let root = try! parseExprStr("obj.field");
    let case ast::NodeValue::FieldAccess(access) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(access.parent, "obj");
    try expectIdent(access.child, "field");
}

/// Test parsing scope access expression.
@test unsafe fn testParseScopeAccess() throws (testing::TestError) {
    let root = try! parseExprStr("module::item");
    let case ast::NodeValue::ScopeAccess(access) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(access.parent, "module");
    try expectIdent(access.child, "item");
}

/// Test parsing array subscript expression.
@test unsafe fn testParseArraySubscript() throws (testing::TestError) {
    let root = try! parseExprStr("array[index]");
    let case ast::NodeValue::Subscript { container, index } = root.value
        else throw testing::TestError::Failed;

    try expectIdent(container, "array");
    try expectIdent(index, "index");
}

/// Test parsing array slicing expressions.
@test unsafe fn testParseArraySlicing() throws (testing::TestError) {
    // Test `array[start..end]`.
    {
        let expr = try! parseExprStr("array[1..10]");
        let case ast::NodeValue::Subscript { container: subContainer, index: subIndex } = expr.value
            else throw testing::TestError::Failed;
        try expectIdent(subContainer, "array");

        let case ast::NodeValue::Range(range) = subIndex.value
            else throw testing::TestError::Failed;
        let start = range.start
            else throw testing::TestError::Failed;
        let end = range.end
            else throw testing::TestError::Failed;
        try expectNumber(start, "1");
        try expectNumber(end, "10");
    }
    // Test `array[start..]`.
    {
        let expr = try! parseExprStr("array[5..]");
        let case ast::NodeValue::Subscript { container: subContainer, index: subIndex } = expr.value
            else throw testing::TestError::Failed;
        try expectIdent(subContainer, "array");

        let case ast::NodeValue::Range(range) = subIndex.value
            else throw testing::TestError::Failed;
        let start = range.start
            else throw testing::TestError::Failed;
        try expectNumber(start, "5");
        try testing::expect(range.end == nil);
    }
    // Test `array[..end]`.
    {
        let expr = try! parseExprStr("array[..10]");
        let case ast::NodeValue::Subscript { container: subContainer, index: subIndex } = expr.value
            else throw testing::TestError::Failed;
        try expectIdent(subContainer, "array");

        let case ast::NodeValue::Range(range) = subIndex.value
            else throw testing::TestError::Failed;
        try testing::expect(range.start == nil);
        let end = range.end
            else throw testing::TestError::Failed;
        try expectNumber(end, "10");
    }
    // Test `array[..]`.
    {
        let expr = try! parseExprStr("array[..]");
        let case ast::NodeValue::Subscript { container: subContainer, index: subIndex } = expr.value
            else throw testing::TestError::Failed;
        try expectIdent(subContainer, "array");

        let case ast::NodeValue::Range(range) = subIndex.value
            else throw testing::TestError::Failed;
        try testing::expect(range.start == nil);
        try testing::expect(range.end == nil);
    }
}

/// Test parsing function call expression.
@test unsafe fn testParseFunctionCall() throws (testing::TestError) {
    let root = try! parseExprStr("func(x, y)");
    let case ast::NodeValue::Call(call) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(call.callee, "func");
    try testing::expect(call.args.len == 2);
    try expectIdent(call.args[0], "x");
    try expectIdent(call.args[1], "y");
}

/// Test parsing chained postfix operators.
@test unsafe fn testParseChainedPostfix() throws (testing::TestError) {
    let root = try! parseExprStr("obj.method(arg)[0]");
    let case ast::NodeValue::Subscript { container: subContainer, index: subIndex } = root.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::Call(call) = subContainer.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::FieldAccess(fieldAccess) = call.callee.value
        else throw testing::TestError::Failed;

    try expectIdent(fieldAccess.parent, "obj");
    try expectIdent(fieldAccess.child, "method");
    try testing::expect(call.args.len == 1);
    try expectIdent(call.args[0], "arg");
}

/// Test parsing a literal cast using `as`.
@test unsafe fn testParseAsCastLiteral() throws (testing::TestError) {
    let root = try! parseExprStr("1 as i32");
    let case ast::NodeValue::As(asExpr) = root.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::Number(_) = asExpr.value.value
        else throw testing::TestError::Failed;

    try expectIntType(asExpr.type, 4, ast::Signedness::Signed);
}

/// Test parsing a cast following chained postfix expressions.
@test unsafe fn testParseAsCastWithPostfix() throws (testing::TestError) {
    let root = try! parseExprStr("value.method(arg) as u32");
    let case ast::NodeValue::As(asExpr) = root.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::Call(call) = asExpr.value.value
        else throw testing::TestError::Failed;

    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw testing::TestError::Failed;

    try expectIdent(access.parent, "value");
    try expectIdent(access.child, "method");
    try testing::expect(call.args.len == 1);
    try expectIdent(call.args[0], "arg");
    try expectIntType(asExpr.type, 4, ast::Signedness::Unsigned);
}

/// Test parsing @sizeOf builtin.
@test unsafe fn testParseBuiltinSizeOf() throws (testing::TestError) {
    let expr = try! parseExprStr("@sizeOf(i32)");
    let case ast::NodeValue::BuiltinCall { kind: builtinKind, args: builtinArgs } = expr.value
        else throw testing::TestError::Failed;

    try testing::expect(builtinKind == ast::Builtin::SizeOf);
    try testing::expect(builtinArgs.len == 1);
    try expectType(builtinArgs[0], ast::TypeSig::Integer {
        width: 4,
        sign: ast::Signedness::Signed,
    });
}

/// Test parsing @alignOf builtin.
@test unsafe fn testParseBuiltinAlignOf() throws (testing::TestError) {
    let expr = try! parseExprStr("@alignOf(i32)");
    let case ast::NodeValue::BuiltinCall { kind: builtinKind, args: builtinArgs } = expr.value
        else throw testing::TestError::Failed;

    try testing::expect(builtinKind == ast::Builtin::AlignOf);
    try testing::expect(builtinArgs.len == 1);
    try expectType(builtinArgs[0], ast::TypeSig::Integer {
        width: 4,
        sign: ast::Signedness::Signed,
    });
}

/// Test parsing @sliceOf with varying argument counts.
@test unsafe fn testParseBuiltinSliceOf() throws (testing::TestError) {
    // Two arguments.
    {
        let expr = try! parseExprStr("@sliceOf(ptr, len)");
        let case ast::NodeValue::BuiltinCall { kind: builtinKind, args: builtinArgs } = expr.value
            else throw testing::TestError::Failed;
        try testing::expect(builtinKind == ast::Builtin::SliceOf);
        try testing::expect(builtinArgs.len == 2);
    }
    // One argument.
    {
        let expr = try! parseExprStr("@sliceOf(ptr)");
        let case ast::NodeValue::BuiltinCall { kind: builtinKind, args: builtinArgs } = expr.value
            else throw testing::TestError::Failed;
        try testing::expect(builtinKind == ast::Builtin::SliceOf);
        try testing::expect(builtinArgs.len == 1);
    }
    // Three arguments.
    {
        let expr = try! parseExprStr("@sliceOf(ptr, len, extra)");
        let case ast::NodeValue::BuiltinCall { kind: builtinKind, args: builtinArgs } = expr.value
            else throw testing::TestError::Failed;
        try testing::expect(builtinKind == ast::Builtin::SliceOf);
        try testing::expect(builtinArgs.len == 3);
    }
}

/// Test parsing prefix unary operators.
@test unsafe fn testParseUnaryOperators() throws (testing::TestError) {
    {
        let notExpr = try! parseExprStr("not flag");
        let case ast::NodeValue::UnOp(notNode) = notExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(notNode.op == ast::UnaryOp::Not);
        try expectIdent(notNode.value, "flag");
    }
    {
        let negExpr = try! parseExprStr("-value");
        let case ast::NodeValue::UnOp(negNode) = negExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(negNode.op == ast::UnaryOp::Neg);
        try expectIdent(negNode.value, "value");
    }
    {
        let bitNotExpr = try! parseExprStr("~mask");
        let case ast::NodeValue::UnOp(bitNotNode) = bitNotExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(bitNotNode.op == ast::UnaryOp::BitNot);
        try expectIdent(bitNotNode.value, "mask");
    }
}

/// Test parsing dereference expressions.
@test unsafe fn testParseDereference() throws (testing::TestError) {
    {
        let derefExpr = try! parseExprStr("*ptr");
        let case ast::NodeValue::Deref(target) = derefExpr.value
            else throw testing::TestError::Failed;
        try expectIdent(target, "ptr");
    }
    {
        let derefField = try! parseExprStr("*ptr.field");
        let case ast::NodeValue::Deref(target) = derefField.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::FieldAccess(access) = target.value
            else throw testing::TestError::Failed;
        try expectIdent(access.parent, "ptr");
        try expectIdent(access.child, "field");
    }
}

/// Test parsing reference (address-of) expressions.
@test unsafe fn testParseRefs() throws (testing::TestError) {
    {
        let expr = try! parseExprStr("&cell obj.field");
        let case ast::NodeValue::AddressOf(address) = expr.value
            else throw testing::TestError::Failed;
        try testing::expect(
            address.kind == ast::AddressKind::Cell and address.permission == nil
        );
        let case ast::NodeValue::FieldAccess(access) = address.target.value
            else throw testing::TestError::Failed;
        try expectIdent(access.parent, "obj");
        try expectIdent(access.child, "field");
    }
    {
        let expr = try! parseExprStr("&cell 'permission obj.field");
        let case ast::NodeValue::AddressOf(address) = expr.value
            else throw testing::TestError::Failed;
        let permission = address.permission else throw testing::TestError::Failed;
        let case ast::NodeValue::Region { name, parent: nil } = permission.value
            else throw testing::TestError::Failed;
        try testing::expect(
            address.kind == ast::AddressKind::Cell and mem::eq(name, "'permission")
        );
        let case ast::NodeValue::FieldAccess(access) = address.target.value
            else throw testing::TestError::Failed;
        try expectIdent(access.parent, "obj");
        try expectIdent(access.child, "field");
    }
    {
        let refExpr = try! parseExprStr("&foo");
        let case ast::NodeValue::AddressOf(refNode) = refExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(
            refNode.kind == ast::AddressKind::Shared and refNode.permission == nil
        );
        try expectIdent(refNode.target, "foo");
    }
    {
        let mutRefExpr = try! parseExprStr("&mut bar");
        let case ast::NodeValue::AddressOf(mutRefNode) = mutRefExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(
            mutRefNode.kind == ast::AddressKind::Mutable and mutRefNode.permission == nil
        );
        try expectIdent(mutRefNode.target, "bar");
    }
    {
        let refFieldExpr = try! parseExprStr("&obj.field");
        let case ast::NodeValue::AddressOf(refFieldNode) = refFieldExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(
            refFieldNode.kind == ast::AddressKind::Shared and refFieldNode.permission == nil
        );
        let case ast::NodeValue::FieldAccess(access) = refFieldNode.target.value
            else throw testing::TestError::Failed;
        try expectIdent(access.parent, "obj");
        try expectIdent(access.child, "field");
    }
    {
        let mutRefFieldExpr = try! parseExprStr("&mut obj.field");
        let case ast::NodeValue::AddressOf(mutRefFieldNode) = mutRefFieldExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(
            mutRefFieldNode.kind == ast::AddressKind::Mutable
            and mutRefFieldNode.permission == nil
        );
        let case ast::NodeValue::FieldAccess(access) = mutRefFieldNode.target.value
            else throw testing::TestError::Failed;
        try expectIdent(access.parent, "obj");
        try expectIdent(access.child, "field");
    }
    for source in ["&'permission obj.field", "&mut 'permission obj.field"] {
        let parsed = try? parseExprStr(source);
        try testing::expect(parsed == nil);
    }
}

/// Test unary operator precedence relative to binary and postfix expressions.
@test unsafe fn testParseUnaryPrecedence() throws (testing::TestError) {
    {
        let expr = try! parseExprStr("not a and b");
        let case ast::NodeValue::BinOp(bin) = expr.value
            else throw testing::TestError::Failed;
        try testing::expect(bin.op == ast::BinaryOp::And);
        let case ast::NodeValue::UnOp(leftUnary) = bin.left.value
            else throw testing::TestError::Failed;
        try testing::expect(leftUnary.op == ast::UnaryOp::Not);
        try expectIdent(leftUnary.value, "a");
        try expectIdent(bin.right, "b");
    }
    {
        let mulExpr = try! parseExprStr("-x * y");
        let case ast::NodeValue::BinOp(mul) = mulExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(mul.op == ast::BinaryOp::Mul);
        let case ast::NodeValue::UnOp(leftNeg) = mul.left.value
            else throw testing::TestError::Failed;
        try testing::expect(leftNeg.op == ast::UnaryOp::Neg);
        try expectIdent(leftNeg.value, "x");
        try expectIdent(mul.right, "y");
    }
    {
        let callExpr = try! parseExprStr("not func()");
        let case ast::NodeValue::UnOp(callNot) = callExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(callNot.op == ast::UnaryOp::Not);
        let case ast::NodeValue::Call(call) = callNot.value.value
            else throw testing::TestError::Failed;
        try expectIdent(call.callee, "func");
    }
}

/// Test parsing assignment expressions.
@test unsafe fn testParseAssignment() throws (testing::TestError) {
    {
        let assign = try! parseStmtStr("set x = 1;");
        let case ast::NodeValue::Assign(node) = assign.value
            else throw testing::TestError::Failed;
        try expectIdent(node.left, "x");
        let case ast::NodeValue::Number(_) = node.right.value
            else throw testing::TestError::Failed;
    }
    {
        let assign = try! parseStmtStr("set obj.field = value;");
        let case ast::NodeValue::Assign(node) = assign.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::FieldAccess(access) = node.left.value
            else throw testing::TestError::Failed;
        try expectIdent(access.parent, "obj");
        try expectIdent(access.child, "field");
        try expectIdent(node.right, "value");
    }
    {
        let assign = try! parseStmtStr("set *ptr = rhs;");
        let case ast::NodeValue::Assign(node) = assign.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Deref(target) = node.left.value
            else throw testing::TestError::Failed;
        try expectIdent(target, "ptr");
        try expectIdent(node.right, "rhs");
    }
    {
        let assign = try! parseStmtStr("set x = 1 + 2;");
        let case ast::NodeValue::Assign(node) = assign.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::BinOp(bin) = node.right.value
            else throw testing::TestError::Failed;
        try testing::expect(bin.op == ast::BinaryOp::Add);
    }
    {
        let assign = try! parseStmtStr("set module::VAR = 1;");
        let case ast::NodeValue::Assign(node) = assign.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::ScopeAccess(access) = node.left.value
            else throw testing::TestError::Failed;
        try expectIdent(access.parent, "module");
        try expectIdent(access.child, "VAR");
    }
}

/// Test that assignment syntax requires the `set` statement.
@test unsafe fn testAssignmentRequiresSetKeyword() throws (testing::TestError) {
    let assign: ?*ast::Node = try? parseStmtStr("x = 1;");
    try testing::expect(assign == nil);

    let compoundAssign: ?*ast::Node = try? parseStmtStr("x += 1;");
    try testing::expect(compoundAssign == nil);
}

/// Test that `set` requires an assignable target.
@test unsafe fn testSetRequiresAssignableTarget() throws (testing::TestError) {
    let binTarget: ?*ast::Node = try? parseStmtStr("set x + y = 1;");
    try testing::expect(binTarget == nil);

    let condTarget: ?*ast::Node = try? parseStmtStr("set x if ok else y = 1;");
    try testing::expect(condTarget == nil);
}

/// Test parsing basic arithmetic binary operators (+, -, *, /, %).
@test unsafe fn testParseBinOpArithmetic() throws (testing::TestError) {
    let add = try! parseExprStr("a + b");
    let case ast::NodeValue::BinOp(op1) = add.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::Add);
    try expectIdent(op1.left, "a");
    try expectIdent(op1.right, "b");

    let sub = try! parseExprStr("x - y");
    let case ast::NodeValue::BinOp(op2) = sub.value
        else throw testing::TestError::Failed;
    try testing::expect(op2.op == ast::BinaryOp::Sub);

    let mul = try! parseExprStr("a * b");
    let case ast::NodeValue::BinOp(op3) = mul.value
        else throw testing::TestError::Failed;
    try testing::expect(op3.op == ast::BinaryOp::Mul);

    let div = try! parseExprStr("x / y");
    let case ast::NodeValue::BinOp(op4) = div.value
        else throw testing::TestError::Failed;
    try testing::expect(op4.op == ast::BinaryOp::Div);

    let modOp = try! parseExprStr("a % b");
    let case ast::NodeValue::BinOp(op5) = modOp.value
        else throw testing::TestError::Failed;
    try testing::expect(op5.op == ast::BinaryOp::Mod);
}

/// Test parsing comparison binary operators (==, <>).
@test unsafe fn testParseBinOpEq() throws (testing::TestError) {
    let eq = try! parseExprStr("a == b");
    let case ast::NodeValue::BinOp(op1) = eq.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::Eq);

    let ne = try! parseExprStr("x <> y");
    let case ast::NodeValue::BinOp(op2) = ne.value
        else throw testing::TestError::Failed;
    try testing::expect(op2.op == ast::BinaryOp::Ne);
}

/// Test parsing comparison binary operators.
@test unsafe fn testParseBinOpGtLt() throws (testing::TestError) {
    let lt = try! parseExprStr("a < b");
    let case ast::NodeValue::BinOp(op1) = lt.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::Lt);

    let gt = try! parseExprStr("x > y");
    let case ast::NodeValue::BinOp(op2) = gt.value
        else throw testing::TestError::Failed;
    try testing::expect(op2.op == ast::BinaryOp::Gt);

    let lte = try! parseExprStr("a <= b");
    let case ast::NodeValue::BinOp(op3) = lte.value
        else throw testing::TestError::Failed;
    try testing::expect(op3.op == ast::BinaryOp::Lte);

    let gte = try! parseExprStr("x >= y");
    let case ast::NodeValue::BinOp(op4) = gte.value
        else throw testing::TestError::Failed;
    try testing::expect(op4.op == ast::BinaryOp::Gte);
}

/// Test parsing bitwise binary operators (&, |, ^, <<, >>).
@test unsafe fn testParseBinOpBitwise() throws (testing::TestError) {
    let bitAnd = try! parseExprStr("a & b");
    let case ast::NodeValue::BinOp(op1) = bitAnd.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::BitAnd);

    let bitOr = try! parseExprStr("x | y");
    let case ast::NodeValue::BinOp(op2) = bitOr.value
        else throw testing::TestError::Failed;
    try testing::expect(op2.op == ast::BinaryOp::BitOr);

    let bitXor = try! parseExprStr("a ^ b");
    let case ast::NodeValue::BinOp(op3) = bitXor.value
        else throw testing::TestError::Failed;
    try testing::expect(op3.op == ast::BinaryOp::BitXor);

    let shl = try! parseExprStr("x << y");
    let case ast::NodeValue::BinOp(op4) = shl.value
        else throw testing::TestError::Failed;
    try testing::expect(op4.op == ast::BinaryOp::Shl);

    let shr = try! parseExprStr("a >> b");
    let case ast::NodeValue::BinOp(op5) = shr.value
        else throw testing::TestError::Failed;
    try testing::expect(op5.op == ast::BinaryOp::Shr);
}

/// Test parsing logical binary operators (and, or).
@test unsafe fn testParseBinOpLogical() throws (testing::TestError) {
    let andOp = try! parseExprStr("a and b");
    let case ast::NodeValue::BinOp(op1) = andOp.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::And);
    try expectIdent(op1.left, "a");
    try expectIdent(op1.right, "b");

    let orOp = try! parseExprStr("x or y");
    let case ast::NodeValue::BinOp(op2) = orOp.value
        else throw testing::TestError::Failed;
    try testing::expect(op2.op == ast::BinaryOp::Or);
    try expectIdent(op2.left, "x");
    try expectIdent(op2.right, "y");
}

/// Test operator precedence: multiplication before addition.
@test unsafe fn testParseBinOpPrecedenceMulAdd() throws (testing::TestError) {
    let root = try! parseExprStr("a + b * c");
    let case ast::NodeValue::BinOp(add) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(add.op == ast::BinaryOp::Add);
    try expectIdent(add.left, "a");

    let case ast::NodeValue::BinOp(mul) = add.right.value
        else throw testing::TestError::Failed;

    try testing::expect(mul.op == ast::BinaryOp::Mul);
    try expectIdent(mul.left, "b");
    try expectIdent(mul.right, "c");
}

/// Test operator precedence: shifts before bitwise operations.
@test unsafe fn testParseBinOpPrecedenceShiftBitwise() throws (testing::TestError) {
    let root = try! parseExprStr("a & b << c");
    let case ast::NodeValue::BinOp(bitAnd) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(bitAnd.op == ast::BinaryOp::BitAnd);
    try expectIdent(bitAnd.left, "a");

    let case ast::NodeValue::BinOp(shl) = bitAnd.right.value
        else throw testing::TestError::Failed;

    try testing::expect(shl.op == ast::BinaryOp::Shl);
    try expectIdent(shl.left, "b");
    try expectIdent(shl.right, "c");
}

/// Test operator precedence: comparison before logical AND.
@test unsafe fn testParseBinOpPrecedenceCompareLogical() throws (testing::TestError) {
    let root = try! parseExprStr("a < b and c > d");
    let case ast::NodeValue::BinOp(andOp) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(andOp.op == ast::BinaryOp::And);

    let case ast::NodeValue::BinOp(lt) = andOp.left.value
        else throw testing::TestError::Failed;
    try testing::expect(lt.op == ast::BinaryOp::Lt);
    try expectIdent(lt.left, "a");
    try expectIdent(lt.right, "b");

    let case ast::NodeValue::BinOp(gt) = andOp.right.value
        else throw testing::TestError::Failed;
    try testing::expect(gt.op == ast::BinaryOp::Gt);
    try expectIdent(gt.left, "c");
    try expectIdent(gt.right, "d");
}

/// Test left associativity of addition.
@test unsafe fn testParseBinOpAssociativityAdd() throws (testing::TestError) {
    let root = try! parseExprStr("a + b + c");
    let case ast::NodeValue::BinOp(add2) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(add2.op == ast::BinaryOp::Add);
    try expectIdent(add2.right, "c");

    let case ast::NodeValue::BinOp(add1) = add2.left.value
        else throw testing::TestError::Failed;
    try testing::expect(add1.op == ast::BinaryOp::Add);
    try expectIdent(add1.left, "a");
    try expectIdent(add1.right, "b");
}

/// Test complex expression with multiple operators and precedence.
@test unsafe fn testParseBinOpComplex() throws (testing::TestError) {
    let root = try! parseExprStr("a + b * c - d / e");
    let case ast::NodeValue::BinOp(sub) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sub.op == ast::BinaryOp::Sub);

    let case ast::NodeValue::BinOp(add) = sub.left.value
        else throw testing::TestError::Failed;
    try testing::expect(add.op == ast::BinaryOp::Add);
    try expectIdent(add.left, "a");

    let case ast::NodeValue::BinOp(mul) = add.right.value
        else throw testing::TestError::Failed;
    try testing::expect(mul.op == ast::BinaryOp::Mul);

    let case ast::NodeValue::BinOp(div) = sub.right.value
        else throw testing::TestError::Failed;
    try testing::expect(div.op == ast::BinaryOp::Div);
}

/// Test binary operators with parentheses override precedence.
@test unsafe fn testParseBinOpParentheses() throws (testing::TestError) {
    let root = try! parseExprStr("(a + b) * c");
    let case ast::NodeValue::BinOp(mul) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(mul.op == ast::BinaryOp::Mul);
    try expectIdent(mul.right, "c");

    let case ast::NodeValue::BinOp(add) = mul.left.value
        else throw testing::TestError::Failed;
    try testing::expect(add.op == ast::BinaryOp::Add);
    try expectIdent(add.left, "a");
    try expectIdent(add.right, "b");
}

/// Test parsing a simple union without payloads.
@test unsafe fn testParseEnumSimple() throws (testing::TestError) {
    let node = try! parseStmtStr("union Color { Red, Green, Blue }");
    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Color");
    try testing::expect(decl.derives.len == 0);

    let variants = decl.variants;
    try testing::expect(variants.len == 3);

    let v0 = variants[0];
    let case ast::NodeValue::UnionDeclVariant(var0) = v0.value
        else throw testing::TestError::Failed;
    try expectIdent(var0.name, "Red");
    try testing::expect(var0.index == 0);
    try testing::expect(var0.type == nil);
    try testing::expect(var0.value == nil);

    let v1 = variants[1];
    let case ast::NodeValue::UnionDeclVariant(var1) = v1.value
        else throw testing::TestError::Failed;
    try expectIdent(var1.name, "Green");
    try testing::expect(var1.index == 1);
    try testing::expect(var1.type == nil);
    try testing::expect(var1.value == nil);

    let v2 = variants[2];
    let case ast::NodeValue::UnionDeclVariant(var2) = v2.value
        else throw testing::TestError::Failed;
    try expectIdent(var2.name, "Blue");
    try testing::expect(var2.index == 2);
    try testing::expect(var2.type == nil);
    try testing::expect(var2.value == nil);
}

/// Test parsing a union with trailing comma.
@test unsafe fn testParseEnumTrailingComma() throws (testing::TestError) {
    let node = try! parseStmtStr("union Letter { A, B, C, }");
    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Letter");
    try testing::expect(decl.variants.len == 3);
}

/// Test parsing a union with explicit values.
@test unsafe fn testParseEnumExplicitValues() throws (testing::TestError) {
    let node = try! parseStmtStr("union Status { Ok = 0, Error = 1, Pending = 5 }");
    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Status");

    let variants = decl.variants;
    try testing::expect(variants.len == 3);

    let v0 = variants[0];
    let case ast::NodeValue::UnionDeclVariant(var0) = v0.value
        else throw testing::TestError::Failed;
    try expectIdent(var0.name, "Ok");
    try testing::expect(var0.index == 0);
    try testing::expect(var0.type == nil);
    try testing::expect(var0.value <> nil);

    let v1 = variants[1];
    let case ast::NodeValue::UnionDeclVariant(var1) = v1.value
        else throw testing::TestError::Failed;
    try expectIdent(var1.name, "Error");
    try testing::expect(var1.index == 1);
    try testing::expect(var1.value <> nil);

    let v2 = variants[2];
    let case ast::NodeValue::UnionDeclVariant(var2) = v2.value
        else throw testing::TestError::Failed;
    try expectIdent(var2.name, "Pending");
    try testing::expect(var2.index == 2);
    try testing::expect(var2.value <> nil);
}

/// Test parsing a union with payload and tag-only variants.
@test unsafe fn testParseEnumWithPayloads() throws (testing::TestError) {
    let node = try! parseStmtStr("union Result { Ok(bool), Error }");
    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Result");
    try testing::expect(decl.variants.len == 2);

    let okFields = try expectVariant(decl.variants[0], "Ok", 0)
        else throw testing::TestError::Failed;
    try testing::expect(okFields.len == 1);
    try expectFieldSig(okFields, 0, nil, ast::TypeSig::Bool);

    let errFields = try expectVariant(decl.variants[1], "Error", 1);
    try testing::expect(errFields == nil);
}

/// Test parsing a union with derives.
@test unsafe fn testParseEnumWithDerives() throws (testing::TestError) {
    let node = try! parseStmtStr("union Option: Debug + Eq { None, Some(i32) }");
    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Option");
    try testing::expect(decl.derives.len == 2);
    try expectIdent(decl.derives[0], "Debug");
    try expectIdent(decl.derives[1], "Eq");

    let variants = decl.variants;
    try testing::expect(variants.len == 2);

    let v0 = variants[0];
    let case ast::NodeValue::UnionDeclVariant(var0) = v0.value
        else throw testing::TestError::Failed;
    try expectIdent(var0.name, "None");
    try testing::expect(var0.type == nil);

    let v1 = variants[1];
    let case ast::NodeValue::UnionDeclVariant(var1) = v1.value
        else throw testing::TestError::Failed;
    try expectIdent(var1.name, "Some");
    try testing::expect(var1.type <> nil);
}

/// Test parsing named record literals with named fields.
@test unsafe fn testParseNamedRecordLiteralNamed() throws (testing::TestError) {
    let r1 = try! parseExprStr("Point { x: 5, y: 10 }");
    let case ast::NodeValue::RecordLit(lit) = r1.value
        else throw testing::TestError::Failed;

    let typeName = lit.typeName else throw testing::TestError::Failed;
    try expectIdent(typeName, "Point");
    try testing::expect(lit.fields.len == 2);

    let field0 = lit.fields[0];
    let case ast::NodeValue::RecordLitField(arg0) = field0.value
        else throw testing::TestError::Failed;
    let label0 = arg0.label else throw testing::TestError::Failed;
    try expectIdent(label0, "x");
    try expectNumber(arg0.value, "5");
}

/// Test parsing anonymous record literals with named fields.
@test unsafe fn testParseAnonymousRecordLiteralNamed() throws (testing::TestError) {
    let r1 = try! parseExprStr("{ x: 10, y: 20 }");
    let case ast::NodeValue::RecordLit(lit) = r1.value
        else throw testing::TestError::Failed;

    try testing::expect(lit.typeName == nil);
    try testing::expect(lit.fields.len == 2);

    let field0 = lit.fields[0];
    let case ast::NodeValue::RecordLitField(arg0) = field0.value
        else throw testing::TestError::Failed;
    let label0 = arg0.label else throw testing::TestError::Failed;
    try expectIdent(label0, "x");
    try expectNumber(arg0.value, "10");

    let field1 = lit.fields[1];
    let case ast::NodeValue::RecordLitField(arg1) = field1.value
        else throw testing::TestError::Failed;
    let label1 = arg1.label else throw testing::TestError::Failed;
    try expectIdent(label1, "y");
    try expectNumber(arg1.value, "20");
}

/// Test parsing record literals with shorthand field syntax.
/// `{ x, y }` is equivalent to `{ x: x, y: y }`.
@test unsafe fn testParseRecordLiteralShorthand() throws (testing::TestError) {
    let r1 = try! parseExprStr("Point { x, y }");
    let case ast::NodeValue::RecordLit(lit) = r1.value
        else throw testing::TestError::Failed;

    let typeName = lit.typeName else throw testing::TestError::Failed;
    try expectIdent(typeName, "Point");
    try testing::expect(lit.fields.len == 2);

    // First field: shorthand `x`.
    let field0 = lit.fields[0];
    let case ast::NodeValue::RecordLitField(arg0) = field0.value
        else throw testing::TestError::Failed;
    let label0 = arg0.label else throw testing::TestError::Failed;
    try expectIdent(label0, "x");
    try expectIdent(arg0.value, "x");
    // Label and value should point to the same node.
    try testing::expect(label0 == arg0.value);

    // Second field: shorthand `y`.
    let field1 = lit.fields[1];
    let case ast::NodeValue::RecordLitField(arg1) = field1.value
        else throw testing::TestError::Failed;
    let label1 = arg1.label else throw testing::TestError::Failed;
    try expectIdent(label1, "y");
    try expectIdent(arg1.value, "y");
    try testing::expect(label1 == arg1.value);
}

/// Test parsing record literals with mixed shorthand and explicit fields.
@test unsafe fn testParseRecordLiteralMixedShorthand() throws (testing::TestError) {
    let r1 = try! parseExprStr("Point { x, y: 10 }");
    let case ast::NodeValue::RecordLit(lit) = r1.value
        else throw testing::TestError::Failed;

    try testing::expect(lit.fields.len == 2);

    // First field: shorthand `x`.
    let field0 = lit.fields[0];
    let case ast::NodeValue::RecordLitField(arg0) = field0.value
        else throw testing::TestError::Failed;
    let label0 = arg0.label else throw testing::TestError::Failed;
    try expectIdent(label0, "x");
    try expectIdent(arg0.value, "x");

    // Second field: explicit `y: 10`.
    let field1 = lit.fields[1];
    let case ast::NodeValue::RecordLitField(arg1) = field1.value
        else throw testing::TestError::Failed;
    let label1 = arg1.label else throw testing::TestError::Failed;
    try expectIdent(label1, "y");
    try expectNumber(arg1.value, "10");
}

/// Test that positional brace initializers are rejected: `{ 1, 2 }`.
@test unsafe fn testParsePositionalBraceInitializerAnonymous() throws (testing::TestError) {
    let parsed: ?*ast::Node = try? parseExprStr("{ 1, 2 }");
    try testing::expect(parsed == nil);
}

/// Test that positional brace initializers are rejected: `Point { 1, 2 }`.
@test unsafe fn testParsePositionalBraceInitializerNamed() throws (testing::TestError) {
    let parsed: ?*ast::Node = try? parseExprStr("Point { 1, 2 }");
    try testing::expect(parsed == nil);
}

/// Test that mixed labeled/positional brace initializers are rejected: `Pt { x: 1, 2 }`.
@test unsafe fn testParseMixedBraceInitializer() throws (testing::TestError) {
    let parsed: ?*ast::Node = try? parseExprStr("Pt { x: 1, 2 }");
    try testing::expect(parsed == nil);
}

/// Unsafe statements have a block body.
@test unsafe fn testParseUnsafeBlock() throws (testing::TestError) {
    let parsed = try? parseStmtsStr("fn run() { unsafe { return; } }");
    let root = parsed else throw testing::TestError::Failed;
    let case ast::NodeValue::Block(module) = root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::FnDecl(decl) = module.statements[0].value
        else throw testing::TestError::Failed;
    let fnBody = decl.body else throw testing::TestError::Failed;
    let case ast::NodeValue::Block(body) = fnBody.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Block(inner) = body.statements[0].value
        else throw testing::TestError::Failed;
    try testing::expect(not body.isUnsafe);
    try testing::expect(inner.isUnsafe);
}

/// Unsafe blocks do not accept declaration attributes.
@test unsafe fn testUnsafeBlockAttributesRejected() throws (testing::TestError) {
    let parsed = try? parseStmtsStr("fn run() { export unsafe {} }");
    try testing::expect(parsed == nil);
}

/// Unsafe static declarations carry an explicit access requirement.
@test unsafe fn testParseUnsafeStatic() throws (testing::TestError) {
    let parsed = try? parseStmtsStr("export unsafe static DATA: [u8; 4] = undefined;");
    try testing::expect(parsed <> nil);
}

@test unsafe fn testParseModule() throws (testing::TestError) {
    let r = try! parseStmtsStr("fn f() {} fn g() {}");

    let case ast::NodeValue::Block(module) = r.value
        else throw testing::TestError::Failed;
    try testing::expect(module.statements.len == 2);

    let first = module.statements[0];
    let case ast::NodeValue::FnDecl(fDecl) = first.value
        else throw testing::TestError::Failed;
    try expectIdent(fDecl.name, "f");

    let second = module.statements[1];
    let case ast::NodeValue::FnDecl(gDecl) = second.value
        else throw testing::TestError::Failed;
    try expectIdent(gDecl.name, "g");
}

/// Test parsing a simple conditional expression.
@test unsafe fn testParseCondExpr() throws (testing::TestError) {
    let r = try! parseExprStr("a if cond else b") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::CondExpr(cond) = r.value
        else throw testing::TestError::Failed;

    try expectIdent(cond.thenExpr, "a");
    try expectIdent(cond.condition, "cond");
    try expectIdent(cond.elseExpr, "b");
}

/// Test parsing a conditional expression with `as` casts.
@test unsafe fn testParseCondExprWithAsCast() throws (testing::TestError) {
    let r = try! parseExprStr("x as i32 if cond else y as i32") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::CondExpr(cond) = r.value
        else throw testing::TestError::Failed;

    // Check thenExpr is an `as` cast.
    let case ast::NodeValue::As(thenAs) = cond.thenExpr.value
        else throw testing::TestError::Failed;
    try expectIdent(thenAs.value, "x");
    try expectIntType(thenAs.type, 4, ast::Signedness::Signed);

    // Check condition.
    try expectIdent(cond.condition, "cond");

    // Check elseExpr is an `as` cast.
    let case ast::NodeValue::As(elseAs) = cond.elseExpr.value
        else throw testing::TestError::Failed;
    try expectIdent(elseAs.value, "y");
    try expectIntType(elseAs.type, 4, ast::Signedness::Signed);
}

/// Test parsing a nested conditional expression (right-associative).
@test unsafe fn testParseCondExprNested() throws (testing::TestError) {
    let r = try! parseExprStr("a if x else b if y else c") catch {
        throw testing::TestError::Failed;
    };
    let case ast::NodeValue::CondExpr(outer) = r.value
        else throw testing::TestError::Failed;

    try expectIdent(outer.thenExpr, "a");
    try expectIdent(outer.condition, "x");

    // The else branch should be another conditional expression.
    let case ast::NodeValue::CondExpr(inner) = outer.elseExpr.value
        else throw testing::TestError::Failed;

    try expectIdent(inner.thenExpr, "b");
    try expectIdent(inner.condition, "y");
    try expectIdent(inner.elseExpr, "c");
}

/// Test that trailing commas are allowed in all comma-separated lists.
@test unsafe fn testTrailingCommas() throws (testing::TestError) {
    // Function call arguments.
    let call = try! parseExprStr("f(1, 2, 3,)");
    let case ast::NodeValue::Call(c) = call.value else throw testing::TestError::Failed;
    try testing::expect(c.args.len == 3);

    // Function parameters.
    let fnNode = try! parseStmtStr("fn add(x: i32, y: i32,) {}");
    let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value else throw testing::TestError::Failed;
    try testing::expect(fnDecl.sig.params.len == 2);

    // Record declarations.
    let recNode = try! parseStmtStr("record R { x: i32, y: bool, }");
    let case ast::NodeValue::RecordDecl(recDecl) = recNode.value else throw testing::TestError::Failed;
    try testing::expect(recDecl.fields.len == 2);

    // Tuple record declarations.
    let tupNode = try! parseStmtStr("record R(i32, bool,);");
    let case ast::NodeValue::RecordDecl(tupDecl) = tupNode.value else throw testing::TestError::Failed;
    try testing::expect(tupDecl.fields.len == 2);

    // Record literals.
    let litNode = try! parseExprStr("Point { x: 1, y: 2, }");
    let case ast::NodeValue::RecordLit(lit) = litNode.value else throw testing::TestError::Failed;
    try testing::expect(lit.fields.len == 2);

    // Union declarations.
    let unionNode = try! parseStmtStr("union Color { Red, Green, Blue, }");
    let case ast::NodeValue::UnionDecl(unionDecl) = unionNode.value else throw testing::TestError::Failed;
    try testing::expect(unionDecl.variants.len == 3);

    // Array literals.
    let arrNode = try! parseExprStr("[1, 2, 3,]");
    let case ast::NodeValue::ArrayLit(items) = arrNode.value else throw testing::TestError::Failed;
    try testing::expect(items.len == 3);

    // Function type parameters.
    let fnType = try! parseTypeStr("fn (i32, bool,)");
    let case ast::NodeValue::TypeSig(sigValue) = fnType.value else throw testing::TestError::Failed;
    let case ast::TypeSig::Fn { sig, .. } = sigValue else throw testing::TestError::Failed;
    try testing::expect(sig.params.len == 2);
    try testing::expect(sig.returnType == nil);

    // Throws lists.
    let throwsNode = try! parseStmtStr("fn handle() throws (Error, Other,) {}");
    let case ast::NodeValue::FnDecl(throwsDecl) = throwsNode.value else throw testing::TestError::Failed;
    try testing::expect(throwsDecl.sig.throwList.len == 2);
}

/// Function declarations and function types accept never return annotations.
@test unsafe fn testParseNeverReturn() throws (testing::TestError) {
    let declNode = try! parseStmtStr("fn stop() -> ! { panic; }");
    let case ast::NodeValue::FnDecl(decl) = declNode.value else throw testing::TestError::Failed;
    let ret = decl.sig.returnType else throw testing::TestError::Failed;
    assert ret.value == ast::NodeValue::TypeSig(ast::TypeSig::Never);
    let fnNode = try! parseTypeStr("unsafe fn(u64) -> ! throws (Error)");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Fn { sig, isUnsafe }) = fnNode.value
        else throw testing::TestError::Failed;
    let fnRet = sig.returnType else throw testing::TestError::Failed;
    assert isUnsafe and sig.params.len == 1 and sig.throwList.len == 1;
    assert fnRet.value == ast::NodeValue::TypeSig(ast::TypeSig::Never);
}

/// Unsafe function types preserve their call requirement and signature.
@test unsafe fn testParseUnsafeFunctionType() throws (testing::TestError) {
    let node = try! parseTypeStr("unsafe fn(&u32) -> u32 throws (Error)");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Fn { sig, isUnsafe }) = node.value
        else throw testing::TestError::Failed;
    assert isUnsafe;
    assert sig.params.len == 1;
    assert sig.returnType <> nil;
    assert sig.throwList.len == 1;
}

/// Region arguments on an inner type remain distinct from a reference region.
@test unsafe fn testRegionReferenceTypes() throws (testing::TestError) {
    let root = try! parseTypeStr("&'short mut Node 'arena");
    let case ast::NodeValue::TypeSig(ast::TypeSig::RegionRef { region, type }) = root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name, parent: nil } = region.value
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "'short"));
    let case ast::NodeValue::TypeSig(ast::TypeSig::Pointer { class, valueType, mutable }) = type.value
        else throw testing::TestError::Failed;
    try testing::expect(class == ast::PointerClass::Ref and mutable);
    let case ast::NodeValue::TypeSig(ast::TypeSig::Applied { name: nominal, regions }) = valueType.value
        else throw testing::TestError::Failed;
    try expectIdent(nominal, "Node");
    try testing::expect(regions.len == 1);
    let case ast::NodeValue::Region { name: argument, .. } = regions[0].value
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(argument, "'arena"));
    let slice = try! parseTypeStr("&'r [View 'a 'b]");
    let case ast::NodeValue::TypeSig(ast::TypeSig::RegionRef { type: sliceType, .. }) = slice.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TypeSig(ast::TypeSig::Slice { .. }) = sliceType.value
        else throw testing::TestError::Failed;
}

/// Declaration lists accept regions, parent relations, and ownership derives.
@test unsafe fn testRegionDeclarations() throws (testing::TestError) {
    let parsedRecord = try! parseStmtStr("record View: 'a + 'b + Copy where 'a: 'b { item: &'b u8 }");
    let case ast::NodeValue::RecordDecl(decl) = parsedRecord.value
        else throw testing::TestError::Failed;
    try testing::expect(decl.regions.len == 2 and decl.derives.len == 1);
    let case ast::NodeValue::Region { parent: parent, .. } = decl.regions[1].value
        else throw testing::TestError::Failed;
    try testing::expect(parent <> nil);
    let func = try! parseStmtStr(
        "fn read 'long 'short (input: &'short u8) -> &'short u8 throws (ReadError) where 'long: 'short { return input; }"
    );
    let case ast::NodeValue::FnDecl(f) = func.value else throw testing::TestError::Failed;
    try testing::expect(f.regions.len == 2 and f.sig.throwList.len == 1);
    let case ast::NodeValue::Region { name: shortName, parent: shortParent } = f.regions[1].value
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(shortName, "'short") and shortParent <> nil);
    let parentNode = shortParent else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: parentName, parent: nil } = parentNode.value
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(parentName, "'long"));
    let parsedUnion = try! parseStmtStr("union Result: 'x { Value(&'x u8), Empty }");
    let case ast::NodeValue::UnionDecl(u) = parsedUnion.value else throw testing::TestError::Failed;
    try testing::expect(u.regions.len == 1 and u.derives.len == 0);
}

/// Regional blocks retain their source bindings and derived session region.
@test unsafe fn testRegionBlocks() throws (testing::TestError) {
    let root = try! parseStmtStr("let left: 'r = &mut state.left, right = &state.right in { useView(left); }");
    let case ast::NodeValue::RegionBlock { bindings, isSession, .. } = root.value
        else throw testing::TestError::Failed;
    try testing::expect(not isSession and bindings.len == 2);
    let nested = try! parseStmtStr("let view: 'inner = &value where 'outer: 'inner in {}");
    let case ast::NodeValue::RegionBlock { region: nestedRegion, .. } = nested.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: nestedName, parent: nestedParent } = nestedRegion.value
        else throw testing::TestError::Failed;
    let parent = nestedParent else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: parentName, parent: nil } = parent.value
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(nestedName, "'inner") and mem::eq(parentName, "'outer"));
    let arena = try! parseStmtStr("use arena as objects in { make(objects); }");
    let case ast::NodeValue::RegionBlock {
        region: arenaRegion, bindings: arenaBindings, isSession: arenaSession, ..
    } = arena.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: arenaRegionName, parent: nil } = arenaRegion.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::RegionBinding(arenaBinding) = arenaBindings[0].value
        else throw testing::TestError::Failed;
    let arenaLabel = arenaBinding.label else throw testing::TestError::Failed;
    let case ast::NodeValue::Ident(arenaLabelName) = arenaLabel.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::AddressOf({
        target: arenaTarget, kind: ast::AddressKind::Mutable, permission: nil,
    }) = arenaBinding.value.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Ident(arenaTargetName) = arenaTarget.value
        else throw testing::TestError::Failed;
    try testing::expect(
        arenaSession and arenaBindings.len == 1
        and mem::eq(arenaRegionName, "'objects")
        and mem::eq(arenaLabelName, "objects")
        and mem::eq(arenaTargetName, "arena")
    );
}

/// Region grammar rejects incomplete lists and invalid allocation headers.
@test unsafe fn testMalformedRegionSyntax() throws (testing::TestError) {
    for source in [
        "fn bad: Copy () {}",
        "record Bad: 'r + {}",
        "let 'r  in {}",
        "let p: 'r = value in {}",
        "let 'r p = &value in {}",
        "let 'child < 'parent p = &value in {}",
        "let 'parent as p = &value in {}",
        "let value: 'child = &source where 'parent: 'other in {}",
        "use arena in {}",
        "use arena as in {}",
        "use arena as first, second in {}",
        "use 'r a = &mut arena in {}",
        "use 'r a as &mut arena in {}",
    ] {
        let parsed = try? parseStmtStr(source);
        try testing::expect(parsed == nil);
    }
    for source in ["&'x' u8", "&mut 'x u8", "View '", "&'r"] {
        let parsed = try? parseTypeStr(source);
        try testing::expect(parsed == nil);
    }
}

/// Ordinary identifiers remain available beside regional block syntax.
@test unsafe fn testRegionContextualKeywords() throws (testing::TestError) {
    for source in [
        "let borrow = 1;",
        "let session = 2;",
        "borrow(value);",
        "session(value);",
        "record Context { borrow: u32, session: u32 }",
    ] {
        let parsed = try? parseStmtStr(source);
        try testing::expect(parsed <> nil);
    }
}

/// The AST printer retains region parameters and qualified reference types.
@test unsafe fn testPrintRegionSignature() throws (testing::TestError) {
    let root = try! parseStmtStr("fn read 'r (input: &'r u8) -> &'r u8 { return input; }");
    static PRINT_STORAGE: [u8; 4096] = [0; 4096];
    let mut arena = alloc::new(&mut PRINT_STORAGE[..]);
    let printed = printer::toExpr(&mut arena, root);
    let case sexpr::Expr::Block { items, .. } = printed
        else throw testing::TestError::Failed;
    try testing::expect(items.len == 4);
    let case sexpr::Expr::List { head, tail, .. } = items[1]
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(head, "regions") and tail.len == 1);
    let case sexpr::Expr::Sym(name) = tail[0] else throw testing::TestError::Failed;
    try testing::expect(mem::eq(name, "'r"));
    let case sexpr::Expr::List { head: refHead, tail: refTail, .. } = items[3]
        else throw testing::TestError::Failed;
    try testing::expect(mem::eq(refHead, "region-ref") and refTail.len == 2);
}

/// Explicit function region arguments precede ordinary call arguments.
@test unsafe fn testFunctionRegionApplication() throws (testing::TestError) {
    let expr = try! parseExprStr("read 'a 'b (p)");
    let case ast::NodeValue::Call(call) = expr.value else throw testing::TestError::Failed;
    let case ast::NodeValue::RegionApply { value, regions } = call.callee.value
        else throw testing::TestError::Failed;
    try expectIdent(value, "read");
    try testing::expect(regions.len == 2 and call.args.len == 1);
}

/// Concrete region headers can name a parent and end without a semicolon.
@test unsafe fn testRegionParentSyntax() throws (testing::TestError) {
    let parsed = try? parseStmtsStr("fn f 'a (p: &'a u32) { let q: 'b = &*p where 'a: 'b in {} return; }");
    try testing::expect(parsed <> nil);
}

/// Cell qualifiers retain pointer ownership and payload syntax.
@test unsafe fn testCellPointerType() throws (testing::TestError) {
    let root = try! parseTypeStr("*cell u32");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Cell {
        class, payload, permission,
    }) = root.value else throw testing::TestError::Failed;
    try testing::expect(class == ast::PointerClass::Owned and permission == nil);
    let case ast::NodeValue::TypeSig(ast::TypeSig::Integer { width: 4, .. }) = payload.value
        else throw testing::TestError::Failed;

    let ownedAssociated = try! parseTypeStr("*cell 'permission u32");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Cell {
        class: ownedClass, payload: ownedPayload, permission: ownedPermission,
    }) = ownedAssociated.value else throw testing::TestError::Failed;
    let ownedPermissionRegion = ownedPermission else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: ownedPermissionName, parent: nil } =
        ownedPermissionRegion.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TypeSig(ast::TypeSig::Integer { width: 4, .. }) =
        ownedPayload.value
        else throw testing::TestError::Failed;
    try testing::expect(
        ownedClass == ast::PointerClass::Owned
        and mem::eq(ownedPermissionName, "'permission")
    );

    let borrowed = try! parseTypeStr("&'r cell Pair 's");
    let case ast::NodeValue::TypeSig(ast::TypeSig::RegionRef { type, .. }) = borrowed.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TypeSig(ast::TypeSig::Cell {
        class: refClass, payload: inner, permission: refPermission,
    }) = type.value else throw testing::TestError::Failed;
    try testing::expect(refClass == ast::PointerClass::Ref and refPermission == nil);
    let case ast::NodeValue::TypeSig(ast::TypeSig::Applied { regions, .. }) = inner.value
        else throw testing::TestError::Failed;
    try testing::expect(regions.len == 1);

    let associated = try! parseTypeStr("&'storage cell 'permission Pair 'payload");
    let case ast::NodeValue::TypeSig(ast::TypeSig::RegionRef {
        region: storage, type: associatedType,
    }) = associated.value else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: storageName, parent: nil } = storage.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TypeSig(ast::TypeSig::Cell {
        class: associatedClass,
        payload: associatedPayload,
        permission: associatedPermission,
    }) = associatedType.value else throw testing::TestError::Failed;
    let permissionRegion = associatedPermission else throw testing::TestError::Failed;
    let case ast::NodeValue::Region { name: permissionName, parent: nil } =
        permissionRegion.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::TypeSig(ast::TypeSig::Applied {
        name: payloadName, regions: payloadRegions,
    }) = associatedPayload.value else throw testing::TestError::Failed;
    try expectIdent(payloadName, "Pair");
    try testing::expect(payloadRegions.len == 1);
    let case ast::NodeValue::Region { name: payloadRegionName, parent: nil } =
        payloadRegions[0].value
        else throw testing::TestError::Failed;
    try testing::expect(
        associatedClass == ast::PointerClass::Ref
        and mem::eq(storageName, "'storage")
        and mem::eq(permissionName, "'permission")
        and mem::eq(payloadRegionName, "'payload")
    );

}

/// Measure committed storage for a statement after an existing node.
unsafe fn statementStorageUsed(source: *[u8]) -> u32 {
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    ast::allocNode(&mut arena, ast::Span { offset: 0, length: 0 }, ast::NodeValue::Bool(true));
    let start = alloc::used(&arena.arena);
    let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
        let mut parser = super::mkParser(scanner::SourceLoc::String, source, arenaRef, poolRef);
        super::advance(&mut parser);
        try! super::parseStmt(&mut parser);
        return alloc::used(&parser.arena.arena) - start;
    }
}

/// Rewinding a failed expression preserves published nodes and source tokens.
@test unsafe fn testSpeculativeRestoreStorage() throws (testing::TestError) {
    let expectedBytes = statementStorageUsed("return");
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let retained = ast::allocNode(&mut arena, ast::Span { offset: 3, length: 1 }, ast::NodeValue::Bool(true));
    let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
        let mut parser = super::mkParser(scanner::SourceLoc::String,
            "return [speculativeRestoreIdentifier, 1 +", arenaRef, poolRef);
        super::advance(&mut parser);
        try super::expect(&mut parser, scanner::TokenKind::Eof, "retained diagnostic") catch {
        };
        let mut expectedScanner = parser.scanner;
        let expectedCurrent = scanner::next(&mut expectedScanner, parser.pool);
        let expectedPrevious = parser.current;
        let expectedContext = parser.context;
        let startOffset = alloc::used(&parser.arena.arena);
        let startId = parser.arena.nextId;
        let statement = try! super::parseStmt(&mut parser);
        let case ast::NodeValue::Return { value } = statement.value else throw testing::TestError::Failed;
        try testing::expect(value == nil);
        try testing::expect(statement.id == startId);
        try testing::expect(alloc::used(&parser.arena.arena) == startOffset + expectedBytes);
        try testing::expect(parser.arena.nextId == startId + 1);
        try testing::expect(parser.scanner.cursor == expectedScanner.cursor);
        try testing::expect(parser.scanner.token == expectedScanner.token);
        try testing::expect(parser.current.kind == expectedCurrent.kind);
        try testing::expect(parser.current.offset == expectedCurrent.offset);
        try testing::expect(parser.previous.kind == expectedPrevious.kind);
        try testing::expect(parser.previous.offset == expectedPrevious.offset);
        try testing::expect(parser.context == expectedContext);
        try testing::expect(parser.errors.count == 1);
        for i in alloc::used(&parser.arena.arena)..ARENA_STORAGE.len {
            set ARENA_STORAGE[i] = 0xA5;
        }
        let case ast::NodeValue::Bool(true) = retained.value else throw testing::TestError::Failed;
        try testing::expect(retained.span.offset == 3);
        try testing::expect(retained.span.length == 1);
        try testing::expect(mem::eq(parser.errors.list[0].message, "retained diagnostic"));
        try testing::expect(mem::eq(parser.errors.list[0].token.source, "return"));
        let interned = strings::find(parser.pool, "speculativeRestoreIdentifier") else throw testing::TestError::Failed;
        try testing::expect(mem::eq(interned, "speculativeRestoreIdentifier"));
        let replacement = ast::allocNode(parser.arena, ast::Span { offset: 0, length: 0 }, ast::NodeValue::Bool(false));
        try testing::expect(replacement.id == startId + 1);
        let case ast::NodeValue::Bool(true) = retained.value else throw testing::TestError::Failed;
    }
}

/// Optional return and panic expressions publish only their wrapper after failure.
@test unsafe fn testSpeculativeStatementPublication() throws (testing::TestError) {
    let expectedBytes = statementStorageUsed("return");
    for source in ["return (speculativeReturnIdentifier +", "panic (speculativePanicIdentifier +"] {
        let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
        ast::allocNode(&mut arena, ast::Span { offset: 0, length: 0 }, ast::NodeValue::Bool(true));
        let startOffset = alloc::used(&arena.arena);
        let poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {
            let mut parser = super::mkParser(scanner::SourceLoc::String, source, arenaRef, poolRef);
            super::advance(&mut parser);
            let startId = parser.arena.nextId;
            let statement = try! super::parseStmt(&mut parser);
            try testing::expect(statement.id == startId);
            try testing::expect(parser.arena.nextId == startId + 1);
            try testing::expect(alloc::used(&parser.arena.arena) == startOffset + expectedBytes);
            try testing::expect(parser.errors.count == 0);
            try testing::expect(parser.current.kind == scanner::TokenKind::LParen);
            match statement.value {
                case ast::NodeValue::Return { value } => try testing::expect(value == nil),
                case ast::NodeValue::Panic { message } => try testing::expect(message == nil),
                else => throw testing::TestError::Failed,
            }
        }
    }
}