radiance · commit

compiler: Borrow parser string pools without copying snapshots

929c447c0daba09a85c93ee38046cec627475bde163cb3ec374e3aa8394a2008

Alexis Sellier committed 7 days ago 1 parent 411cc85d

lib/std/lang/parser.rad +145 -127

    count: u32,
}

/// Snapshot of parser state for speculative parsing.
record SavedState: Copy {
    /// Scanner position, tokens, diagnostics, and expression context.
    parser: Parser,
    /// Scanner position.
    scanner: scanner::Scanner,
    /// Token under examination.
    current: scanner::Token,
    /// Most recently consumed token.
    previous: scanner::Token,
    /// Diagnostics collected before speculative parsing.
    errors: ErrorList,
    /// Expression context before speculative parsing.
    context: Context,
    /// First byte available for tentative allocations.
    arena: u32,
    /// First node identifier available to the tentative parse.
    nextId: u32,
}

            return nil,
    }
}

/// Parser state.
export record Parser: Copy {
export record Parser: 'pool {
    /// The scanner that provides tokens.
    scanner: scanner::Scanner,
    /// Interned string pool. It must remain valid while parsing.
    pool: *unsafe mut strings::Pool,
    /// Interned string pool borrowed for this parse.
    pool: &'pool mut strings::Pool,
    /// The current token being examined.
    current: scanner::Token,
    /// The most recently consumed token.
    previous: scanner::Token,
    /// Collection of errors encountered during parsing.

    /// 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 every copy of the parser.
export unsafe fn mkParser(sourceLoc: scanner::SourceLoc, source: *[u8], arena: &mut ast::NodeArena, pool: *unsafe mut strings::Pool) -> Parser {
    return Parser {
/// The node arena and string pool must outlive the parser.
export unsafe fn mkParser 'pool (sourceLoc: scanner::SourceLoc, source: *[u8], arena: &mut ast::NodeArena, pool: &'pool mut strings::Pool) -> Parser 'pool {
    return Parser 'pool {
        scanner: scanner::scanner(sourceLoc, source, pool),
        pool,
        current: scanner::invalid(0, ""),
        previous: scanner::invalid(0, ""),
        errors: ErrorList { list: undefined, count: 0 },
        errors: ErrorList { list: [Error { message: "", token: scanner::invalid(0, "") }; MAX_ERRORS], count: 0 },
        arena: (&mut *arena) as *unsafe mut ast::NodeArena,
        allocator: alloc::arenaAllocator(&mut arena.arena),
        context: Context::Normal,
    };
}

/// Emit a `true` or `false` literal node.
unsafe fn nodeBool(p: &mut Parser, value: bool) -> *ast::Node {
unsafe fn nodeBool 'pool (p: &mut Parser 'pool, value: bool) -> *ast::Node {
    return node(p, ast::NodeValue::Bool(value));
}

/// Parse an integer literal while mapping shared errors into parser diagnostics.
fn parseIntLiteral(p: &mut Parser, text: *[u8]) -> fmt::IntLiteral
fn parseIntLiteral 'pool (p: &mut Parser 'pool, text: *[u8]) -> fmt::IntLiteral
    throws (ParseError)
{
    let literal = try fmt::parseInt(text) catch err {
        match err {
            case fmt::ParseError::Invalid =>

    };
    return literal;
}

/// Emit an integer type node.
unsafe fn nodeTypeInt(p: &mut Parser, width: u8, sign: ast::Signedness) -> *ast::Node {
unsafe fn nodeTypeInt 'pool (p: &mut Parser 'pool, width: u8, sign: ast::Signedness) -> *ast::Node {
    return node(p, ast::NodeValue::TypeSig(
        ast::TypeSig::Integer { width, sign }
    ));
}

/// Emit a number literal node with the provided literal metadata.
unsafe fn nodeNumber(p: &mut Parser, literal: fmt::IntLiteral) -> *ast::Node {
unsafe fn nodeNumber 'pool (p: &mut Parser 'pool, literal: fmt::IntLiteral) -> *ast::Node {
    return node(p, ast::NodeValue::Number(literal));
}

/// Emit a `super` node.
unsafe fn nodeSuper(p: &mut Parser) -> *ast::Node {
unsafe fn nodeSuper 'pool (p: &mut Parser 'pool) -> *ast::Node {
    return node(p, ast::NodeValue::Super);
}

/// Emit a single attribute node.
unsafe fn nodeAttribute(p: &mut Parser, attr: ast::Attribute) -> *ast::Node {
unsafe fn nodeAttribute 'pool (p: &mut Parser 'pool, attr: ast::Attribute) -> *ast::Node {
    return node(p, ast::NodeValue::Attribute(attr));
}

/// Emit a unary operator node.
unsafe fn nodeUnary(p: &mut Parser, op: ast::UnaryOp, value: *ast::Node) -> *ast::Node {
unsafe fn nodeUnary 'pool (p: &mut Parser 'pool, op: ast::UnaryOp, value: *ast::Node) -> *ast::Node {
    return node(p, ast::NodeValue::UnOp({ op, value }));
}

/// Parse one expression without inheriting a surrounding condition or pattern context.
unsafe fn parseNormalExpr(p: &mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseNormalExpr 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
    let saved = p.context;
    set p.context = Context::Normal;
    let expr = try parseExpr(p);
    set p.context = saved;
    return expr;
}

/// Parse a parenthesized expression without applying postfix operators.
unsafe fn parseParenthesized(p: &mut Parser) -> *ast::Node
unsafe fn parseParenthesized 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LParen, "expected `(`");

    let expr = try parseNormalExpr(p);


    return expr;
}

/// Parse an array literal: `[a, b, c]` or `[item; count]`.
unsafe fn parseArrayLiteral(p: &mut Parser) -> *ast::Node
unsafe fn parseArrayLiteral 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LBracket, "expected `[`");
    if consume(p, scanner::TokenKind::RBracket) { // Empty array: `[]`.
        let empty: *mut [*ast::Node] = &mut [];


    return node(p, ast::NodeValue::ArrayLit(items));
}

/// Parse a function call expression.
unsafe fn parseCall(p: &mut Parser, callee: *ast::Node) -> *ast::Node
unsafe fn parseCall 'pool (p: &mut Parser 'pool, callee: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    let args = try parseList(
        p,
        scanner::TokenKind::LParen,
        scanner::TokenKind::RParen,
        parseNormalExpr
        parseNormalExpr 'pool
    );
    return node(p, ast::NodeValue::Call(
        ast::Call { callee, args }
    ));
}

/// Parse zero or more trailing `as` casts applied to `expr`.
unsafe fn parseAsCast(p: &mut Parser, expr: *ast::Node) -> *ast::Node
unsafe fn parseAsCast 'pool (p: &mut Parser 'pool, expr: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut result = expr;

    while consume(p, scanner::TokenKind::As) {

/// Parse an optional conditional expression suffix.
///
///   `<thenExpr> if <condition> else <elseExpr>`
///
/// If no `if` keyword follows, returns the input expression unchanged.
unsafe fn parseCondExpr(p: &mut Parser, thenExpr: *ast::Node) -> *ast::Node
unsafe fn parseCondExpr 'pool (p: &mut Parser 'pool, thenExpr: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    // Only parse conditional expressions in normal context.
    // In conditional context, `if` is used for guards.
    if p.context <> Context::Normal {

        ast::CondExpr { condition, thenExpr, elseExpr }
    ));
}

/// Parse array subscript or slice expression after `[`.
unsafe fn parseSubscriptOrSlice(p: &mut Parser, container: *ast::Node) -> *ast::Node
unsafe fn parseSubscriptOrSlice 'pool (p: &mut Parser 'pool, container: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LBracket, "expected `[`");

    let mut index: *ast::Node = undefined;


    return node(p, ast::NodeValue::Subscript { container, index });
}

/// Parse postfix operators (eg. field access, function call etc.)
unsafe fn parsePostfix(p: &mut Parser, expr: *ast::Node) -> *ast::Node
unsafe fn parsePostfix 'pool (p: &mut Parser 'pool, expr: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut result = expr;

    loop {

    }
    return result;
}

/// Parse a conditional expression.
export unsafe fn parseCond(p: &mut Parser) -> *ast::Node throws (ParseError) {
export unsafe fn parseCond 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
    let saved = p.context;
    set p.context = Context::Condition;
    let expr = try parseExpr(p);
    set p.context = saved;

    return expr;
}

/// Parse unary expression followed by optional `as` cast.
/// `as` has higher precedence than binary ops but lower than unary.
unsafe fn parseUnary(p: &mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseUnary 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
    let unary = try parseUnaryExpr(p);
    return try parseAsCast(p, unary);
}

/// Parse prefix unary expressions and defer to primary expressions otherwise.
unsafe fn parseUnaryExpr(p: &mut Parser) -> *ast::Node
unsafe fn parseUnaryExpr 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    match p.current.kind {
        case scanner::TokenKind::Not => {
            advance(p);

        }
    }
}

/// Parse the access qualifier after an address operator.
unsafe fn parseAddressKind(p: &mut Parser) -> ast::AddressKind {
fn parseAddressKind 'pool (p: &mut Parser 'pool) -> ast::AddressKind {
    if consume(p, scanner::TokenKind::Mut) {
        return ast::AddressKind::Mutable;
    }
    if check(p, scanner::TokenKind::Ident) and mem::eq(p.current.source, "cell") {
        advance(p);

            return false,
    }
}

/// Build a range expression node with an optional start and end expression.
unsafe fn parseRangeExpr(p: &mut Parser, start: ?*ast::Node) -> *ast::Node
unsafe fn parseRangeExpr 'pool (p: &mut Parser 'pool, start: ?*ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut endExpr: ?*ast::Node = nil;

    if not isRangeTerminator(p.current.kind) {

        ast::Range { start, end: endExpr }
    ));
}

