current: scanner::Token,

    /// The most recently consumed token.

    previous: scanner::Token,

    /// Collection of errors encountered during parsing.

    errors: ErrorList,

    /// Allocator backed by the node arena.

    allocator: alloc::Allocator,

    /// Current parsing context (normal or conditional).

    context: Context,

}

/// Create a new parser initialized with the given source kind, source and node arena.

/// The node arena and string pool must outlive the parser.

    return Parser 'pool {

        scanner: scanner::scanner(sourceLoc, source, pool),

        pool,

        current: scanner::invalid(0, ""),

        previous: scanner::invalid(0, ""),

        errors: ErrorList { list: [Error { message: "", token: scanner::invalid(0, "") }; MAX_ERRORS], count: 0 },

        context: Context::Normal,

    };

}

/// Emit a `true` or `false` literal node.

        set node.span.length = 0;

    }

}

/// Save parser state for speculative parsing.

    return SavedState {

        scanner: p.scanner,

        current: p.current,

        previous: p.previous,

        errors: p.errors,

/// Parse a module from source text using the provided arena for node storage.

export unsafe fn parse(sourceLoc: scanner::SourceLoc, input: *[u8], arena: &mut ast::NodeArena, pool: &mut strings::Pool) -> *mut ast::Node

    throws (ParseError)

{

        return try parseModule(&mut p) catch {

            printErrors(&p);

            throw ParseError::UnexpectedToken;

        };

    }

}

/// Scanner state can advance without an unsafe token operation.

@test unsafe fn testSafeTokenOperations() throws (testing::TestError) {

    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

        try checkTokenOperations(&mut parser);

    }

}

/// Parse multiple statements from a string.

unsafe fn parseStmtsStr(input: *[u8]) -> *ast::Node

    throws (testing::TestError)

{

    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

        return try super::parseModule(&mut parser) catch {

            throw testing::TestError::Failed;

        };

    }

}

/// Parse a single type from a string.

unsafe fn parseTypeStr(input: *[u8]) -> *ast::Node

    throws (super::ParseError)

{

    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

        super::advance(&mut parser);

        let root = try super::parseType(&mut parser);

        try super::expect(&mut parser, scanner::TokenKind::Eof, "expected end of type");

        return root;

/// Parse a single expression from a string.

export unsafe fn parseExprStr(input: *[u8]) -> *ast::Node

    throws (super::ParseError)

{

    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

        super::advance(&mut parser);

        return try super::parseExpr(&mut parser);

    }

}

/// Parse a single statement from a string.

unsafe fn parseStmtStr(input: *[u8]) -> *ast::Node

    throws (super::ParseError)

{

    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

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

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

unsafe fn parseNumberLiteral(text: *[u8]) -> fmt::IntLiteral

    throws (testing::TestError)

{

    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

        super::advance(&mut parser);

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

        if not super::check(&parser, scanner::TokenKind::Eof) {

/// Ensure that parsing the supplied literal source fails.

unsafe fn expectNumberLiteralFail(text: *[u8])

    throws (testing::TestError)

{

    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

        super::advance(&mut parser);

        try super::parseExpr(&mut parser) catch {

            return;

        };

}

/// Test scanning source-level `void` produces an identifier, not a type keyword.

@test unsafe fn testParseTypeVoidRejected() throws (testing::TestError) {

    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

        super::advance(&mut parser);

        try testing::expect(super::check(&parser, scanner::TokenKind::Ident));

    }

}

/// Measure committed storage for a statement after an existing node.

unsafe fn statementStorageUsed(source: *[u8]) -> u32 {

    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

    ast::allocNode(&mut arena, ast::Span { offset: 0, length: 0 }, ast::NodeValue::Bool(true));

    let start = alloc::used(&arena.arena);

        super::advance(&mut parser);

        try! super::parseStmt(&mut parser);

    }

}

/// Rewinding a failed expression preserves published nodes and source tokens.

@test unsafe fn testSpeculativeRestoreStorage() throws (testing::TestError) {

    let expectedBytes = statementStorageUsed("return");

    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

    let retained = ast::allocNode(&mut arena, ast::Span { offset: 3, length: 1 }, ast::NodeValue::Bool(true));

        let mut parser = super::mkParser(scanner::SourceLoc::String,

        super::advance(&mut parser);

        try super::expect(&mut parser, scanner::TokenKind::Eof, "retained diagnostic") catch {

        };

        let mut expectedScanner = parser.scanner;

        let expectedCurrent = scanner::next(&mut expectedScanner, parser.pool);

        let expectedPrevious = parser.current;

        let expectedContext = parser.context;

        let statement = try! super::parseStmt(&mut parser);

        let case ast::NodeValue::Return { value } = statement.value else throw testing::TestError::Failed;

        try testing::expect(value == nil);

        try testing::expect(statement.id == startId);

        try testing::expect(parser.scanner.cursor == expectedScanner.cursor);

        try testing::expect(parser.scanner.token == expectedScanner.token);

        try testing::expect(parser.current.kind == expectedCurrent.kind);

        try testing::expect(parser.current.offset == expectedCurrent.offset);

        try testing::expect(parser.previous.kind == expectedPrevious.kind);

        try testing::expect(parser.previous.offset == expectedPrevious.offset);

        try testing::expect(parser.context == expectedContext);

        try testing::expect(parser.errors.count == 1);

            set ARENA_STORAGE[i] = 0xA5;

        }

        let case ast::NodeValue::Bool(true) = retained.value else throw testing::TestError::Failed;

        try testing::expect(retained.span.offset == 3);

        try testing::expect(retained.span.length == 1);

        try testing::expect(mem::eq(parser.errors.list[0].message, "retained diagnostic"));

        try testing::expect(mem::eq(parser.errors.list[0].token.source, "return"));

        let interned = strings::find(parser.pool, "speculativeRestoreIdentifier") else throw testing::TestError::Failed;

        try testing::expect(mem::eq(interned, "speculativeRestoreIdentifier"));

        try testing::expect(replacement.id == startId + 1);

        let case ast::NodeValue::Bool(true) = retained.value else throw testing::TestError::Failed;

    }

}

    let expectedBytes = statementStorageUsed("return");

    for source in ["return (speculativeReturnIdentifier +", "panic (speculativePanicIdentifier +"] {

        let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

        ast::allocNode(&mut arena, ast::Span { offset: 0, length: 0 }, ast::NodeValue::Bool(true));

        let startOffset = alloc::used(&arena.arena);

            super::advance(&mut parser);

            let statement = try! super::parseStmt(&mut parser);

            try testing::expect(statement.id == startId);

            try testing::expect(parser.errors.count == 0);

            try testing::expect(parser.current.kind == scanner::TokenKind::LParen);

            match statement.value {

                case ast::NodeValue::Return { value } => try testing::expect(value == nil),

                case ast::NodeValue::Panic { message } => try testing::expect(message == nil),

}

/// Parse and analyze an expression string for testing.

unsafe fn resolveExprStr 'arena (self: &mut super::Resolver 'arena, stmt: *[u8]) -> TestResult throws (testing::TestError) {

    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

        parser::advance(&mut p);

        let expr = try parser::parseExpr(&mut p) catch {

            panic "resolveExprStr: parsing failed";

        };

            throw testing::TestError::Failed;

        };

        return TestResult { diagnostics, root: expr };

    }

}