//! Parser tests.

use std::mem;

use std::testing;

use std::lang::ast;

use std::lang::scanner;

use std::lang::strings;

/// Unified arena size.

const 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.

pub 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;

}

/// Parse an expression expected to be a number literal and return its payload.

fn parseNumberLiteral(text: *[u8]) -> ast::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.

pub 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.

pub 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 == ast::Radix::Decimal);

}

/// Verify that hexadecimal literals record metadata without marking them signed.

@test fn testParseNumberMetadata() throws (testing::TestError) {

    let lit = try parseNumberLiteral("0xFF");

    try testing::expect(lit.magnitude == 0xFF);

    try testing::expect(lit.radix == ast::Radix::Hex);

    try testing::expect(not lit.signed);

    try testing::expect(not lit.negative);

}

/// 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 == ast::Radix::Binary);

}

/// Signed literals produced by the scanner keep sign details in metadata.

@test fn testParseSignedLiteralMetadata() throws (testing::TestError) {

    let literal = try parseNumberLiteral("42");

    try testing::expect(not literal.signed);

    try testing::expect(not literal.negative);

    try testing::expect(literal.magnitude == 42);

    let neg = try parseNumberLiteral("-99");

    try testing::expect(neg.signed);

    try testing::expect(neg.negative);

    try testing::expect(neg.magnitude == 99);

}

/// Literals with prefixes still parse correctly when explicitly signed.

@test fn testParseSignedPrefixedLiteral() throws (testing::TestError) {

    let hex = try parseNumberLiteral("+0x2A");

    try testing::expect(hex.signed);

    try testing::expect(not hex.negative);

    try testing::expect(hex.radix == ast::Radix::Hex);

    try testing::expect(hex.magnitude == 0x2A);

    let neg = try parseNumberLiteral("-0x2A");

    try testing::expect(neg.signed);

    try testing::expect(neg.negative);

    try testing::expect(neg.radix == ast::Radix::Hex);

    try testing::expect(neg.magnitude == 0x2A);

    let bin = try parseNumberLiteral("-0b11");

    try testing::expect(bin.signed);

    try testing::expect(bin.negative);

    try testing::expect(bin.radix == ast::Radix::Binary);

    try testing::expect(bin.magnitude == 0b11);

}

/// 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");

    try expectNumberLiteralFail("+0x1G");

}

/// Ensure digit-to-value conversion covers decimal and hex ranges.

@test fn testDigitFromAscii() throws (testing::TestError) {

    let zero = super::digitFromAscii('0', 10) else throw testing::TestError::Failed;

    try testing::expect(zero == 0);

    let nine = super::digitFromAscii('9', 10) else throw testing::TestError::Failed;

    try testing::expect(nine == 9);

    let lower = super::digitFromAscii('a', 16) else throw testing::TestError::Failed;

    try testing::expect(lower == 10);

    let lowerF = super::digitFromAscii('f', 16) else throw testing::TestError::Failed;

    try testing::expect(lowerF == 15);

    let upper = super::digitFromAscii('A', 16) else throw testing::TestError::Failed;

    try testing::expect(upper == 10);

    let upperF = super::digitFromAscii('F', 16) else throw testing::TestError::Failed;

    try testing::expect(upperF == 15);

    try testing::expect(super::digitFromAscii('g', 16) == nil);

    try testing::expect(super::digitFromAscii('_', 10) == nil);

}

/// 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 `const` declaration.

@test fn testParseConst() throws (testing::TestError) {

    let node = try! parseStmtStr("const 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("pub 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::Pub);

    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Pub));

}

/// 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);

}

/// Test parsing a pointer type, including `mut`.

@test fn testParseTypePointer() throws (testing::TestError) {

    let node = try! parseTypeStr("*mut i32");

    let case ast::NodeValue::TypeSig(sig) = node.value

        else throw testing::TestError::Failed;

    let case ast::TypeSig::Pointer { valueType, mutable } = sig

        else throw testing::TestError::Failed;

    try expectIntType(valueType, 4, ast::Signedness::Signed);

    try testing::expect(mutable);

}

/// Test parsing an immutable pointer type.

@test fn testParseTypePointerImmutable() throws (testing::TestError) {

    let node = try! parseTypeStr("*i32");

    let case ast::NodeValue::TypeSig(sig) = node.value

        else throw testing::TestError::Failed;

    let case ast::TypeSig::Pointer { valueType, mutable } = sig

        else throw testing::TestError::Failed;

    try expectIntType(valueType, 4, ast::Signedness::Signed);

    try testing::expect(not mutable);

}

/// 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 { itemType, mutable } = sig

        else throw testing::TestError::Failed;

    try expectIntType(itemType, 1, ast::Signedness::Unsigned);

    try testing::expect(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 { itemType, mutable } = sig

        else throw testing::TestError::Failed;

    try expectIntType(itemType, 1, ast::Signedness::Unsigned);

    try testing::expect(mutable);

}

/// 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, mutable: _ } = 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 a function declaration with attributes.

@test fn testParseFnDeclAttributes() throws (testing::TestError) {

    let node = try! parseStmtStr("pub extern 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::Pub);

    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::Pub));

    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 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