/// Parse binary expressions using precedence climbing.
unsafe fn parseBinary(p: &mut Parser, left: *ast::Node, minPrec: i32) -> *ast::Node
unsafe fn parseBinary 'pool (p: &mut Parser 'pool, left: *ast::Node, minPrec: i32) -> *ast::Node
    throws (ParseError)
{
    let mut result = left;

    loop {

        else => return true,
    }
}

/// Parse a primary leaf expression without postfix operators.
unsafe fn parseLeaf(p: &mut Parser) -> *ast::Node
unsafe fn parseLeaf 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    match p.current.kind {
        case scanner::TokenKind::True => {
            advance(p);

        }
    }
}

/// Parse a primary expression (leaf nodes followed by postfix operators).
unsafe fn parsePrimary(p: &mut Parser) -> *ast::Node
unsafe fn parsePrimary 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let leaf = try parseLeaf(p);
    return try parsePostfix(p, leaf);
}

/// Parse a builtin function call like `@sizeOf(T)` or `@alignOf(T)`.
unsafe fn parseBuiltin(p: &mut Parser) -> *ast::Node
unsafe fn parseBuiltin 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    // Skip the '@' to get the name.
    let ident = p.current.source;
    advance(p);


/// Parse a single expression.
///
/// Parses unary and binary operators using precedence climbing.
/// Conditional expressions (`x if cond else y`) have lowest precedence.
export unsafe fn parseExpr(p: &mut Parser) -> *ast::Node
export unsafe fn parseExpr 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let left = try parseUnary(p);
    let expr = try parseBinary(p, left, -1);
    return try parseCondExpr(p, expr);
}

/// Try to consume a compound assignment operator and return its binary op.
unsafe fn tryCompoundAssignOp(p: &mut Parser) -> ?ast::BinaryOp {
fn tryCompoundAssignOp 'pool (p: &mut Parser 'pool) -> ?ast::BinaryOp {
    match p.current.kind {
        case scanner::TokenKind::PlusEqual =>    { advance(p); return ast::BinaryOp::Add; }
        case scanner::TokenKind::MinusEqual =>   { advance(p); return ast::BinaryOp::Sub; }
        case scanner::TokenKind::StarEqual =>    { advance(p); return ast::BinaryOp::Mul; }
        case scanner::TokenKind::SlashEqual =>   { advance(p); return ast::BinaryOp::Div; }

        else => return nil,
    }
}

/// Parse an expression statement.
export unsafe fn parseExprStmt(p: &mut Parser) -> *ast::Node
export unsafe fn parseExprStmt 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let expr = try parseExpr(p);
    return node(p, ast::NodeValue::ExprStmt(expr));
}

/// Parse a `set` statement assignment.
unsafe fn parseSetStmt(p: &mut Parser) -> *ast::Node
unsafe fn parseSetStmt 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let target = try parseUnary(p);
    if not ast::isPlaceExpr(target) {
        throw failParsing(p, "invalid assignment target");

    }
    throw failParsing(p, "expected assignment after `set`");
}

/// Parse leading attributes and declaration modifiers.
unsafe fn parseAttributes(p: &mut Parser) -> ?ast::Attributes {
unsafe fn parseAttributes 'pool (p: &mut Parser 'pool) -> ?ast::Attributes {
    let mut attrs = ast::nodeSlice(p.arena, 4);

    if let attr = tryParseAnnotation(p) {
        attrs.append(attr, p.allocator);
    }


/// Try to parse an annotation like `@default`.
///
/// Returns `nil` if not a known annotation (e.g. `@sizeOf` or `@alignOf` which are builtins).
/// Only consumes tokens if a valid annotation is found.
unsafe fn tryParseAnnotation(p: &mut Parser) -> ?*ast::Node {
unsafe fn tryParseAnnotation 'pool (p: &mut Parser 'pool) -> ?*ast::Node {
    if not check(p, scanner::TokenKind::AtIdent) {
        return nil;
    }
    // Token is @identifier, skip the '@' to get the name.
    let ident = p.current.source;

}

/// Parse a single statement.
///
/// Dispatches to the appropriate statement parser based on the current token.
export unsafe fn parseStmt(p: &mut Parser) -> *ast::Node
export unsafe fn parseStmt 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    // TODO: Why is `parseStmt` checking for attributes?
    // We should have a `parseDecl` which is top-level, and `parseStmt` which
    // is inside functions.

        }
    }
}

/// Return whether the current `let` statement starts a regional block.
unsafe fn isRegionBlock(p: &Parser) -> bool {
fn isRegionBlock 'pool (p: &mut Parser 'pool) -> bool {
    let mut lookahead = p.scanner;
    return scanner::next(&mut lookahead, p.pool).kind == scanner::TokenKind::Ident
        and scanner::next(&mut lookahead, p.pool).kind == scanner::TokenKind::Colon
        and scanner::next(&mut lookahead, p.pool).kind == scanner::TokenKind::Region;
}

/// Return whether the current `use` statement has an allocation-session header.
unsafe fn isSessionBlock(p: &mut Parser) -> bool {
unsafe fn isSessionBlock 'pool (p: &mut Parser 'pool) -> bool {
    let saved = saveState(p);
    advance(p);
    let source: ?*ast::Node = try? parseUnaryExpr(p);
    let result = source <> nil
        and consume(p, scanner::TokenKind::As)

}

/// Parse statements until the specified ending token is encountered.
///
/// Returns the completed immutable statement list.
export unsafe fn parseStmtsUntil(p: &mut Parser, end: scanner::TokenKind, capacity: u32) -> *[*ast::Node]
export unsafe fn parseStmtsUntil 'pool (p: &mut Parser 'pool, end: scanner::TokenKind, capacity: u32) -> *[*ast::Node]
    throws (ParseError)
{
    let mut statements = ast::nodeSlice(p.arena, capacity);
    while not check(p, end) {
        let stmt = try parseStmt(p);

    }
    return statements;
}

/// Parse a block of statements enclosed in curly braces.
export unsafe fn parseBlock(p: &mut Parser) -> *ast::Node
export unsafe fn parseBlock 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    return try parseBlockBody(p, false);
}

/// Parse a statement block with the specified unsafe permission.
unsafe fn parseBlockBody(p: &mut Parser, isUnsafe: bool) -> *ast::Node
unsafe fn parseBlockBody 'pool (p: &mut Parser 'pool, isUnsafe: bool) -> *ast::Node
    throws (ParseError)
{
    let start = p.current;

    if not consume(p, scanner::TokenKind::LBrace) {


    return node(p, ast::NodeValue::Block(blk));
}

/// Create a block containing a single statement node.
unsafe fn mkBlockWith(p: &mut Parser, node: *ast::Node) -> ast::Block {
unsafe fn mkBlockWith 'pool (p: &mut Parser 'pool, node: *ast::Node) -> ast::Block {
    let stmts = ast::nodeSlice(p.arena, 1).append(node, p.allocator);
    return ast::Block { statements: stmts, isUnsafe: false };
}

/// Parse the branch that follows `else` in let-else style constructs.
///
/// Allows either a block, a single statement like `return`,
/// or a standalone expression which is returned directly.
unsafe fn parseLetElseBranch(p: &mut Parser) -> *ast::Node
unsafe fn parseLetElseBranch 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    if check(p, scanner::TokenKind::LBrace) {
        return try parseBlock(p);
    }

    }
    return branch;
}

/// Allocate a new node from the parser's arena.
unsafe fn node(p: &mut Parser, value: ast::NodeValue) -> *mut ast::Node {
unsafe fn node 'pool (p: &mut Parser 'pool, value: ast::NodeValue) -> *mut ast::Node {
    let span = ast::Span {
        offset: p.previous.offset,
        length: p.previous.source.len,
    };
    let n = ast::allocNode(p.arena, span, value);


    return n;
}

/// Update the span of `node` using the most recently consumed token.
fn finishSpan(p: &mut Parser, node: &mut ast::Node) {
fn finishSpan 'pool (p: &mut Parser 'pool, node: &mut ast::Node) {
    let start: u32 = node.span.offset;
    let mut end: u32 = p.previous.offset + p.previous.source.len;

    if end >= start {
        set node.span.length = end - start;

        set node.span.length = 0;
    }
}

/// Save parser state for speculative parsing.
unsafe fn saveState(p: &Parser) -> SavedState {
unsafe fn saveState 'pool (p: &Parser 'pool) -> SavedState {
    return SavedState {
        parser: *p,
        scanner: p.scanner,
        current: p.current,
        previous: p.previous,
        errors: p.errors,
        context: p.context,
        arena: alloc::save(&p.arena.arena),
        nextId: p.arena.nextId,
    };
}

/// Restore scanner state, diagnostics, arena storage, and node identifiers.
/// Tentative nodes must be unreachable from all state retained by the caller.
/// Interned tokens retain source storage, which must outlive the string pool.
unsafe fn restoreState(p: &mut Parser, s: &SavedState) {
    set *p = s.parser;
unsafe fn restoreState 'pool (p: &mut Parser 'pool, s: &SavedState) {
    set p.scanner = s.scanner;
    set p.current = s.current;
    set p.previous = s.previous;
    set p.errors = s.errors;
    set p.context = s.context;
    alloc::restore(&mut p.arena.arena, s.arena);
    set p.arena.nextId = s.nextId;
}

/// Report a parser error.
fn reportError(p: &mut Parser, token: scanner::Token, message: *[u8]) {
fn reportError 'pool (p: &mut Parser 'pool, token: scanner::Token, message: *[u8]) {
    assert message.len > 0;

    // Ignore errors once the error list is full.
    if p.errors.count < p.errors.list.len {
        set p.errors.list[p.errors.count] = Error { message, token };
        set p.errors.count += 1;
    }
}

/// Fail the parsing process with the given error.
fn failParsing(p: &mut Parser, err: *[u8]) -> ParseError {
fn failParsing 'pool (p: &mut Parser 'pool, err: *[u8]) -> ParseError {
    let token = p.current;
    reportError(p, token, err);
    return ParseError::UnexpectedToken;
}

