radiance · Radiance self-hosting compiler

compiler/ lib/ examples/ std/ arch/ char/ collections/ lang/ alloc/ ast/ gen/ il/ module/ parser/ tests.rad 119.6 KiB resolver/ scanner/ alloc.rad 4.3 KiB ast.rad 23.9 KiB gen.rad 507 B il.rad 15.3 KiB lower.rad 287.8 KiB module.rad 13.5 KiB package.rad 1.2 KiB parser.rad 82.9 KiB resolver.rad 407.8 KiB scanner.rad 18.3 KiB sexpr.rad 6.3 KiB strings.rad 2.2 KiB types.rad 280 B sys/ arch.rad 68 B char.rad 855 B collections.rad 39 B fmt.rad 8.1 KiB intrinsics.rad 467 B io.rad 1.3 KiB lang.rad 276 B mem.rad 2.2 KiB sys.rad 173 B testing.rad 2.4 KiB tests.rad 12.9 KiB vec.rad 1.7 KiB std.rad 281 B scripts/ seed/ sublime/ test/ vim/ .gitignore 336 B .gitsigners 112 B LICENSE 1.1 KiB Makefile 3.7 KiB README 4.8 KiB STYLE 2.5 KiB std.lib 1.2 KiB std.lib.test 347 B
lib/std/lang/parser/tests.rad 119.6 KiB raw
//! Parser tests.

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

/// Unified arena size.
constant ARENA_SIZE: u32 = 2097152;
/// Unified arena storage for all AST allocations.
static ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
/// String pool.
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);
    }
}

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

/// Parse a single type from a string.
fn parseTypeStr(input: *[u8]) -> *ast::Node
    throws (super::ParseError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, input, &mut arena, &mut STRING_POOL);
    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 fn parseExprStr(input: *[u8]) -> *ast::Node
    throws (super::ParseError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, input, &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);
    return try super::parseExpr(&mut parser);
}

/// Parse a single statement from a string.
fn parseStmtStr(input: *[u8]) -> *ast::Node
    throws (super::ParseError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, input, &mut arena, &mut STRING_POOL);
    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;
}

/// Require a statement to fail with one focused parser diagnostic.
fn expectStmtParseError(input: *[u8], message: *[u8])
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(
        scanner::SourceLoc::String, input, &mut arena, &mut STRING_POOL
    );
    super::advance(&mut parser);
    try super::parseStmt(&mut parser) catch {
        assert parser.errors.count == 1;
        assert mem::eq(parser.errors.list[0].message, message);
        return;
    };
    throw testing::TestError::Failed;
}

/// Parse an expression expected to be a number literal and return its payload.
fn parseNumberLiteral(text: *[u8]) -> fmt::IntLiteral
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, text, &mut arena, &mut STRING_POOL);
    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.
fn expectNumberLiteralFail(text: *[u8])
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, text, &mut arena, &mut STRING_POOL);
    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) -> ?*mut [*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: *mut [*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 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 fn testParseNumber() throws (testing::TestError) {
    let r1 = try! parseExprStr("4519");
    try expectNumber(r1, "4519");
}

/// Verify that decimal literals record magnitude and base metadata.
@test 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 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 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 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 fn testRejectUnaryPlus() throws (testing::TestError) {
    try expectNumberLiteralFail("+1");
    try expectNumberLiteralFail("+value");
    try expectNumberLiteralFail("+(value)");
}

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

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

/// Range expressions allow a missing start bound.
@test 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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.
fn expectI32Pointer(
    source: *[u8],
    class: types::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 fn testParseTypePointer() throws (testing::TestError) {
    try expectI32Pointer("*mut i32", types::PointerClass::Owned, true);
}

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

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

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

/// Test parsing a slice type.
@test 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 == types::PointerClass::Owned;
    try expectIntType(itemType, 1, ast::Signedness::Unsigned);
    assert not mutable;
}

/// Test parsing a mutable slice type.
@test 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 == types::PointerClass::Owned;
    try expectIntType(itemType, 1, ast::Signedness::Unsigned);
    assert mutable;
}

/// Test parsing reference and unsafe slice classes.
@test 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 == types::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 == types::PointerClass::Unsafe;
}

/// Test parsing trait object pointer classes.
@test 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 == types::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 == types::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 == types::PointerClass::Unsafe;
}

/// Test parsing an array type.
@test 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.
@test 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 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 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 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 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 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 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 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 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 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 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 fn testParseTypeVoidRejected() throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(scanner::SourceLoc::String, "void", &mut arena, &mut STRING_POOL);
    super::advance(&mut parser);
    try testing::expect(super::check(&parser, scanner::TokenKind::Ident));
}

