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

    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 case ast::NodeValue::TypeSig(sig) = payloadType.value

        else throw testing::TestError::Failed;

    let case ast::TypeSig::Record { fields, .. } = sig

        else throw testing::TestError::Failed;

    try expectNumber(length, "4");

}

/// Test parsing a named record declaration without derives.

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

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

}

/// Test parsing a record declaration with derives.

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

    let node = try! parseStmtStr("record R: Eq + Debug { field: i32 }");

    try testing::expect(flagValue);

}

/// Test parsing an unlabeled record declaration.

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

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

}

/// Test parsing a single-field unlabeled record.

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

    let node = try! parseStmtStr("record R(bool);");

    }

}

/// Test parsing a function declaration with a throws clause.

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

    let case ast::NodeValue::FnDecl(decl) = node.value

        else throw testing::TestError::Failed;

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

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

    try expectTypeIdent(decl.sig.throwList[0], "Error");

    try expectTypeIdent(decl.sig.throwList[1], "Crash");

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

    try expectIdent(var2.name, "Pending");

    try testing::expect(var2.index == 2);

    try testing::expect(var2.value != nil);

}

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

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

    try testing::expect(okFields.len == 1);

    try expectFieldSig(okFields, 0, nil, ast::TypeSig::Bool);

    let errFields = try expectVariant(decl.variants[1], "Error", 1);

}

/// Test parsing a union with derives.

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

    let node = try! parseStmtStr("union Option: Debug + Eq { None, Some(i32) }");

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

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

    try resolveAndExpectConstExpr("@sizeOf(u8)", 1);

    try resolveAndExpectConstExpr("@sizeOf(u16)", 2);

    try resolveAndExpectConstExpr("@sizeOf(u32)", 4);

    try resolveAndExpectConstExpr("@sizeOf(i32)", 4);

    try resolveAndExpectConstExpr("@sizeOf(bool)", 1);

    try resolveAndExpectConstExpr("@sizeOf(*u32)", 8);

    try resolveAndExpectConstExpr("@sizeOf([u8; 10])", 10);

    try resolveAndExpectConstExpr("@sizeOf(*[u32])", 16);

    try resolveAndExpectConstExpr("@sizeOf(?u8)", 2);

    try resolveAndExpectConstExpr("@sizeOf(?u16)", 4);

    try resolveAndExpectConstExpr("@alignOf(u8)", 1);

    try resolveAndExpectConstExpr("@alignOf(u16)", 2);

    try resolveAndExpectConstExpr("@alignOf(u32)", 4);

    try resolveAndExpectConstExpr("@alignOf(i32)", 4);

    try resolveAndExpectConstExpr("@alignOf(bool)", 1);

    try resolveAndExpectConstExpr("@alignOf(*u8)", 8);

    try resolveAndExpectConstExpr("@alignOf(*u16)", 8);

    try resolveAndExpectConstExpr("@alignOf(*u32)", 8);

    try resolveAndExpectConstExpr("@alignOf(*opaque)", 8);

    try resolveAndExpectConstExpr("@alignOf([u8; 8])", 1);

    } {

        let mut a = testResolver();

        let program = "fn voidFn() {} let x = voidFn();";

        let result = try resolveProgramStr(&mut a, program);

        try expectErrorKind(&result, super::ErrorKind::CannotAssignVoid);

    }

}

//

// Module Declaration Tests

/// Descriptor for a single test case, holding its module path, name, and entry point.

pub record TestInfo {

    module: *[u8],

    name: *[u8],

}

/// Construct a [`TestInfo`]. Used by the compiler's synthetic test harness.

    return TestInfo { module, name, func };

}

/// Run all tests and return `0` on success or `1` if any test failed.

pub fn runAllTests(tests: *[TestInfo]) -> i32 {

fn runTest(

    ctx: *mut Ctx,

    module: *[u8],

    name: *[u8],

) {

    io::print("test ");

    io::print(module);

    io::print("::");

    io::print(name);

    assert @alignOf(*[u16]) == 8;

    assert @sizeOf(*mut [u8]) == 16;

    assert @alignOf(*mut [u8]) == 8;

    return 0;

}

/// Calls nested helpers to build the final result.

fn callNested(x: i32, y: i32) -> i32 {

    return add(inc(x), inc(y));

}

fn callVoid() -> i32 {

    doNothing();

    return 1;

}

record Point {

    x: i32,

    y: i32,

}

    p.x = 4;

    p.y = 38;

}

@default fn main() -> i32 {

//! returns: 84

//! Test mutable pointer references.

    *ptr = 42;

}

@default fn main() -> i32 {

    let mut a: i32 = 0;

//! returns: 0

union TestError {

    Failed,

}

@default fn main() -> u32 {

    // Place a guard variable on the stack.

    let mut guard: u32 = 42;

    try voidSuccess() catch {

        return (1) - 42;

    };

    // Guard should still be 42, not clobbered.

union Color { Red, Green, Blue }

union MaybeInt { None, Some(i32) }

fn makeRed() -> Color {

    return Color::Red;

}

fn makeBlue() -> Color {

    return Color::Blue;

}

/// Builds a union variant with a payload.

    return MaybeInt::Some(7);

}

/// Builds a union variant without a payload.

fn makeNone() -> MaybeInt {

}

union Color { Red, Green, Blue }

union Option { None, Some(i32) }

fn makeRed() -> Color {

    return Color::Red;

}

fn assignGreen() -> Color {

    let c: Color = Color::Green;

    return c;

}

fn makeNone() -> Option {

    return Option::None;

}

/// Accesses a variant with payload for comparison.

union Error { Boom }

    if flag {

        throw Error::Boom();

    }

}

    try fallible(flag);

}