/// Print all errors that have been collected during parsing.
export fn printErrors(p: &Parser) {
export fn printErrors 'pool (p: &Parser 'pool) {
    for i in 0..p.errors.count {
        let e = p.errors.list[i];
        if let loc = scanner::getLocation(
            p.scanner.sourceLoc, p.scanner.source, e.token.offset
        ) {

        io::print("\n");
    }
}

/// Check whether the current token matches the expected kind.
export fn check(p: &Parser, kind: scanner::TokenKind) -> bool {
export fn check 'pool (p: &Parser 'pool, kind: scanner::TokenKind) -> bool {
    return p.current.kind == kind;
}

/// Advance the parser by one token.
export unsafe fn advance(p: &mut Parser) {
export fn advance 'pool (p: &mut Parser 'pool) {
    set p.previous = p.current;
    set p.current = scanner::next(&mut p.scanner, p.pool);
}

/// Parse an `if let` pattern matching statement.
///
/// Syntax: `if let binding = scrutinee { ... }`
/// Syntax: `if let mut binding = scrutinee { ... }`
unsafe fn parseIfLet(p: &mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseIfLet 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
    try expect(p, scanner::TokenKind::Let, "expected `let`");

    // Parse pattern: either `case <pattern>`, `mut <ident>`, or simple `<ident>`.
    let mut pattern: *ast::Node = undefined;
    let mut kind = ast::PatternKind::Binding;

        elseBranch,
    }));
}

/// Parse a `while let` statement.
unsafe fn parseWhileLet(p: &mut Parser) -> *ast::Node
unsafe fn parseWhileLet 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Let, "expected `let`");

    // Parse pattern: either `case <pattern>`, `mut <ident>`, or simple `<ident>`.

        elseBranch,
    }));
}

/// Parse a `while` statement.
unsafe fn parseWhile(p: &mut Parser) -> *ast::Node
unsafe fn parseWhile 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::While, "expected `while`");

    // Check for `while let` or `while let case` syntax.

        condition, body, elseBranch,
    }));
}

/// Parse a `loop` statement.
unsafe fn parseLoop(p: &mut Parser) -> *ast::Node
unsafe fn parseLoop 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Loop, "expected `loop`");
    let body = try parseBlock(p);

    return node(p, ast::NodeValue::Loop { body });
}

/// Parse a `for` statement.
unsafe fn parseFor(p: &mut Parser) -> *ast::Node
unsafe fn parseFor 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::For, "expected `for`");

    let binding = try parseIdentOrPlaceholder(p, "expected identifier or `_`");

        binding, index, iterable, body, elseBranch,
    }));
}

/// Parse a `return` statement.
unsafe fn parseReturn(p: &mut Parser) -> *ast::Node
unsafe fn parseReturn 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Return, "expected `return`");

    // Speculatively try to parse a return value expression.

    }
    return node(p, ast::NodeValue::Return { value });
}

/// Parse a `throw` statement.
unsafe fn parseThrow(p: &mut Parser) -> *ast::Node
unsafe fn parseThrow 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Throw, "expected `throw`");
    let expr = try parseExpr(p);

    return node(p, ast::NodeValue::Throw { expr });
}

/// Parse a `panic` statement.
unsafe fn parsePanic(p: &mut Parser) -> *ast::Node
unsafe fn parsePanic 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Panic, "expected `panic`");

    // `panic { expr }`.

///
/// Forms:
///   `assert <expr>`
///   `assert <expr>, "message"`
///   `assert { <expr> }, "message"`
unsafe fn parseAssert(p: &mut Parser) -> *ast::Node
unsafe fn parseAssert 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Assert, "expected `assert`");

    // `assert { expr }` block form or `assert <expr>`.

    }
    return node(p, ast::NodeValue::Assert { condition, message });
}

/// Parse a `try` expression with optional `catch` clause(s).
unsafe fn parseTryExpr(p: &mut Parser) -> *ast::Node
unsafe fn parseTryExpr 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Try, "expected `try`");

    let shouldPanic = consume(p, scanner::TokenKind::Bang);

///               d
///           }
///       }
///   }
///
unsafe fn parseIf(p: &mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseIf 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
    try expect(p, scanner::TokenKind::If, "expected `if`");

    // Check for `if let` or `if let case` syntax.
    if check(p, scanner::TokenKind::Let) {
        return try parseIfLet(p);

        condition: cond, thenBranch, elseBranch,
    }));
}

/// Parse a `match` statement.
unsafe fn parseMatch(p: &mut Parser) -> *ast::Node
unsafe fn parseMatch 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Match, "expected `match`");

    let subject = try parseCond(p);

        ast::Match { subject, prongs }
    ));
}

/// Parse a single `match` prong.
unsafe fn parseMatchProng(p: &mut Parser) -> *ast::Node
unsafe fn parseMatchProng 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let mut guard: ?*ast::Node = nil;

    // Case prong: `case <pattern>, ... if <guard> => <body>`.

    ));
}

/// Parse a pattern expression used by `case` constructs.
/// Uses `Pattern` context to allow record literals but not conditional expressions.
unsafe fn parseMatchPattern(p: &mut Parser) -> *ast::Node
unsafe fn parseMatchPattern 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let saved = p.context;
    set p.context = Context::Pattern;
    let pattern = try parseExpr(p);


    return pattern;
}

/// Parse a region name.
unsafe fn parseRegion(p: &mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseRegion 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
    let name = try expect(p, scanner::TokenKind::Region, "expected region name");
    return node(p, ast::NodeValue::Region { name, parent: nil });
}

/// Parse consecutive region names.
unsafe fn parseRegions(p: &mut Parser) -> *mut [*ast::Node] throws (ParseError) {
unsafe fn parseRegions 'pool (p: &mut Parser 'pool) -> *mut [*ast::Node] throws (ParseError) {
    let mut regions = ast::nodeSlice(p.arena, 4);
    while check(p, scanner::TokenKind::Region) {
        regions.append(try parseRegion(p), p.allocator);
    }
    return regions;
}

/// Parse region bounds for a declaration.
unsafe fn parseRegionBounds(p: &mut Parser, regions: &mut [*ast::Node])
unsafe fn parseRegionBounds 'pool (p: &mut Parser 'pool, regions: &mut [*ast::Node])
    throws (ParseError)
{
    if not consume(p, scanner::TokenKind::Where) {
        return;
    }

        }
    }
}

/// Parse scoped borrow bindings.
unsafe fn parseRegionBlock(p: &mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseRegionBlock 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
    advance(p);
    let mut binding = try parseIdent(p, "expected region binding name");
    try expect(p, scanner::TokenKind::Colon, "expected `:` after region binding");
    let regionName = try expect(p, scanner::TokenKind::Region, "expected region name after `:`");
    let mut region = node(p, ast::NodeValue::Region { name: regionName, parent: nil });

    let body = try parseBlock(p);
    return node(p, ast::NodeValue::RegionBlock { region, bindings, body, isSession: false });
}

/// Create a region name from an allocation-session binding name.
unsafe fn sessionRegion(p: &mut Parser, binding: *ast::Node) -> *ast::Node {
unsafe fn sessionRegion 'pool (p: &mut Parser 'pool, binding: *ast::Node) -> *ast::Node {
    let case ast::NodeValue::Ident(name) = binding.value
        else panic "sessionRegion: invalid binding";
    let len = name.len + 1;
    let buf = alloc::remainingBuf(&mut p.arena.arena);
    assert buf.len >= len, "sessionRegion: node arena is full";

    alloc::commit(&mut p.arena.arena, len);
    return node(p, ast::NodeValue::Region { name: &buf[..len], parent: nil });
}

/// Parse an allocation session with an implicit exclusive source borrow.
unsafe fn parseSessionBlock(p: &mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseSessionBlock 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
    try expect(p, scanner::TokenKind::Use, "expected `use`");
    let target = try parseUnaryExpr(p);
    let value = node(p, ast::NodeValue::AddressOf({ target, kind: ast::AddressKind::Mutable }));
    try expect(p, scanner::TokenKind::As, "expected `as` after allocation source");
    let binding = try parseIdent(p, "expected allocation binding after `as`");

    let body = try parseBlock(p);
    return node(p, ast::NodeValue::RegionBlock { region, bindings, body, isSession: true });
}

/// Parse an identifier.
unsafe fn parseIdent(p: &mut Parser, err: *[u8]) -> *ast::Node
unsafe fn parseIdent 'pool (p: &mut Parser 'pool, err: *[u8]) -> *ast::Node
    throws (ParseError)
{
    let source = try expect(p, scanner::TokenKind::Ident, err);
    return node(p, ast::NodeValue::Ident(source));
}

/// Parse either an identifier or a placeholder (`_`).
unsafe fn parseIdentOrPlaceholder(p: &mut Parser, err: *[u8]) -> *ast::Node
unsafe fn parseIdentOrPlaceholder 'pool (p: &mut Parser 'pool, err: *[u8]) -> *ast::Node
    throws (ParseError)
{
    if consume(p, scanner::TokenKind::Underscore) {
        return node(p, ast::NodeValue::Placeholder);
    }

}

/// Parse an alignment specifier.
///
/// Syntax: `align(N)` where N is a power of 2.
unsafe fn parseAlign(p: &mut Parser) -> *ast::Node
unsafe fn parseAlign 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Align, "expected `align`");
    let value = try parseParenthesized(p);
    return node(p, ast::NodeValue::Align { value });


/// Parse a comma-separated list of record fields.
/// The opening delimiter should already be consumed.
/// For labeled fields: `{ name: T, ... }`.
/// For unlabeled fields: `(T, T, ...)`.
unsafe fn parseRecordFields(
    p: &mut Parser,
unsafe fn parseRecordFields 'pool (
    p: &mut Parser 'pool,
    mode: RecordFieldMode
) -> *mut [*ast::Node]
    throws (ParseError)
{
    let terminator = scanner::TokenKind::RBrace if mode == RecordFieldMode::Labeled


    return fields;
}