/// Test parsing the unsafe function modifier.
@test 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;

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

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

/// Test `unsafe` on the other declaration forms that support it.
@test fn testParseUnsafeMethodAndModule() throws (testing::TestError) {
    let moduleNode = try! parseStmtStr("unsafe mod io;");
    let case ast::NodeValue::Mod(moduleDecl) = moduleNode.value
        else throw testing::TestError::Failed;
    let moduleAttrs = moduleDecl.attrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&moduleAttrs, ast::Attribute::Unsafe);

    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;
    assert methods.len == 1;
    let case ast::NodeValue::MethodDecl { attrs, .. } = methods[0].value
        else throw testing::TestError::Failed;
    let methodAttrs = attrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&methodAttrs, ast::Attribute::Unsafe);

    let mut 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 {
        attrs: traitAttrs, ..
    } = traitMethods[0].value else throw testing::TestError::Failed;
    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 parsing a function declaration with attributes.
@test 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 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 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 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 fn testParseTypeBool() throws (testing::TestError) {
    let node = try! parseTypeStr("bool");
    try expectType(node, ast::TypeSig::Bool);
}


/// Test parsing an unsigned integer type.
@test 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 fn testParseRefs() throws (testing::TestError) {
    {
        let refExpr = try! parseExprStr("&foo");
        let case ast::NodeValue::AddressOf(refNode) = refExpr.value
            else throw testing::TestError::Failed;
        try testing::expect(refNode.mutable == false);
        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.mutable == true);
        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.mutable == false);
        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.mutable == true);
        let case ast::NodeValue::FieldAccess(access) = mutRefFieldNode.target.value
            else throw testing::TestError::Failed;
        try expectIdent(access.parent, "obj");
        try expectIdent(access.child, "field");
    }
}

/// Test unary operator precedence relative to binary and postfix expressions.
@test 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 fn testParseMixedBraceInitializer() throws (testing::TestError) {
    let parsed: ?*ast::Node = try? parseExprStr("Pt { x: 1, 2 }");
    try testing::expect(parsed == nil);
}

@test 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 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 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 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 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);
}

/// Generic declarations retain ordered type, bound, and constant parameters.
@test fn testParseGenericDeclarations() throws (testing::TestError) {
    let recordNode = try! parseStmtStr(
        "record Pair⟨T: Reader + Writer, U⟩ { first: T, second: U }"
    );
    let case ast::NodeValue::RecordDecl(recordDecl) = recordNode.value
        else throw testing::TestError::Failed;
    assert recordDecl.params.len == 2;
    let case ast::NodeValue::GenericParam(ast::GenericParam::Type {
        name: firstName, bounds
    }) = recordDecl.params[0].value else throw testing::TestError::Failed;
    try expectIdent(firstName, "T");
    assert bounds.len == 2;
    try expectIdent(bounds[0], "Reader");
    try expectIdent(bounds[1], "Writer");

    let unionNode = try! parseStmtStr("union Maybe⟨T⟩ { None, Some(T) }");
    let case ast::NodeValue::UnionDecl(unionDecl) = unionNode.value
        else throw testing::TestError::Failed;
    assert unionDecl.params.len == 1;

    let fnNode = try! parseStmtStr("fn first⟨T⟩(value: T) -> T { return value; }");
    let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
        else throw testing::TestError::Failed;
    assert fnDecl.params.len == 1;

    let constNode = try! parseStmtStr(
        "record InlineVec⟨T, constant N: u32⟩ { data: [T; 4] }"
    );
    let case ast::NodeValue::RecordDecl(constDecl) = constNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericParam(ast::GenericParam::Const {
        name: constName, type: constType
    }) = constDecl.params[1].value else throw testing::TestError::Failed;
    try expectIdent(constName, "N");
    try expectIntType(constType, 4, ast::Signedness::Unsigned);
}