/// Parse an optional declaration list and separate regions from derives.
unsafe fn parseNominalClauses(
    p: &mut Parser,
unsafe fn parseNominalClauses 'pool (
    p: &mut Parser 'pool,
    regions: &mut *mut [*ast::Node],
    derives: &mut *mut [*ast::Node],
) throws (ParseError) {
    if not consume(p, scanner::TokenKind::Colon) {
        return;

        }
    }
}

/// Parse an optional list of trait names.
unsafe fn parseDerives(p: &mut Parser) -> *mut [*ast::Node] throws (ParseError) {
unsafe fn parseDerives 'pool (p: &mut Parser 'pool) -> *mut [*ast::Node] throws (ParseError) {
    if not consume(p, scanner::TokenKind::Colon) {
        return &mut [];
    }
    let mut derives = ast::nodeSlice(p.arena, 4);
    loop {

    return derives;
}

/// Parse a single record literal field.
/// Can be either labeled, or shorthand.
unsafe fn parseRecordLitField(p: &mut Parser) -> *ast::Node
unsafe fn parseRecordLitField 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let name = try parseIdent(p, "expected field name");
    if consume(p, scanner::TokenKind::Colon) {
        // Labeled field: `name: value`.

}

/// Parse a record literal body.
/// Eg. `{ x: 1, y: 2 }`
/// Eg. `{ x: 1, .. }`
unsafe fn parseRecordLit(p: &mut Parser, typeName: ?*ast::Node) -> *ast::Node
unsafe fn parseRecordLit 'pool (p: &mut Parser 'pool, typeName: ?*ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut fields = ast::nodeSlice(p.arena, MAX_RECORD_FIELDS);
    let mut ignoreRest = false;
    try expect(p, scanner::TokenKind::LBrace, "expected `{` to begin record literal");

    ));
}

/// Parse a named record declaration.
/// `record Point { x: i32, y: i32 }`, or `record Pair(i32, i32);`
unsafe fn parseRecordDecl(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseRecordDecl 'pool (p: &mut Parser 'pool, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Record, "expected `record`");

    let name = try parseIdent(p, "expected record name");

    }
}

/// Parse a union declaration.
/// Example: `union Color { Red, Green, Blue = 5 }`
unsafe fn parseUnionDecl(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseUnionDecl 'pool (p: &mut Parser 'pool, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Union, "expected `union`");

    let name = try parseIdent(p, "expected union name");

        }
    ));
}

/// Parse a function parameter.
unsafe fn parseFnParam(p: &mut Parser) -> *ast::Node
unsafe fn parseFnParam 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let ntv = try parseNameTypeValue(p);
    let type = ntv.type
        else throw failParsing(p, "missing type in function parameter");

        ast::FnParam { name: ntv.name, type }
    ));
}

/// Parse an optional `throws` clause and return the collected type list.
unsafe fn parseThrowList(p: &mut Parser) -> *mut [*ast::Node]
unsafe fn parseThrowList 'pool (p: &mut Parser 'pool) -> *mut [*ast::Node]
    throws (ParseError)
{
    if not consume(p, scanner::TokenKind::Throws) {
        return ast::nodeSlice(p.arena, 0);
    }
    return try parseList(
        p,
        scanner::TokenKind::LParen,
        scanner::TokenKind::RParen,
        parseType
        parseType 'pool
    );
}

/// Parse a function type signature.
unsafe fn parseFnType(p: &mut Parser) -> *ast::Node
unsafe fn parseFnType 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let isUnsafe = consume(p, scanner::TokenKind::Unsafe);
    try expect(p, scanner::TokenKind::Fn, "expected `fn`");
    let params = try parseList(
        p,
        scanner::TokenKind::LParen,
        scanner::TokenKind::RParen,
        parseType
        parseType 'pool
    );
    let mut returnType: ?*ast::Node = nil;

    if consume(p, scanner::TokenKind::Arrow) {
        set returnType = try parseReturnType(p);

        ast::TypeSig::Fn { sig, isUnsafe }
    ));
}

/// Parse a function signature following the function name.
unsafe fn parseFnTypeSig(p: &mut Parser) -> ast::FnSig
unsafe fn parseFnTypeSig 'pool (p: &mut Parser 'pool) -> ast::FnSig
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LParen, "expected `(` after function name");
    let mut params = ast::nodeSlice(p.arena, 8);



    return ast::FnSig { params, returnType, throwList };
}

/// Parse a function return type, including the uninhabited type.
unsafe fn parseReturnType(p: &mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseReturnType 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
    if consume(p, scanner::TokenKind::Bang) {
        return node(p, ast::NodeValue::TypeSig(ast::TypeSig::Never));
    }
    return try parseType(p);
}

/// Parse a function declaration.
unsafe fn parseFnDecl(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseFnDecl 'pool (p: &mut Parser 'pool, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Fn, "expected `fn`");

    // Method syntax: `fn (recv: *Type) name(params) { body }`.

        ast::FnDecl { name, regions, sig, body, attrs: fnAttrs }
    ));
}

/// Parse a pointer-like type after its ownership prefix.
unsafe fn parsePointerLikeType(
    p: &mut Parser,
unsafe fn parsePointerLikeType 'pool (
    p: &mut Parser 'pool,
    class: ast::PointerClass,
) -> *ast::Node throws (ParseError) {
    if check(p, scanner::TokenKind::Ident) and mem::eq(p.current.source, "cell") {
        advance(p);
        let payload = try parseType(p);

        ast::TypeSig::Pointer { class, valueType, mutable }
    ));
}

/// Parse an array type.
unsafe fn parseArrayType(p: &mut Parser) -> *ast::Node
unsafe fn parseArrayType 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LBracket, "expected `[`");
    let itemType = try parseType(p);


    ));
}

/// Parse a type path: an identifier optionally followed by `::` scope access.
/// Returns an identifier node or a scope access chain.
unsafe fn parseTypePath(p: &mut Parser) -> *ast::Node
unsafe fn parseTypePath 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let mut path: *ast::Node = undefined;
    if p.current.kind == scanner::TokenKind::Super {
        advance(p);

    }
    return path;
}

/// Parse a type annotation.
export unsafe fn parseType(p: &mut Parser) -> *ast::Node
export unsafe fn parseType 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    match p.current.kind {
        case scanner::TokenKind::Question => {
            advance(p);


/// Parse a name, optional type, and optional value.
///
/// Used for record field declarations, variable declarations,
/// and record field initializations.
unsafe fn parseNameTypeValue(p: &mut Parser) -> NameTypeValue
unsafe fn parseNameTypeValue 'pool (p: &mut Parser 'pool) -> NameTypeValue
    throws (ParseError)
{
    let name = try parseIdentOrPlaceholder(p, "expected identifier or `_`");
    let mut type: ?*ast::Node = nil;
    let mut alignment: ?*ast::Node = nil;

    }
    return NameTypeValue { name, type, value, alignment };
}

/// Parse a constant declaration.
unsafe fn parseConst(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseConst 'pool (p: &mut Parser 'pool, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Constant, "expected `constant`");

    let ident = try parseIdent(p, "expected identifier in constant declaration");

        ast::ConstDecl { ident, type, value, attrs }
    ));
}

/// Parse a static declaration.
unsafe fn parseStatic(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseStatic 'pool (p: &mut Parser 'pool, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Static, "expected `static`");

    let ident = try parseIdent(p, "expected identifier in static declaration");

        ast::StaticDecl { ident, type, value, attrs }
    ));
}

/// Parse a `use` declaration.
unsafe fn parseUse(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseUse 'pool (p: &mut Parser 'pool, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Use, "expected `use`");

    // Allow `super` or identifier as the first part of the path.

        ast::Use { path, wildcard: false, attrs }
    ));
}

/// Parse a `mod` declaration.
unsafe fn parseMod(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseMod 'pool (p: &mut Parser 'pool, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Mod, "expected `mod`");
    let name = try parseIdent(p, "expected module name after `mod`");


///
/// Eg. `let case <pattern> = <expr> else { ... };`
/// Eg. `let case <pattern> = <expr> if <guard> else { ... };`
///
/// Expects `let case` tokens to have already been consumed.
unsafe fn parseLetCase(p: &mut Parser) -> *ast::Node throws (ParseError) {
unsafe fn parseLetCase 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
    let pattern = try parseMatchPattern(p);

    try expect(p, scanner::TokenKind::Equal, "expected `=` after pattern");
    let expr = try parseCond(p);


/// Eg. `let mut <ident> = <expr> else { ... };`
/// Eg. `let <ident> = <expr> if <guard> else { ... };`
/// Eg. `mut <ident> = <expr>;`
///
/// Expects `let` or `mut` token to have already been consumed.
unsafe fn parseLet(p: &mut Parser, mutable: bool) -> *ast::Node throws (ParseError) {
unsafe fn parseLet 'pool (p: &mut Parser 'pool, mutable: bool) -> *ast::Node throws (ParseError) {
    let binding = try parseNameTypeValue(p);
    let value = binding.value
        else throw failParsing(p, "expected value initializer");

    // Check for optional `else` clause (let-else).

        ident: binding.name, type: binding.type, value, alignment: binding.alignment, mutable,
    }));
}

/// 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: *unsafe mut strings::Pool) -> *mut ast::Node
export unsafe fn parse(sourceLoc: scanner::SourceLoc, input: *[u8], arena: &mut ast::NodeArena, pool: &mut strings::Pool) -> *mut ast::Node
    throws (ParseError)
{
    let mut p = mkParser(sourceLoc, input, arena, pool);
    return try parseModule(&mut p) catch {
        printErrors(&p);
        throw ParseError::UnexpectedToken;
    };
    let poolRef: 'pool = &mut *pool in {
        let mut p = mkParser(sourceLoc, input, arena, poolRef);
        return try parseModule(&mut p) catch {
            printErrors(&p);
            throw ParseError::UnexpectedToken;
        };
    }
}

/// Parse a complete module into a block of top-level statements.
///
/// This is the main entry point for parsing an entire Radiance source file.
/// The parser must already be initialized with source code.
export unsafe fn parseModule(p: &mut Parser) -> *mut ast::Node
export unsafe fn parseModule 'pool (p: &mut Parser 'pool) -> *mut ast::Node
    throws (ParseError)
{
    advance(p); // Set the parser up with a first token.

    let statements = try parseStmtsUntil(p, scanner::TokenKind::Eof, 512);


    return node(p, ast::NodeValue::Block(blk));
}

/// Consume a token of the given kind if present.
export unsafe fn consume(p: &mut Parser, kind: scanner::TokenKind) -> bool {
export fn consume 'pool (p: &mut Parser 'pool, kind: scanner::TokenKind) -> bool {
    if check(p, kind) {
        advance(p);
        return true;
    }
    return false;
}

/// Expect a token of the given kind or report an error.
export unsafe fn expect(p: &mut Parser, kind: scanner::TokenKind, message: *[u8]) -> *[u8]
export fn expect 'pool (p: &mut Parser 'pool, kind: scanner::TokenKind, message: *[u8]) -> *[u8]
    throws (ParseError)
{
    if not consume(p, kind) {
        let token = p.current;
        reportError(p, token, message);

    }
}

/// Parse a trait declaration.
/// Syntax: `trait Name { fn (*Trait) method(...) -> T; ... }`
unsafe fn parseTraitDecl(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseTraitDecl 'pool (p: &mut Parser 'pool, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Trait, "expected `trait`");
    let name = try parseIdent(p, "expected trait name");
    let supertraits = try parseDerives(p);

    return node(p, ast::NodeValue::TraitDecl { name, supertraits, methods, attrs });
}

/// Parse a trait method signature.
/// Syntax: `fn (*Trait) fnord(<params>) -> ReturnType;`
unsafe fn parseTraitMethodSig(p: &mut Parser) -> *ast::Node
unsafe fn parseTraitMethodSig 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    let attrs = parseAttributes(p);
    try expect(p, scanner::TokenKind::Fn, "expected `fn`");
    try expect(p, scanner::TokenKind::LParen, "expected `(` before receiver");

/// Parse an instance block.
/// Syntax: `instance Trait for Type { fn (t: *mut Type) fnord(..) {..} }`
///
/// Instance declarations do not accept attributes (e.g. `export`).
/// Visibility is determined by the trait declaration itself.
unsafe fn parseInstanceDecl(p: &mut Parser) -> *ast::Node
unsafe fn parseInstanceDecl 'pool (p: &mut Parser 'pool) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Instance, "expected `instance`");
    let traitName = try parseTypePath(p);
    try expect(p, scanner::TokenKind::For, "expected `for` after trait name");

/// Parse a method declaration with a receiver.
/// Syntax: `fn (t: *mut Type) fnord(<params>) -> ReturnType { body }`
///
/// Used both inside `instance` blocks and as standalone methods at the top level.
/// Expects the `fn` token to have already been consumed.
unsafe fn parseMethodDecl(p: &mut Parser, attrs: ?ast::Attributes) -> *ast::Node
unsafe fn parseMethodDecl 'pool (p: &mut Parser 'pool, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LParen, "expected `(` before receiver");

    let receiverName = try parseIdent(p, "expected receiver name");

        name, modifiers, receiverName, receiverType, sig, body,
    });
}

/// Parse a comma-separated list enclosed by the given delimiters.
unsafe fn parseList(
    p: &mut Parser,
unsafe fn parseList 'pool (
    p: &mut Parser 'pool,
    open: scanner::TokenKind,
    close: scanner::TokenKind,
    parseItem: unsafe fn (&mut Parser) -> *ast::Node throws (ParseError)
    parseItem: unsafe fn (&mut Parser 'pool) -> *ast::Node throws (ParseError)
) -> *mut [*ast::Node] throws (ParseError) {
    try expect(p, open, listExpectMessage(open));
    let mut items = ast::nodeSlice(p.arena, 8);

    while not check(p, close) {

lib/std/lang/parser/tests.rad +135 -90

    } else {
        try testing::expect(range.end == nil);
    }
}

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

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

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

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

    return root;
        return root;
    }
}

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

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

    return root;
        return root;
    }
}

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

    let node = try! super::parseExpr(&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;
        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;
        return lit;
    }
}

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

    try super::parseExpr(&mut parser) catch {
        return;
    };
    if not super::check(&parser, scanner::TokenKind::Eof) {
        return;
        try super::parseExpr(&mut parser) catch {
            return;
        };
        if not super::check(&parser, scanner::TokenKind::Eof) {
            return;
        }
        throw testing::TestError::Failed;
    }
    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)

}

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

/// Test parsing the unsafe function modifier.
@test unsafe fn testParseUnsafeFnDecl() throws (testing::TestError) {
    let node = try! parseStmtStr("unsafe fn run() {}");

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

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

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

lib/std/lang/resolver/tests.rad +11 -9

}

/// 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[..]);
    let mut p = parser::mkParser(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL);
    parser::advance(&mut p);
    let poolRef: 'pool = &mut STRING_POOL in {
        let mut p = parser::mkParser(scanner::SourceLoc::String, stmt, &mut arena, poolRef);
        parser::advance(&mut p);

    let expr = try parser::parseExpr(&mut p) catch {
        panic "resolveExprStr: parsing failed";
    };
    let diagnostics = try super::resolveExpr(self, expr, &mut arena) catch {
        throw testing::TestError::Failed;
    };
    return TestResult { diagnostics, root: expr };
        let expr = try parser::parseExpr(&mut p) catch {
            panic "resolveExprStr: parsing failed";
        };
        let diagnostics = try super::resolveExpr(self, expr, &mut arena) catch {
            throw testing::TestError::Failed;
        };
        return TestResult { diagnostics, root: expr };
    }
}

/// Parse and analyze a module string for testing.
/// Use this for code with `fn`, `record`, `union`, etc. at the top level.
export unsafe fn resolveProgramStr 'arena (self: &mut super::Resolver 'arena, stmt: *[u8]) -> TestResult throws (testing::TestError) {

144	152		return nil,
145	153		}
146	154		}
147	155
148	156		/// Parser state.
149		-	export record Parser: Copy {
	157	+	export record Parser: 'pool {
150	158		/// The scanner that provides tokens.
151	159		scanner: scanner::Scanner,
152		-	/// Interned string pool. It must remain valid while parsing.
153		-	pool: *unsafe mut strings::Pool,
	160	+	/// Interned string pool borrowed for this parse.
	161	+	pool: &'pool mut strings::Pool,
154	162		/// The current token being examined.
155	163		current: scanner::Token,
156	164		/// The most recently consumed token.
157	165		previous: scanner::Token,
158	166		/// Collection of errors encountered during parsing.

164	172		/// Current parsing context (normal or conditional).
165	173		context: Context,
166	174		}
167	175
168	176		/// Create a new parser initialized with the given source kind, source and node arena.
169		-	/// The node arena and string pool must outlive every copy of the parser.
170		-	export unsafe fn mkParser(sourceLoc: scanner::SourceLoc, source: [u8], arena: &mut ast::NodeArena, pool: unsafe mut strings::Pool) -> Parser {
171		-	return Parser {
	177	+	/// The node arena and string pool must outlive the parser.
	178	+	export unsafe fn mkParser 'pool (sourceLoc: scanner::SourceLoc, source: *[u8], arena: &mut ast::NodeArena, pool: &'pool mut strings::Pool) -> Parser 'pool {
	179	+	return Parser 'pool {
172	180		scanner: scanner::scanner(sourceLoc, source, pool),
173	181		pool,
174	182		current: scanner::invalid(0, ""),
175	183		previous: scanner::invalid(0, ""),
176		-	errors: ErrorList { list: undefined, count: 0 },
	184	+	errors: ErrorList { list: [Error { message: "", token: scanner::invalid(0, "") }; MAX_ERRORS], count: 0 },
177	185		arena: (&mut arena) as unsafe mut ast::NodeArena,
178	186		allocator: alloc::arenaAllocator(&mut arena.arena),
179	187		context: Context::Normal,
180	188		};
181	189		}
182	190
183	191		/// Emit a `true` or `false` literal node.
184		-	unsafe fn nodeBool(p: &mut Parser, value: bool) -> *ast::Node {
	192	+	unsafe fn nodeBool 'pool (p: &mut Parser 'pool, value: bool) -> *ast::Node {
185	193		return node(p, ast::NodeValue::Bool(value));
186	194		}
187	195
188	196		/// Parse an integer literal while mapping shared errors into parser diagnostics.
189		-	fn parseIntLiteral(p: &mut Parser, text: *[u8]) -> fmt::IntLiteral
	197	+	fn parseIntLiteral 'pool (p: &mut Parser 'pool, text: *[u8]) -> fmt::IntLiteral