/// Generic applications nest in nominal types and preserve qualified targets.
@test fn testParseGenericTypeApplications() throws (testing::TestError) {
    let node = try! parseTypeStr("Result⟨collections::Vec⟨T⟩, E⟩");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(outerNode)) = node.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(outer) = outerNode.value
        else throw testing::TestError::Failed;
    try expectIdent(outer.target, "Result");
    assert outer.args.len == 2;

    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(innerNode)) =
        outer.args[0].value else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(inner) = innerNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::ScopeAccess(path) = inner.target.value
        else throw testing::TestError::Failed;
    try expectIdent(path.parent, "collections");
    try expectIdent(path.child, "Vec");
    assert inner.args.len == 1;
    try expectTypeIdent(inner.args[0], "T");
    try expectTypeIdent(outer.args[1], "E");

    let constNode = try! parseTypeStr("InlineVec⟨T, N + 1⟩");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(constAppNode)) =
        constNode.value else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(constApp) = constAppNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::BinOp(constExpr) = constApp.args[1].value
        else throw testing::TestError::Failed;
    assert constExpr.op == ast::BinaryOp::Add;
    try expectIdent(constExpr.left, "N");
    try expectNumber(constExpr.right, "1");

    let rangeNode = try! parseTypeStr("Window⟨0..⟩");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(rangeAppNode)) =
        rangeNode.value else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(rangeApp) = rangeAppNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Range(range) = rangeApp.args[0].value
        else throw testing::TestError::Failed;
    assert range.start <> nil;
    assert range.end == nil;
}

/// Function applications use generic syntax without changing array subscripts.
@test fn testParseGenericFunctionApplications() throws (testing::TestError) {
    let explicit = try! parseExprStr("first⟨i32⟩(value)");
    let case ast::NodeValue::Call(call) = explicit.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(app) = call.callee.value
        else throw testing::TestError::Failed;
    try expectIdent(app.target, "first");
    assert app.args.len == 1;
    try expectIntType(app.args[0], 4, ast::Signedness::Signed);

    let singleSymbolic = try! parseExprStr("first⟨T⟩(value)");
    let case ast::NodeValue::Call(singleCall) = singleSymbolic.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(singleApp) = singleCall.callee.value
        else throw testing::TestError::Failed;
    assert singleApp.args.len == 1;
    try expectTypeIdent(singleApp.args[0], "T");

    let recordExpr = try! parseExprStr("Pair⟨T⟩ { first: value }");
    let case ast::NodeValue::RecordLit(recordLit) = recordExpr.value
        else throw testing::TestError::Failed;
    let recordType = recordLit.typeName else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(recordApp) = recordType.value
        else throw testing::TestError::Failed;
    assert recordApp.args.len == 1;

    let indexedCall = try! parseExprStr("callbacks[*index](value)");
    let case ast::NodeValue::Call(indexed) = indexedCall.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Subscript { index, .. } = indexed.callee.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Deref(indexTarget) = index.value
        else throw testing::TestError::Failed;
    try expectIdent(indexTarget, "index");

    let symbolic = try! parseExprStr("map⟨T, U⟩(value)");
    let case ast::NodeValue::Call(symbolicCall) = symbolic.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(symbolicApp) = symbolicCall.callee.value
        else throw testing::TestError::Failed;
    assert symbolicApp.args.len == 2;

    let functionValue = try! parseExprStr("first⟨i32⟩");
    let case ast::NodeValue::GenericApply(valueApp) = functionValue.value
        else throw testing::TestError::Failed;
    try expectIntType(valueApp.args[0], 4, ast::Signedness::Signed);

    let subscript = try! parseExprStr("values[index]");
    let case ast::NodeValue::Subscript { .. } = subscript.value
        else throw testing::TestError::Failed;
}

/// Instantiation roots retain every applied path in a grouped declaration.
@test fn testParseInstantiateDeclaration() throws (testing::TestError) {
    let node = try! parseStmtStr(
        "instantiate collections::Pair⟨i32, bool⟩, Maybe⟨i32⟩;"
    );
    let case ast::NodeValue::Instantiate(applications) = node.value
        else throw testing::TestError::Failed;
    assert applications.len == 2;
    let case ast::NodeValue::GenericApply(app) = applications[0].value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::ScopeAccess(path) = app.target.value
        else throw testing::TestError::Failed;
    try expectIdent(path.parent, "collections");
    try expectIdent(path.child, "Pair");
    assert app.args.len == 2;
    let case ast::NodeValue::GenericApply(second) = applications[1].value
        else throw testing::TestError::Failed;
    try expectIdent(second.target, "Maybe");
    assert second.args.len == 1;
}

/// Generic syntax reports focused malformed-list diagnostics.
@test fn testParseGenericDiagnostics() throws (testing::TestError) {
    try expectStmtParseError(
        "record Empty⟨⟩ {}", "generic parameter list cannot be empty"
    );
    try expectStmtParseError(
        "record Bad⟨constant constant N: u32⟩ {}", "duplicate `constant` in generic parameter"
    );
    try expectStmtParseError(
        "instantiate Pair⟨i32,⟩;", "expected generic argument after `,`"
    );
    try expectStmtParseError(
        "instantiate Pair;", "`instantiate` requires a generic application"
    );
}