190	198		throws (ParseError)
191	199		{
192	200		let literal = try fmt::parseInt(text) catch err {
193	201		match err {
194	202		case fmt::ParseError::Invalid =>

201	209		};
202	210		return literal;
203	211		}
204	212
205	213		/// Emit an integer type node.
206		-	unsafe fn nodeTypeInt(p: &mut Parser, width: u8, sign: ast::Signedness) -> *ast::Node {
	214	+	unsafe fn nodeTypeInt 'pool (p: &mut Parser 'pool, width: u8, sign: ast::Signedness) -> *ast::Node {
207	215		return node(p, ast::NodeValue::TypeSig(
208	216		ast::TypeSig::Integer { width, sign }
209	217		));
210	218		}
211	219
212	220		/// Emit a number literal node with the provided literal metadata.
213		-	unsafe fn nodeNumber(p: &mut Parser, literal: fmt::IntLiteral) -> *ast::Node {
	221	+	unsafe fn nodeNumber 'pool (p: &mut Parser 'pool, literal: fmt::IntLiteral) -> *ast::Node {
214	222		return node(p, ast::NodeValue::Number(literal));
215	223		}
216	224
217	225		/// Emit a `super` node.
218		-	unsafe fn nodeSuper(p: &mut Parser) -> *ast::Node {
	226	+	unsafe fn nodeSuper 'pool (p: &mut Parser 'pool) -> *ast::Node {
219	227		return node(p, ast::NodeValue::Super);
220	228		}
221	229
222	230		/// Emit a single attribute node.
223		-	unsafe fn nodeAttribute(p: &mut Parser, attr: ast::Attribute) -> *ast::Node {
	231	+	unsafe fn nodeAttribute 'pool (p: &mut Parser 'pool, attr: ast::Attribute) -> *ast::Node {
224	232		return node(p, ast::NodeValue::Attribute(attr));
225	233		}
226	234
227	235		/// Emit a unary operator node.
228		-	unsafe fn nodeUnary(p: &mut Parser, op: ast::UnaryOp, value: ast::Node) -> ast::Node {
	236	+	unsafe fn nodeUnary 'pool (p: &mut Parser 'pool, op: ast::UnaryOp, value: ast::Node) -> ast::Node {
229	237		return node(p, ast::NodeValue::UnOp({ op, value }));
230	238		}
231	239
232	240		/// Parse one expression without inheriting a surrounding condition or pattern context.
233		-	unsafe fn parseNormalExpr(p: &mut Parser) -> *ast::Node throws (ParseError) {
	241	+	unsafe fn parseNormalExpr 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
234	242		let saved = p.context;
235	243		set p.context = Context::Normal;
236	244		let expr = try parseExpr(p);
237	245		set p.context = saved;
238	246		return expr;
239	247		}
240	248
241	249		/// Parse a parenthesized expression without applying postfix operators.
242		-	unsafe fn parseParenthesized(p: &mut Parser) -> *ast::Node
	250	+	unsafe fn parseParenthesized 'pool (p: &mut Parser 'pool) -> *ast::Node
243	251		throws (ParseError)
244	252		{
245	253		try expect(p, scanner::TokenKind::LParen, "expected `(`");
246	254
247	255		let expr = try parseNormalExpr(p);

250	258
251	259		return expr;
252	260		}
253	261
254	262		/// Parse an array literal: `[a, b, c]` or `[item; count]`.
255		-	unsafe fn parseArrayLiteral(p: &mut Parser) -> *ast::Node
	263	+	unsafe fn parseArrayLiteral 'pool (p: &mut Parser 'pool) -> *ast::Node
256	264		throws (ParseError)
257	265		{
258	266		try expect(p, scanner::TokenKind::LBracket, "expected `[`");
259	267		if consume(p, scanner::TokenKind::RBracket) { // Empty array: `[]`.
260	268		let empty: mut [ast::Node] = &mut [];

282	290
283	291		return node(p, ast::NodeValue::ArrayLit(items));
284	292		}
285	293
286	294		/// Parse a function call expression.
287		-	unsafe fn parseCall(p: &mut Parser, callee: ast::Node) -> ast::Node
	295	+	unsafe fn parseCall 'pool (p: &mut Parser 'pool, callee: ast::Node) -> ast::Node
288	296		throws (ParseError)
289	297		{
290	298		let args = try parseList(
291	299		p,
292	300		scanner::TokenKind::LParen,
293	301		scanner::TokenKind::RParen,
294		-	parseNormalExpr
	302	+	parseNormalExpr 'pool
295	303		);
296	304		return node(p, ast::NodeValue::Call(
297	305		ast::Call { callee, args }
298	306		));
299	307		}
300	308
301	309		/// Parse zero or more trailing `as` casts applied to `expr`.
302		-	unsafe fn parseAsCast(p: &mut Parser, expr: ast::Node) -> ast::Node
	310	+	unsafe fn parseAsCast 'pool (p: &mut Parser 'pool, expr: ast::Node) -> ast::Node
303	311		throws (ParseError)
304	312		{
305	313		let mut result = expr;
306	314
307	315		while consume(p, scanner::TokenKind::As) {

84	84		count: u32,
85	85		}
86	86
87	87		/// Snapshot of parser state for speculative parsing.
88	88		record SavedState: Copy {
89		-	/// Scanner position, tokens, diagnostics, and expression context.
90		-	parser: Parser,
	89	+	/// Scanner position.
	90	+	scanner: scanner::Scanner,
	91	+	/// Token under examination.
	92	+	current: scanner::Token,
	93	+	/// Most recently consumed token.
	94	+	previous: scanner::Token,
	95	+	/// Diagnostics collected before speculative parsing.
	96	+	errors: ErrorList,
	97	+	/// Expression context before speculative parsing.
	98	+	context: Context,
91	99		/// First byte available for tentative allocations.
92	100		arena: u32,
93	101		/// First node identifier available to the tentative parse.
94	102		nextId: u32,
95	103		}

317	325		/// Parse an optional conditional expression suffix.
318	326		///
319	327		/// `<thenExpr> if <condition> else <elseExpr>`
320	328		///
321	329		/// If no `if` keyword follows, returns the input expression unchanged.
322		-	unsafe fn parseCondExpr(p: &mut Parser, thenExpr: ast::Node) -> ast::Node
	330	+	unsafe fn parseCondExpr 'pool (p: &mut Parser 'pool, thenExpr: ast::Node) -> ast::Node
323	331		throws (ParseError)
324	332		{
325	333		// Only parse conditional expressions in normal context.
326	334		// In conditional context, `if` is used for guards.
327	335		if p.context <> Context::Normal {

338	346		ast::CondExpr { condition, thenExpr, elseExpr }
339	347		));
340	348		}
341	349
342	350		/// Parse array subscript or slice expression after `[`.
343		-	unsafe fn parseSubscriptOrSlice(p: &mut Parser, container: ast::Node) -> ast::Node
	351	+	unsafe fn parseSubscriptOrSlice 'pool (p: &mut Parser 'pool, container: ast::Node) -> ast::Node
344	352		throws (ParseError)
345	353		{
346	354		try expect(p, scanner::TokenKind::LBracket, "expected `[`");
347	355
348	356		let mut index: *ast::Node = undefined;

378	386
379	387		return node(p, ast::NodeValue::Subscript { container, index });
380	388		}
381	389
382	390		/// Parse postfix operators (eg. field access, function call etc.)
383		-	unsafe fn parsePostfix(p: &mut Parser, expr: ast::Node) -> ast::Node
	391	+	unsafe fn parsePostfix 'pool (p: &mut Parser 'pool, expr: ast::Node) -> ast::Node
384	392		throws (ParseError)
385	393		{
386	394		let mut result = expr;
387	395
388	396		loop {

428	436		}
429	437		return result;
430	438		}
431	439
432	440		/// Parse a conditional expression.
433		-	export unsafe fn parseCond(p: &mut Parser) -> *ast::Node throws (ParseError) {
	441	+	export unsafe fn parseCond 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
434	442		let saved = p.context;
435	443		set p.context = Context::Condition;
436	444		let expr = try parseExpr(p);
437	445		set p.context = saved;
438	446
439	447		return expr;
440	448		}
441	449
442	450		/// Parse unary expression followed by optional `as` cast.
443	451		/// `as` has higher precedence than binary ops but lower than unary.
444		-	unsafe fn parseUnary(p: &mut Parser) -> *ast::Node throws (ParseError) {
	452	+	unsafe fn parseUnary 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
445	453		let unary = try parseUnaryExpr(p);
446	454		return try parseAsCast(p, unary);
447	455		}
448	456
449	457		/// Parse prefix unary expressions and defer to primary expressions otherwise.
450		-	unsafe fn parseUnaryExpr(p: &mut Parser) -> *ast::Node
	458	+	unsafe fn parseUnaryExpr 'pool (p: &mut Parser 'pool) -> *ast::Node
451	459		throws (ParseError)
452	460		{
453	461		match p.current.kind {
454	462		case scanner::TokenKind::Not => {
455	463		advance(p);

482	490		}
483	491		}
484	492		}
485	493
486	494		/// Parse the access qualifier after an address operator.
487		-	unsafe fn parseAddressKind(p: &mut Parser) -> ast::AddressKind {
	495	+	fn parseAddressKind 'pool (p: &mut Parser 'pool) -> ast::AddressKind {
488	496		if consume(p, scanner::TokenKind::Mut) {
489	497		return ast::AddressKind::Mutable;
490	498		}
491	499		if check(p, scanner::TokenKind::Ident) and mem::eq(p.current.source, "cell") {
492	500		advance(p);

523	531		return false,
524	532		}
525	533		}
526	534
527	535		/// Build a range expression node with an optional start and end expression.
528		-	unsafe fn parseRangeExpr(p: &mut Parser, start: ?ast::Node) -> ast::Node
	536	+	unsafe fn parseRangeExpr 'pool (p: &mut Parser 'pool, start: ?ast::Node) -> ast::Node
529	537		throws (ParseError)
530	538		{
531	539		let mut endExpr: ?*ast::Node = nil;
532	540
533	541		if not isRangeTerminator(p.current.kind) {

538	546		ast::Range { start, end: endExpr }
539	547		));
540	548		}
541	549
542	550		/// Parse binary expressions using precedence climbing.
543		-	unsafe fn parseBinary(p: &mut Parser, left: ast::Node, minPrec: i32) -> ast::Node
	551	+	unsafe fn parseBinary 'pool (p: &mut Parser 'pool, left: ast::Node, minPrec: i32) -> ast::Node
544	552		throws (ParseError)
545	553		{
546	554		let mut result = left;
547	555
548	556		loop {

607	615		else => return true,
608	616		}
609	617		}
610	618
611	619		/// Parse a primary leaf expression without postfix operators.
612		-	unsafe fn parseLeaf(p: &mut Parser) -> *ast::Node
	620	+	unsafe fn parseLeaf 'pool (p: &mut Parser 'pool) -> *ast::Node
613	621		throws (ParseError)
614	622		{
615	623		match p.current.kind {
616	624		case scanner::TokenKind::True => {
617	625		advance(p);

695	703		}
696	704		}
697	705		}
698	706
699	707		/// Parse a primary expression (leaf nodes followed by postfix operators).
700		-	unsafe fn parsePrimary(p: &mut Parser) -> *ast::Node
	708	+	unsafe fn parsePrimary 'pool (p: &mut Parser 'pool) -> *ast::Node
701	709		throws (ParseError)
702	710		{
703	711		let leaf = try parseLeaf(p);
704	712		return try parsePostfix(p, leaf);
705	713		}
706	714
707	715		/// Parse a builtin function call like `@sizeOf(T)` or `@alignOf(T)`.
708		-	unsafe fn parseBuiltin(p: &mut Parser) -> *ast::Node
	716	+	unsafe fn parseBuiltin 'pool (p: &mut Parser 'pool) -> *ast::Node
709	717		throws (ParseError)
710	718		{
711	719		// Skip the '@' to get the name.
712	720		let ident = p.current.source;
713	721		advance(p);

748	756
749	757		/// Parse a single expression.
750	758		///
751	759		/// Parses unary and binary operators using precedence climbing.
752	760		/// Conditional expressions (`x if cond else y`) have lowest precedence.
753		-	export unsafe fn parseExpr(p: &mut Parser) -> *ast::Node
	761	+	export unsafe fn parseExpr 'pool (p: &mut Parser 'pool) -> *ast::Node
754	762		throws (ParseError)
755	763		{
756	764		let left = try parseUnary(p);
757	765		let expr = try parseBinary(p, left, -1);
758	766		return try parseCondExpr(p, expr);
759	767		}
760	768
761	769		/// Try to consume a compound assignment operator and return its binary op.
762		-	unsafe fn tryCompoundAssignOp(p: &mut Parser) -> ?ast::BinaryOp {
	770	+	fn tryCompoundAssignOp 'pool (p: &mut Parser 'pool) -> ?ast::BinaryOp {
763	771		match p.current.kind {
764	772		case scanner::TokenKind::PlusEqual => { advance(p); return ast::BinaryOp::Add; }
765	773		case scanner::TokenKind::MinusEqual => { advance(p); return ast::BinaryOp::Sub; }
766	774		case scanner::TokenKind::StarEqual => { advance(p); return ast::BinaryOp::Mul; }
767	775		case scanner::TokenKind::SlashEqual => { advance(p); return ast::BinaryOp::Div; }

774	782		else => return nil,
775	783		}
776	784		}
777	785
778	786		/// Parse an expression statement.
779		-	export unsafe fn parseExprStmt(p: &mut Parser) -> *ast::Node
	787	+	export unsafe fn parseExprStmt 'pool (p: &mut Parser 'pool) -> *ast::Node
780	788		throws (ParseError)
781	789		{
782	790		let expr = try parseExpr(p);
783	791		return node(p, ast::NodeValue::ExprStmt(expr));
784	792		}
785	793
786	794		/// Parse a `set` statement assignment.
787		-	unsafe fn parseSetStmt(p: &mut Parser) -> *ast::Node
	795	+	unsafe fn parseSetStmt 'pool (p: &mut Parser 'pool) -> *ast::Node
788	796		throws (ParseError)
789	797		{
790	798		let target = try parseUnary(p);
791	799		if not ast::isPlaceExpr(target) {
792	800		throw failParsing(p, "invalid assignment target");

810	818		}
811	819		throw failParsing(p, "expected assignment after `set`");
812	820		}
813	821
814	822		/// Parse leading attributes and declaration modifiers.
815		-	unsafe fn parseAttributes(p: &mut Parser) -> ?ast::Attributes {
	823	+	unsafe fn parseAttributes 'pool (p: &mut Parser 'pool) -> ?ast::Attributes {
816	824		let mut attrs = ast::nodeSlice(p.arena, 4);
817	825
818	826		if let attr = tryParseAnnotation(p) {
819	827		attrs.append(attr, p.allocator);
820	828		}

832	840
833	841		/// Try to parse an annotation like `@default`.
834	842		///
835	843		/// Returns `nil` if not a known annotation (e.g. `@sizeOf` or `@alignOf` which are builtins).
836	844		/// Only consumes tokens if a valid annotation is found.
837		-	unsafe fn tryParseAnnotation(p: &mut Parser) -> ?*ast::Node {
	845	+	unsafe fn tryParseAnnotation 'pool (p: &mut Parser 'pool) -> ?*ast::Node {
838	846		if not check(p, scanner::TokenKind::AtIdent) {
839	847		return nil;
840	848		}
841	849		// Token is @identifier, skip the '@' to get the name.
842	850		let ident = p.current.source;

856	864		}
857	865
858	866		/// Parse a single statement.
859	867		///
860	868		/// Dispatches to the appropriate statement parser based on the current token.
861		-	export unsafe fn parseStmt(p: &mut Parser) -> *ast::Node
	869	+	export unsafe fn parseStmt 'pool (p: &mut Parser 'pool) -> *ast::Node
862	870		throws (ParseError)
863	871		{
864	872		// TODO: Why is `parseStmt` checking for attributes?
865	873		// We should have a `parseDecl` which is top-level, and `parseStmt` which
866	874		// is inside functions.

986	994		}
987	995		}
988	996		}
989	997
990	998		/// Return whether the current `let` statement starts a regional block.
991		-	unsafe fn isRegionBlock(p: &Parser) -> bool {
	999	+	fn isRegionBlock 'pool (p: &mut Parser 'pool) -> bool {
992	1000		let mut lookahead = p.scanner;
993	1001		return scanner::next(&mut lookahead, p.pool).kind == scanner::TokenKind::Ident
994	1002		and scanner::next(&mut lookahead, p.pool).kind == scanner::TokenKind::Colon
995	1003		and scanner::next(&mut lookahead, p.pool).kind == scanner::TokenKind::Region;
996	1004		}
997	1005
998	1006		/// Return whether the current `use` statement has an allocation-session header.
999		-	unsafe fn isSessionBlock(p: &mut Parser) -> bool {
	1007	+	unsafe fn isSessionBlock 'pool (p: &mut Parser 'pool) -> bool {
1000	1008		let saved = saveState(p);
1001	1009		advance(p);
1002	1010		let source: ?*ast::Node = try? parseUnaryExpr(p);
1003	1011		let result = source <> nil
1004	1012		and consume(p, scanner::TokenKind::As)

1009	1017		}
1010	1018
1011	1019		/// Parse statements until the specified ending token is encountered.
1012	1020		///
1013	1021		/// Returns the completed immutable statement list.
1014		-	export unsafe fn parseStmtsUntil(p: &mut Parser, end: scanner::TokenKind, capacity: u32) -> [ast::Node]
	1022	+	export unsafe fn parseStmtsUntil 'pool (p: &mut Parser 'pool, end: scanner::TokenKind, capacity: u32) -> [ast::Node]
1015	1023		throws (ParseError)
1016	1024		{
1017	1025		let mut statements = ast::nodeSlice(p.arena, capacity);
1018	1026		while not check(p, end) {
1019	1027		let stmt = try parseStmt(p);

1031	1039		}
1032	1040		return statements;
1033	1041		}
1034	1042
1035	1043		/// Parse a block of statements enclosed in curly braces.
1036		-	export unsafe fn parseBlock(p: &mut Parser) -> *ast::Node
	1044	+	export unsafe fn parseBlock 'pool (p: &mut Parser 'pool) -> *ast::Node
1037	1045		throws (ParseError)
1038	1046		{
1039	1047		return try parseBlockBody(p, false);
1040	1048		}
1041	1049
1042	1050		/// Parse a statement block with the specified unsafe permission.
1043		-	unsafe fn parseBlockBody(p: &mut Parser, isUnsafe: bool) -> *ast::Node
	1051	+	unsafe fn parseBlockBody 'pool (p: &mut Parser 'pool, isUnsafe: bool) -> *ast::Node
1044	1052		throws (ParseError)
1045	1053		{
1046	1054		let start = p.current;
1047	1055
1048	1056		if not consume(p, scanner::TokenKind::LBrace) {

1054	1062
1055	1063		return node(p, ast::NodeValue::Block(blk));
1056	1064		}
1057	1065
1058	1066		/// Create a block containing a single statement node.
1059		-	unsafe fn mkBlockWith(p: &mut Parser, node: *ast::Node) -> ast::Block {
	1067	+	unsafe fn mkBlockWith 'pool (p: &mut Parser 'pool, node: *ast::Node) -> ast::Block {
1060	1068		let stmts = ast::nodeSlice(p.arena, 1).append(node, p.allocator);
1061	1069		return ast::Block { statements: stmts, isUnsafe: false };
1062	1070		}
1063	1071
1064	1072		/// Parse the branch that follows `else` in let-else style constructs.
1065	1073		///
1066	1074		/// Allows either a block, a single statement like `return`,
1067	1075		/// or a standalone expression which is returned directly.
1068		-	unsafe fn parseLetElseBranch(p: &mut Parser) -> *ast::Node
	1076	+	unsafe fn parseLetElseBranch 'pool (p: &mut Parser 'pool) -> *ast::Node
1069	1077		throws (ParseError)
1070	1078		{
1071	1079		if check(p, scanner::TokenKind::LBrace) {
1072	1080		return try parseBlock(p);
1073	1081		}

1078	1086		}
1079	1087		return branch;
1080	1088		}
1081	1089
1082	1090		/// Allocate a new node from the parser's arena.
1083		-	unsafe fn node(p: &mut Parser, value: ast::NodeValue) -> *mut ast::Node {
	1091	+	unsafe fn node 'pool (p: &mut Parser 'pool, value: ast::NodeValue) -> *mut ast::Node {
1084	1092		let span = ast::Span {
1085	1093		offset: p.previous.offset,
1086	1094		length: p.previous.source.len,
1087	1095		};
1088	1096		let n = ast::allocNode(p.arena, span, value);

1090	1098
1091	1099		return n;
1092	1100		}
1093	1101
1094	1102		/// Update the span of `node` using the most recently consumed token.
1095		-	fn finishSpan(p: &mut Parser, node: &mut ast::Node) {
	1103	+	fn finishSpan 'pool (p: &mut Parser 'pool, node: &mut ast::Node) {
1096	1104		let start: u32 = node.span.offset;
1097	1105		let mut end: u32 = p.previous.offset + p.previous.source.len;
1098	1106
1099	1107		if end >= start {
1100	1108		set node.span.length = end - start;

1102	1110		set node.span.length = 0;
1103	1111		}
1104	1112		}
1105	1113
1106	1114		/// Save parser state for speculative parsing.
1107		-	unsafe fn saveState(p: &Parser) -> SavedState {
	1115	+	unsafe fn saveState 'pool (p: &Parser 'pool) -> SavedState {
1108	1116		return SavedState {
1109		-	parser: *p,
	1117	+	scanner: p.scanner,
	1118	+	current: p.current,
	1119	+	previous: p.previous,
	1120	+	errors: p.errors,
	1121	+	context: p.context,
1110	1122		arena: alloc::save(&p.arena.arena),
1111	1123		nextId: p.arena.nextId,
1112	1124		};
1113	1125		}
1114	1126
1115	1127		/// Restore scanner state, diagnostics, arena storage, and node identifiers.
1116	1128		/// Tentative nodes must be unreachable from all state retained by the caller.
1117	1129		/// Interned tokens retain source storage, which must outlive the string pool.
1118		-	unsafe fn restoreState(p: &mut Parser, s: &SavedState) {
1119		-	set *p = s.parser;
	1130	+	unsafe fn restoreState 'pool (p: &mut Parser 'pool, s: &SavedState) {
	1131	+	set p.scanner = s.scanner;
	1132	+	set p.current = s.current;
	1133	+	set p.previous = s.previous;
	1134	+	set p.errors = s.errors;
	1135	+	set p.context = s.context;
1120	1136		alloc::restore(&mut p.arena.arena, s.arena);
1121	1137		set p.arena.nextId = s.nextId;
1122	1138		}
1123	1139
1124	1140		/// Report a parser error.
1125		-	fn reportError(p: &mut Parser, token: scanner::Token, message: *[u8]) {
	1141	+	fn reportError 'pool (p: &mut Parser 'pool, token: scanner::Token, message: *[u8]) {
1126	1142		assert message.len > 0;
1127	1143
1128	1144		// Ignore errors once the error list is full.
1129	1145		if p.errors.count < p.errors.list.len {
1130	1146		set p.errors.list[p.errors.count] = Error { message, token };
1131	1147		set p.errors.count += 1;
1132	1148		}
1133	1149		}
1134	1150
1135	1151		/// Fail the parsing process with the given error.
1136		-	fn failParsing(p: &mut Parser, err: *[u8]) -> ParseError {
	1152	+	fn failParsing 'pool (p: &mut Parser 'pool, err: *[u8]) -> ParseError {
1137	1153		let token = p.current;
1138	1154		reportError(p, token, err);
1139	1155		return ParseError::UnexpectedToken;
1140	1156		}
1141	1157
1142	1158		/// Print all errors that have been collected during parsing.
1143		-	export fn printErrors(p: &Parser) {
	1159	+	export fn printErrors 'pool (p: &Parser 'pool) {
1144	1160		for i in 0..p.errors.count {
1145	1161		let e = p.errors.list[i];
1146	1162		if let loc = scanner::getLocation(
1147	1163		p.scanner.sourceLoc, p.scanner.source, e.token.offset
1148	1164		) {

1169	1185		io::print("\n");
1170	1186		}
1171	1187		}
1172	1188
1173	1189		/// Check whether the current token matches the expected kind.
1174		-	export fn check(p: &Parser, kind: scanner::TokenKind) -> bool {
	1190	+	export fn check 'pool (p: &Parser 'pool, kind: scanner::TokenKind) -> bool {
1175	1191		return p.current.kind == kind;
1176	1192		}
1177	1193
1178	1194		/// Advance the parser by one token.
1179		-	export unsafe fn advance(p: &mut Parser) {
	1195	+	export fn advance 'pool (p: &mut Parser 'pool) {
1180	1196		set p.previous = p.current;
1181	1197		set p.current = scanner::next(&mut p.scanner, p.pool);
1182	1198		}
1183	1199
1184	1200		/// Parse an `if let` pattern matching statement.
1185	1201		///
1186	1202		/// Syntax: `if let binding = scrutinee { ... }`
1187	1203		/// Syntax: `if let mut binding = scrutinee { ... }`
1188		-	unsafe fn parseIfLet(p: &mut Parser) -> *ast::Node throws (ParseError) {
	1204	+	unsafe fn parseIfLet 'pool (p: &mut Parser 'pool) -> *ast::Node throws (ParseError) {
1189	1205		try expect(p, scanner::TokenKind::Let, "expected `let`");
1190	1206
1191	1207		// Parse pattern: either `case <pattern>`, `mut <ident>`, or simple `<ident>`.
1192	1208		let mut pattern: *ast::Node = undefined;
1193	1209		let mut kind = ast::PatternKind::Binding;

1227	1243		elseBranch,
1228	1244		}));
1229	1245		}
1230	1246
1231	1247		/// Parse a `while let` statement.
1232		-	unsafe fn parseWhileLet(p: &mut Parser) -> *ast::Node
	1248	+	unsafe fn parseWhileLet 'pool (p: &mut Parser 'pool) -> *ast::Node
1233	1249		throws (ParseError)
1234	1250		{
1235	1251		try expect(p, scanner::TokenKind::Let, "expected `let`");
1236	1252
1237	1253		// Parse pattern: either `case <pattern>`, `mut <ident>`, or simple `<ident>`.

1265	1281		elseBranch,
1266	1282		}));
1267	1283		}
1268	1284
1269	1285		/// Parse a `while` statement.
1270		-	unsafe fn parseWhile(p: &mut Parser) -> *ast::Node
	1286	+	unsafe fn parseWhile 'pool (p: &mut Parser 'pool) -> *ast::Node
1271	1287		throws (ParseError)
1272	1288		{
1273	1289		try expect(p, scanner::TokenKind::While, "expected `while`");
1274	1290
1275	1291		// Check for `while let` or `while let case` syntax.

1287	1303		condition, body, elseBranch,
1288	1304		}));
1289	1305		}
1290	1306
1291	1307		/// Parse a `loop` statement.
1292		-	unsafe fn parseLoop(p: &mut Parser) -> *ast::Node
	1308	+	unsafe fn parseLoop 'pool (p: &mut Parser 'pool) -> *ast::Node
1293	1309		throws (ParseError)
1294	1310		{
1295	1311		try expect(p, scanner::TokenKind::Loop, "expected `loop`");
1296	1312		let body = try parseBlock(p);
1297	1313
1298	1314		return node(p, ast::NodeValue::Loop { body });
1299	1315		}
1300	1316
1301	1317		/// Parse a `for` statement.
1302		-	unsafe fn parseFor(p: &mut Parser) -> *ast::Node
	1318	+	unsafe fn parseFor 'pool (p: &mut Parser 'pool) -> *ast::Node
1303	1319		throws (ParseError)
1304	1320		{
1305	1321		try expect(p, scanner::TokenKind::For, "expected `for`");
1306	1322
1307	1323		let binding = try parseIdentOrPlaceholder(p, "expected identifier or `_`");

1323	1339		binding, index, iterable, body, elseBranch,
1324	1340		}));
1325	1341		}
1326	1342
1327	1343		/// Parse a `return` statement.
1328		-	unsafe fn parseReturn(p: &mut Parser) -> *ast::Node
	1344	+	unsafe fn parseReturn 'pool (p: &mut Parser 'pool) -> *ast::Node
1329	1345		throws (ParseError)
1330	1346		{
1331	1347		try expect(p, scanner::TokenKind::Return, "expected `return`");
1332	1348
1333	1349		// Speculatively try to parse a return value expression.

1338	1354		}
1339	1355		return node(p, ast::NodeValue::Return { value });
1340	1356		}
1341	1357
1342	1358		/// Parse a `throw` statement.
1343		-	unsafe fn parseThrow(p: &mut Parser) -> *ast::Node
	1359	+	unsafe fn parseThrow 'pool (p: &mut Parser 'pool) -> *ast::Node
1344	1360		throws (ParseError)
1345	1361		{
1346	1362		try expect(p, scanner::TokenKind::Throw, "expected `throw`");
1347	1363		let expr = try parseExpr(p);
1348	1364
1349	1365		return node(p, ast::NodeValue::Throw { expr });
1350	1366		}
1351	1367
1352	1368		/// Parse a `panic` statement.
1353		-	unsafe fn parsePanic(p: &mut Parser) -> *ast::Node
	1369	+	unsafe fn parsePanic 'pool (p: &mut Parser 'pool) -> *ast::Node
1354	1370		throws (ParseError)
1355	1371		{
1356	1372		try expect(p, scanner::TokenKind::Panic, "expected `panic`");
1357	1373
1358	1374		// `panic { expr }`.

1374	1390		///
1375	1391		/// Forms:
1376	1392		/// `assert <expr>`
1377	1393		/// `assert <expr>, "message"`
1378	1394		/// `assert { <expr> }, "message"`
1379		-	unsafe fn parseAssert(p: &mut Parser) -> *ast::Node
	1395	+	unsafe fn parseAssert 'pool (p: &mut Parser 'pool) -> *ast::Node
1380	1396		throws (ParseError)
1381	1397		{
1382	1398		try expect(p, scanner::TokenKind::Assert, "expected `assert`");
1383	1399
1384	1400		// `assert { expr }` block form or `assert <expr>`.

1395	1411		}
1396	1412		return node(p, ast::NodeValue::Assert { condition, message });
1397	1413		}
1398	1414
1399	1415		/// Parse a `try` expression with optional `catch` clause(s).
1400		-	unsafe fn parseTryExpr(p: &mut Parser) -> *ast::Node
	1416	+	unsafe fn parseTryExpr 'pool (p: &mut Parser 'pool) -> *ast::Node
1401	1417		throws (ParseError)
1402	1418		{
1403	1419		try expect(p, scanner::TokenKind::Try, "expected `try`");
1404	1420
1405	1421		let shouldPanic = consume(p, scanner::TokenKind::Bang);