radiance · commit

compiler/radiance.rad +19 -19

    let case ast::NodeValue::Block(block) = modAst.value else {
        return;
    };
    let modPath = module::moduleQualifiedPath(entry);

    for i in 0..block.statements.len {
        let stmt = block.statements.list[i];
    for stmt in block.statements {
        if let case ast::NodeValue::FnDecl(decl) = stmt.value {
            if let fnName = getTestFnName(&decl) {
                if *testCount < tests.len {
                    tests[*testCount] = TestDesc { modPath, fnName };
                    *testCount += 1;

        funcPath[j - 1] = desc.modPath[j];
    }
    funcPath[desc.modPath.len - 1] = desc.fnName;
    let funcArg = synthScopeAccess(arena, &funcPath[..desc.modPath.len]);

    let mut args = ast::nodeList(arena, 3);
    ast::nodeListPush(&mut args, modArg);
    ast::nodeListPush(&mut args, nameArg);
    ast::nodeListPush(&mut args, funcArg);
    let a = ast::nodeAllocator(arena);
    let mut args = ast::nodeSlice(arena, 3);
    args.append(modArg, a);
    args.append(nameArg, a);
    args.append(funcArg, a);

    return ast::synthNode(arena, ast::NodeValue::Call(ast::Call { callee, args }));
}

/// Inject a test runner into the entry package's root module.

}

/// Synthesize the test entry point.
fn synthTestMainFn(arena: *mut ast::NodeArena, tests: *[TestDesc]) -> *ast::Node {
    // Build array literal: `[testing::test(...), ...]`.
    let mut elements = ast::nodeList(arena, tests.len);
    let a = ast::nodeAllocator(arena);
    let mut elements = ast::nodeSlice(arena, tests.len as u32);
    for i in 0..tests.len {
        ast::nodeListPush(&mut elements, synthTestCall(arena, &tests[i]));
        elements.append(synthTestCall(arena, &tests[i]), a);
    }
    let arrayLit = ast::synthNode(arena, ast::NodeValue::ArrayLit(elements));

    // Build: `&[...]`.
    let testsRef = ast::synthNode(arena, ast::NodeValue::AddressOf(ast::AddressOf {
        target: arrayLit, mutable: false,
    }));

    // Build: `testing::runAllTests(&[...])`.
    let runFn = synthScopeAccess(arena, &["testing", "runAllTests"]);
    let mut callArgs = ast::nodeList(arena, 1);
    ast::nodeListPush(&mut callArgs, testsRef);
    let mut callArgs = ast::nodeSlice(arena, 1);
    callArgs.append(testsRef, a);
    let callExpr = ast::synthNode(arena, ast::NodeValue::Call(ast::Call {
        callee: runFn, args: callArgs,
    }));

    // Build: `return testing::runAllTests(&[...]);`
    let retStmt = ast::synthNode(arena, ast::NodeValue::Return { value: callExpr });
    let mut bodyStmts = ast::nodeList(arena, 1);
    ast::nodeListPush(&mut bodyStmts, retStmt);
    let mut bodyStmts = ast::nodeSlice(arena, 1);
    bodyStmts.append(retStmt, a);
    let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block { statements: bodyStmts }));

    // Build: `fn #testMain() -> i32`
    let fnName = ast::synthNode(arena, ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, "#testMain")));
    let returnType = ast::synthNode(arena, ast::NodeValue::TypeSig(ast::TypeSig::Integer {
        width: 4, sign: ast::Signedness::Signed,
    }));
    let fnSig = ast::FnSig {
        params: ast::nodeList(arena, 0),
        params: ast::nodeSlice(arena, 0),
        returnType,
        throwList: ast::nodeList(arena, 0),
        throwList: ast::nodeSlice(arena, 0),
    };

    // `@default` attribute.
    let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));
    let mut attrList = ast::nodeList(arena, 1);
    ast::nodeListPush(&mut attrList, attrNode);
    let mut attrList = ast::nodeSlice(arena, 1);
    attrList.append(attrNode, a);
    let fnAttrs = ast::Attributes { list: attrList };

    return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
        name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
    }));

) {
    let case ast::NodeValue::Block(block) = blockNode.value else {
        panic "injectIntoBlock: expected Block node";
    };
    let mut stmts = block.statements;
    ast::nodeListGrow(&mut stmts, arena, 1);
    ast::nodeListPush(&mut stmts, decl);
    stmts.append(decl, ast::nodeAllocator(arena));

    blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });
}

/// Write code buffer to file as raw bytes.

        throw Error::Other;
    };
    if not resolver::success(&diags) {
        resolver::printer::printDiagnostics(&diags, &res);
        io::print("radiance: failed: ");
        io::printU32(diags.errors.listLen);
        io::printU32(diags.errors.len);
        io::printLn(" errors");
        throw Error::Other;
    }
    return res;
}

lib/std/arch/rv64/isel.rad +4 -6

    return getReg(s, ssa);
}

/// Look up symbol address in data map.
fn lookupDataSym(s: *Selector, name: *[u8]) -> u32 throws (SelectorError) {
    for i in 0..s.dataSyms.len {
        let sym = s.dataSyms[i];

    for sym in s.dataSyms {
        if mem::eq(sym.name, name) {
            return sym.addr;
        }
    }
    throw SelectorError::Internal;

/// Returns the total size needed for all static reserves, respecting alignment.
fn computeReserveSize(func: *il::Fn) -> i32 {
    let mut offset: i32 = 0;
    for b in 0..func.blocks.len {
        let block = &func.blocks[b];
        for i in 0..block.instrs.len {
            match block.instrs.list[i] {
        for instr in block.instrs {
            match instr {
                case il::Instr::Reserve { size, alignment, .. } => {
                    if let case il::Val::Imm(sz) = size {
                        offset = mem::alignUpI32(offset, alignment as i32);
                        offset += (sz as i32);
                    }

        // Record debug location before emitting machine instructions.
        if hasLocs {
            emit::recordSrcLoc(s.e, block.locs[i]);
        }
        s.pendingSpill = nil;
        selectInstr(s, blockIdx, block.instrs.list[i], frame, func);
        selectInstr(s, blockIdx, block.instrs[i], frame, func);

        // Flush the pending spill store, if any.
        if let p = s.pendingSpill {
            if let slot = regalloc::spill::spillSlot(&s.ralloc.spill, p.ssa) {
                emit::emitSd(s.e, p.rd, super::FP, spillOffset(s, slot));

lib/std/lang/alloc.rad +0 -20

    let ptr = try alloc(arena, size * count, alignment);

    return @sliceOf(ptr, count);
}

/// Grow a slice to accommodate more elements.
///
/// Allocates new storage with double the current capacity, copies existing
/// elements, and returns the new slice. Old storage remains allocated.
pub fn growSlice(arena: *mut Arena, old: *mut [opaque], len: u32, size: u32, alignment: u32) -> *mut [opaque] throws (AllocError) {
    let mut newCap = old.len * 2;
    if newCap == 0 {
        newCap = 1;
    }
    let new = try allocSlice(arena, size, alignment, newCap);

    // Copy existing elements (byte-wise).
    let oldBytes = @sliceOf(old.ptr as *u8, len * size);
    let newBytes = @sliceOf(new.ptr as *mut u8, len * size);
    for i in 0..len * size {
        newBytes[i] = oldBytes[i];
    }
    return new;
}

/// Generic allocator interface.
///
/// Bundles an allocation function with an opaque context pointer so that
/// any allocation strategy (arena, free-list, mmap, pool) can be used
/// through a uniform interface. The `func` field is called with the context

lib/std/lang/ast.rad +34 -83

    arena: alloc::Arena,
    /// Next node ID to assign. Incremented on each node allocation.
    nextId: u32,
}

/// List of node pointers that tracks its length.
pub record NodeList {
    /// Slice of node pointers.
    list: *mut [*Node],
    /// Number of elements currently in the list.
    len: u32,
}

/// Initialize a node arena backed by the given byte slice.
pub fn nodeArena(data: *mut [u8]) -> NodeArena {
    return NodeArena {
        arena: alloc::new(data),
        nextId: 0,
    };
}

/// Create a new node list in the arena with the specified capacity.
pub fn nodeList(arena: *mut NodeArena, capacity: u32) -> NodeList {
/// Create an empty `*mut [*Node]` slice with the given capacity.
pub fn nodeSlice(arena: *mut NodeArena, capacity: u32) -> *mut [*Node] {
    if capacity == 0 {
        // Return an empty list without allocating.
        return NodeList { list: undefined, len: 0 };
        return &mut [];
    }
    let ptr = try! alloc::allocSlice(&mut arena.arena, @sizeOf(*Node), @alignOf(*Node), capacity);
    let list = ptr as *mut [*Node];

    return NodeList { list, len: 0 };
    return @sliceOf(ptr.ptr as *mut *Node, 0, capacity);
}

/// Push a node to the end of the list.
pub fn nodeListPush(self: *mut NodeList, node: *Node) -> u32 {
    if self.len >= self.list.len {
        panic "nodeListPush: out of space";
    }
    self.list[self.len] = node;
    self.len += 1;

    return self.len;
}

/// Grow a node list's backing storage by `extra` slots.
///
/// Allocates a new backing array of size `self.len + extra`, copies existing
/// node pointers, and updates `self.list`. Existing node data is not copied.
pub fn nodeListGrow(self: *mut NodeList, arena: *mut NodeArena, extra: u32) {
    if self.list.len - self.len >= extra {
        return;
    }
    let newCap = self.len + extra;
    let ptr = try! alloc::allocSlice(&mut arena.arena, @sizeOf(*Node), @alignOf(*Node), newCap);
    let newList = ptr as *mut [*Node];

    for i in 0..self.len {
        newList[i] = self.list[i];
    }
    self.list = newList;
/// Return an allocator backed by the node arena.
// TODO: Why do we need this?
pub fn nodeAllocator(arena: *mut NodeArena) -> alloc::Allocator {
    return alloc::arenaAllocator(&mut arena.arena);
}

/// Attribute bit set applied to declarations or fields.
pub union Attribute {
    /// Public visibility attribute.

    Intrinsic = 0b10000,
}

/// Ordered collection of attribute nodes applied to a declaration.
pub record Attributes {
    list: NodeList,
}

/// Append an attribute node to the list.
pub fn attributesPush(self: *mut Attributes, attr: *Node) -> u32 {
    return nodeListPush(&mut self.list, attr);
}

/// Return the number of attributes stored in the list.
pub fn attributesLen(self: *Attributes) -> u32 {
    return self.list.len;
}

/// Fetch the attribute node at the specified index.
pub fn attributesGet(self: *Attributes, index: u32) -> *Node {
    assert index < self.list.len, "attributesGet: invalid index";
    return self.list.list[index];
    list: *mut [*Node],
}

/// Check if an attributes list contains an attribute.
pub fn attributesContains(self: *Attributes, attr: Attribute) -> bool {
    for i in 0..self.list.len {
        let node = attributesGet(self, i);
    for node in self.list {
        if let case NodeValue::Attribute(a) = node.value; a == attr {
            return true;
        }
    }
    return false;

    /// Nominal type, points to identifier node.
    Nominal(*Node),
    /// Inline record type for union variant payloads.
    Record {
        /// Field declaration nodes.
        fields: NodeList,
        fields: *mut [*Node],
        /// Whether this record has labeled fields.
        labeled: bool,
    },
    /// Anonymous function type.
    Fn(FnSig),

}

/// Function signature.
pub record FnSig {
    /// Parameter type nodes in declaration order.
    params: NodeList,
    params: *mut [*Node],
    /// Optional return type node.
    returnType: ?*Node,
    /// Throwable type nodes declared in the signature.
    throwList: NodeList,
    throwList: *mut [*Node],
}

/// Address-of expression metadata.
pub record AddressOf {
    /// Target expression being referenced.

}

/// Compound statement block with optional dedicated scope.
pub record Block {
    /// Statements that belong to this block.
    statements: NodeList,
    statements: *mut [*Node],
}

/// Function call expression.
pub record Call {
    /// Callee expression.
    callee: *Node,
    /// Argument expressions in source order.
    args: NodeList,
    args: *mut [*Node],
}

/// Single argument to a function or record literal, optionally labeled.
pub record Arg {
    /// Optional label applied to the argument.

/// Try expression metadata.
pub record Try {
    /// Expression evaluated with implicit error propagation.
    expr: *Node,
    /// Catch clauses. Empty for propagation (`try`), `try!`, or `try?`.
    catches: NodeList,
    catches: *mut [*Node],
    /// Whether the try should panic instead of returning an error.
    shouldPanic: bool,
    /// Whether the try should return an optional instead of propagating error.
    returnsOptional: bool,
}

}

/// Prong arm.
pub union ProngArm {
    /// Case arm with pattern list.
    Case(NodeList),
    Case(*mut [*Node]),
    /// Binding arm with single identifier or placeholder.
    Binding(*Node),
    /// Else arm.
    Else,
}

/// `match` statement metadata.
pub record Match {
    /// Expression whose value controls the match.
    subject: *Node,
    /// Prong nodes evaluated in order.
    prongs: NodeList,
    prongs: *mut [*Node],
}

/// `match` prong metadata.
pub record MatchProng {
    /// Prong arm.

pub record RecordLit {
    /// Type name associated with the literal.
    /// If `nil`, it's an anonymous record literal.
    typeName: ?*Node,
    /// Field initializer nodes.
    fields: NodeList,
    fields: *mut [*Node],
    /// When true, remaining fields are discarded (`{ x, .. }`).
    ignoreRest: bool,
}

/// Record declaration.
pub record RecordDecl {
    /// Identifier naming the record.
    name: *Node,
    /// Field declaration nodes.
    fields: NodeList,
    fields: *mut [*Node],
    /// Optional attribute list applied to the record.
    attrs: ?Attributes,
    /// Trait derivations attached to the record.
    derives: NodeList,
    derives: *mut [*Node],
    /// Whether this record has labeled fields.
    labeled: bool,
}

/// Union declarations.
pub record UnionDecl {
    /// Identifier naming the union.
    name: *Node,
    /// Variant nodes making up the union.
    variants: NodeList,
    variants: *mut [*Node],
    /// Optional attribute list applied to the union.
    attrs: ?Attributes,
    /// Trait derivations attached to the union.
    derives: NodeList,
    derives: *mut [*Node],
}

/// Union variant declaration.
pub record UnionDeclVariant {
    /// Identifier naming the variant.

    /// Numeric literal such as `42` or `0xFF`.
    Number(IntLiteral),
    /// Range expression such as `0..10` or `..`.
    Range(Range),
    /// Array literal expression.
    ArrayLit(NodeList),
    ArrayLit(*mut [*Node]),
    /// Array repeat literal expression.
    ArrayRepeatLit(ArrayRepeatLit),
    /// Array subscript expression.
    Subscript {
        /// Array or slice.

    /// Builtin function call (e.g. `@sizeOf(T)`).
    BuiltinCall {
        /// Builtin function kind.
        kind: Builtin,
        /// Argument list.
        args: NodeList,
        args: *mut [*Node],
    },
    /// Block expression or statement body.
    Block(Block),
    /// Call expression, eg. `f(x)`.
    Call(Call),

    /// Trait declaration.
    TraitDecl {
        /// Trait name identifier.
        name: *Node,
        /// Supertrait name nodes.
        supertraits: NodeList,
        supertraits: *mut [*Node],
        /// Method signature nodes ([`TraitMethodSig`]).
        methods: NodeList,
        methods: *mut [*Node],
        /// Optional attributes.
        attrs: ?Attributes,
    },
    /// Method signature inside a trait declaration.
    TraitMethodSig {

        /// Trait name identifier.
        traitName: *Node,
        /// Target type identifier.
        targetType: *Node,
        /// Method definition nodes ([`InstanceMethodDecl`]).
        methods: NodeList,
        methods: *mut [*Node],
    },
    /// Method definition inside an instance block.
    InstanceMethodDecl {
        /// Method name identifier.
        name: *Node,

    fnBody: *Node
}

/// Synthesize a module with a function in it with the given name and statements.
pub fn synthFnModule(
    arena: *mut NodeArena, name: *[u8], bodyStmts: NodeList
    arena: *mut NodeArena, name: *[u8], bodyStmts: *mut [*Node]
) -> SynthFnMod {
    let a = nodeAllocator(arena);
    let fnName = synthNode(arena, NodeValue::Ident(name));
    let params = nodeList(arena, 0);
    let throwList = nodeList(arena, 0);
    let params: *mut [*Node] = &mut [];
    let throwList: *mut [*Node] = &mut [];
    let fnSig = FnSig { params, returnType: nil, throwList };
    let fnBody = synthNode(arena, NodeValue::Block(Block { statements: bodyStmts }));
    let fnDecl = synthNode(arena, NodeValue::FnDecl(FnDecl {
        name: fnName, sig: fnSig, body: fnBody, attrs: nil,
    }));
    let mut rootStmts = nodeList(arena, 1);
    nodeListPush(&mut rootStmts, fnDecl);
    let mut rootStmts: *mut [*Node] = &mut [];
    rootStmts.append(fnDecl, a);
    let modBody = synthNode(arena, NodeValue::Block(Block { statements: rootStmts }));

    return SynthFnMod { modBody, fnBody };
}

lib/std/lang/ast/printer.rad +34 -34

                else sexpr::list(a, "ptr", &[toExpr(a, valueType)]),
        case super::TypeSig::Optional { valueType } =>
            return sexpr::list(a, "?", &[toExpr(a, valueType)]),
        case super::TypeSig::Nominal(name) => return toExpr(a, name),
        case super::TypeSig::Record { fields, .. } =>
            return sexpr::list(a, "record", nodeListToExprs(a, &fields)),
            return sexpr::list(a, "record", nodeListToExprs(a, &fields[..])),
        case super::TypeSig::Fn(sig) => {
            let mut ret = sexpr::sym("void");
            if let rt = sig.returnType {
                ret = toExpr(a, rt);
            }
            return sexpr::list(a, "fn", &[sexpr::list(a, "params", nodeListToExprs(a, &sig.params)), ret]);
            return sexpr::list(a, "fn", &[sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..])), ret]);
        }
        case super::TypeSig::TraitObject { traitName, mutable } =>
            return sexpr::list(a, "obj", &[sexpr::sym("mut"), toExpr(a, traitName)]) if mutable
                else sexpr::list(a, "obj", &[toExpr(a, traitName)]),
    }
}

/// Convert a node list to a slice of expressions.
fn nodeListToExprs(a: *mut alloc::Arena, nodes: *super::NodeList) -> *[sexpr::Expr] {
/// Convert a node slice to a slice of expressions.
fn nodeListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len);
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for i in 0..nodes.len {
        buf[i] = toExpr(a, nodes.list[i]);
        buf[i] = toExpr(a, nodes[i]);
    }
    return buf;
}

/// Convert an optional node to an expression, or return placeholder.

    }
    return sexpr::Expr::Null;
}

/// Convert a list of match prongs to expressions.
fn prongListToExprs(a: *mut alloc::Arena, nodes: *super::NodeList) -> *[sexpr::Expr] {
fn prongListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len);
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for i in 0..nodes.len {
        let prong = nodes.list[i];
        let prong = nodes[i];
        match prong.value {
            case super::NodeValue::MatchProng(p) => {
                buf[i] = prongToExpr(a, p);
            }
            else => {

/// Convert a match prong to an S-expression.
fn prongToExpr(a: *mut alloc::Arena, p: super::MatchProng) -> sexpr::Expr {
    match p.arm {
        case super::ProngArm::Case(patterns) => {
            return sexpr::block(a, "case", &[
                sexpr::list(a, "patterns", nodeListToExprs(a, &patterns)),
                sexpr::list(a, "patterns", nodeListToExprs(a, &patterns[..])),
                guardExpr(a, p.guard)
            ], &[toExpr(a, p.body)]);
        }
        case super::ProngArm::Else => {
            return sexpr::block(a, "else", &[guardExpr(a, p.guard)], &[toExpr(a, p.body)]);

) -> sexpr::Expr {
    return sexpr::list(a, ":", &[toExprOpt(a, field), toExpr(a, type), toExprOrNull(a, value)]);
}

/// Convert a list of record fields to expressions.
fn fieldListToExprs(a: *mut alloc::Arena, nodes: *super::NodeList) -> *[sexpr::Expr] {
fn fieldListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len);
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for i in 0..nodes.len {
        let node = nodes.list[i];
        let node = nodes[i];
        match node.value {
            case super::NodeValue::RecordField { field, type, value } => {
                buf[i] = fieldToExpr(a, field, type, value);
            }
            else => {

fn variantToExpr(a: *mut alloc::Arena, name: *super::Node, type: ?*super::Node) -> sexpr::Expr {
    return sexpr::list(a, "variant", &[toExpr(a, name), toExprOrNull(a, type)]);
}

/// Convert a list of union variants to expressions.
fn variantListToExprs(a: *mut alloc::Arena, nodes: *super::NodeList) -> *[sexpr::Expr] {
fn variantListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len);
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for i in 0..nodes.len {
        let node = nodes.list[i];
        let node = nodes[i];
        match node.value {
            case super::NodeValue::UnionDeclVariant(v) => {
                buf[i] = variantToExpr(a, v.name, v.type);
            }
            else => {

        case super::NodeValue::BinOp(b) =>
            return sexpr::list(a, binOpName(b.op), &[toExpr(a, b.left), toExpr(a, b.right)]),
        case super::NodeValue::UnOp(u) =>
            return sexpr::list(a, unOpName(u.op), &[toExpr(a, u.value)]),
        case super::NodeValue::Call(c) => {
            let buf = try! sexpr::allocExprs(a, c.args.len + 1);
            let buf = try! sexpr::allocExprs(a, c.args.len as u32 + 1);
            buf[0] = toExpr(a, c.callee);
            for i in 0..c.args.len { buf[i + 1] = toExpr(a, c.args.list[i]); }
            for i in 0..c.args.len { buf[i + 1] = toExpr(a, c.args[i]); }
            return sexpr::Expr::List { head: "call", tail: buf, multiline: false };
        }
        case super::NodeValue::BuiltinCall { kind, args } =>
            return sexpr::list(a, builtinName(kind), nodeListToExprs(a, &args)),
            return sexpr::list(a, builtinName(kind), nodeListToExprs(a, &args[..])),
        case super::NodeValue::Subscript { container, index } =>
            return sexpr::list(a, "[]", &[toExpr(a, container), toExpr(a, index)]),
        case super::NodeValue::FieldAccess(acc) =>
            return sexpr::list(a, ".", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),
        case super::NodeValue::ScopeAccess(acc) =>

        case super::NodeValue::Deref(target) =>
            return sexpr::list(a, "deref", &[toExpr(a, target)]),
        case super::NodeValue::As(cast) =>
            return sexpr::list(a, "as", &[toExpr(a, cast.value), toExpr(a, cast.type)]),
        case super::NodeValue::ArrayLit(elems) =>
            return sexpr::list(a, "array", nodeListToExprs(a, &elems)),
            return sexpr::list(a, "array", nodeListToExprs(a, &elems[..])),
        case super::NodeValue::ArrayRepeatLit(rep) =>
            return sexpr::list(a, "array-repeat", &[toExpr(a, rep.item), toExpr(a, rep.count)]),
        case super::NodeValue::RecordLit(lit) => {
            let mut total: u32 = lit.fields.len;
            let mut total: u32 = lit.fields.len as u32;
            if let _ = lit.typeName {
                total += 1;
            }
            let buf = try! sexpr::allocExprs(a, total);
            let mut idx: u32 = 0;
            if let tn = lit.typeName {
                buf[idx] = toExpr(a, tn); idx = idx + 1;
            }
            for i in 0..lit.fields.len {
                buf[idx + i] = toExpr(a, lit.fields.list[i]);
                buf[idx + i] = toExpr(a, lit.fields[i]);
            }
            return sexpr::Expr::List { head: "record-lit", tail: buf, multiline: lit.fields.len > 2 };
        }
        case super::NodeValue::RecordLitField(f) =>
            return sexpr::list(a, "field", &[toExprOpt(a, f.label), toExpr(a, f.value)]),

        }
        case super::NodeValue::Try(t) => {
            let mut head = "try";
            if t.shouldPanic { head = "try!"; }
            if t.catches.len > 0 {
                let catches = nodeListToExprs(a, &t.catches);
                let catches = nodeListToExprs(a, &t.catches[..]);
                return sexpr::list(a, head, &[toExpr(a, t.expr), sexpr::block(a, "catches", &[], catches)]);
            }
            return sexpr::list(a, head, &[toExpr(a, t.expr)]);
        }
        case super::NodeValue::CatchClause(clause) => {

            children[len] = toExpr(a, clause.body);
            len += 1;
            return sexpr::list(a, head, &children[..len]);
        }
        case super::NodeValue::Block(blk) => {
            let children = nodeListToExprs(a, &blk.statements);
            let children = nodeListToExprs(a, &blk.statements[..]);
            return sexpr::block(a, "block", &[], children);
        }
        case super::NodeValue::Let(decl) => {
            let mut head = "let";
            if decl.mutable { head = "let-mut"; }

                toExpr(a, f.iterable)
            ], &[toExpr(a, f.body), toExprOrNull(a, f.elseBranch)]),
        case super::NodeValue::Loop { body } =>
            return sexpr::block(a, "loop", &[], &[toExpr(a, body)]),
        case super::NodeValue::Match(m) => {
            let children = prongListToExprs(a, &m.prongs);
            let children = prongListToExprs(a, &m.prongs[..]);
            return sexpr::block(a, "match", &[toExpr(a, m.subject)], children);
        }
        case super::NodeValue::MatchProng(p) => {
            return prongToExpr(a, p);
        }
        case super::NodeValue::FnDecl(f) => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &f.sig.params));
            let params = sexpr::list(a, "params", nodeListToExprs(a, &f.sig.params[..]));
            let ret = toExprOrNull(a, f.sig.returnType);
            if let body = f.body {
                return sexpr::block(a, "fn", &[toExpr(a, f.name), params, ret], &[toExpr(a, body)]);
            }
            return sexpr::list(a, "fn", &[toExpr(a, f.name), params, ret]);
        }
        case super::NodeValue::Mod(m) => return sexpr::list(a, "mod", &[toExpr(a, m.name)]),
        case super::NodeValue::Use(u_) => return sexpr::list(a, "use", &[toExpr(a, u_.path)]),
        case super::NodeValue::RecordDecl(r) => {
            let children = fieldListToExprs(a, &r.fields);
            let children = fieldListToExprs(a, &r.fields[..]);
            return sexpr::block(a, "record", &[toExpr(a, r.name)], children);
        }
        case super::NodeValue::RecordField { field, type, value } => {
            return fieldToExpr(a, field, type, value);
        }
        case super::NodeValue::UnionDecl(u_) => {
            let children = variantListToExprs(a, &u_.variants);
            let children = variantListToExprs(a, &u_.variants[..]);
            return sexpr::block(a, "union", &[toExpr(a, u_.name)], children);
        }
        case super::NodeValue::UnionDeclVariant(v) => {
            return variantToExpr(a, v.name, v.type);
        }
        case super::NodeValue::ExprStmt(e) => return toExpr(a, e),
        case super::NodeValue::TraitDecl { name, supertraits, methods, .. } => {
            let children = nodeListToExprs(a, &methods);
            let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, &supertraits));
            let children = nodeListToExprs(a, &methods[..]);
            let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, &supertraits[..]));
            return sexpr::block(a, "trait", &[toExpr(a, name), supers], children);
        }
        case super::NodeValue::TraitMethodSig { name, receiver, sig } => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params));
            let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
            let ret = toExprOrNull(a, sig.returnType);
            return sexpr::list(a, "methodSig", &[toExpr(a, receiver), toExpr(a, name), params, ret]);
        }
        case super::NodeValue::InstanceDecl { traitName, targetType, methods } => {
            let children = nodeListToExprs(a, &methods);
            let children = nodeListToExprs(a, &methods[..]);
            return sexpr::block(a, "instance", &[toExpr(a, traitName), toExpr(a, targetType)], children);
        }
        case super::NodeValue::InstanceMethodDecl { name, receiverName, receiverType, sig, body } => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params));
            let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
            let ret = toExprOrNull(a, sig.returnType);
            return sexpr::block(a, "method", &[toExpr(a, receiverType), toExpr(a, receiverName), toExpr(a, name), params, ret], &[toExpr(a, body)]);
        }
        else => return sexpr::sym("?"),
    }

/// Dump the tree rooted at `root`, using the provided arena for allocation.
pub fn printTree(root: *super::Node, arena: *mut alloc::Arena) {
    match root.value {
        case super::NodeValue::Block(blk) => {
            for i in 0..blk.statements.len {
                sexpr::print(toExpr(arena, blk.statements.list[i]), 0);
                sexpr::print(toExpr(arena, blk.statements[i]), 0);
                if i < blk.statements.len - 1 { io::print("\n\n"); }
            }
            io::print("\n");
        }
        else => {

lib/std/lang/gen/regalloc/assign.rad +1 -1

            }
        }

        // Process each instruction.
        for i in 0..block.instrs.len {
            let instr = block.instrs.list[i];
            let instr = block.instrs[i];
            let mut ctx = InstrCtx {
                current: &mut current,
                usedRegs: &mut usedRegs,
                func,
                live,

lib/std/lang/gen/regalloc/liveness.rad +6 -6

        let block = &func.blocks[b];
        for p in block.params {
            maxReg = maxRegNum(p.value.n, maxReg);
        }
        for i in 0..block.instrs.len {
            il::forEachReg(block.instrs.list[i], maxRegCallback, &mut maxReg as *mut opaque);
            if let dst = il::instrDst(block.instrs.list[i]) {
            il::forEachReg(block.instrs[i], maxRegCallback, &mut maxReg as *mut opaque);
            if let dst = il::instrDst(block.instrs[i]) {
                maxReg = maxRegNum(dst.n, maxReg);
            }
        }
    }
    if maxReg > MAX_SSA_REGS {

fn computeLocalDefsUses(block: *il::Block, defs: *mut bitset::Bitset, uses: *mut bitset::Bitset) {
    for p in block.params {
        bitset::set(defs, p.value.n);
    }
    for i in 0..block.instrs.len {
        let instr = block.instrs.list[i];
        let instr = block.instrs[i];
        let mut ctx = DefsUses { defs, uses };
        il::forEachReg(instr, addUseCallback, &mut ctx as *mut opaque);

        if let dst = il::instrDst(instr) {
            bitset::set(defs, dst.n);

/// Add successor "live in" sets to the scratch bitset.
fn addSuccessorLiveIn(func: *il::Fn, block: *il::Block, liveIn: *[bitset::Bitset], scratch: *mut bitset::Bitset) {
    if block.instrs.len == 0 {
        return;
    }
    let term = block.instrs.list[block.instrs.len - 1];
    let term = block.instrs[block.instrs.len - 1];

    match term {
        case il::Instr::Jmp { target, .. } =>
            unionBlockLiveIn(target, liveIn, scratch),
        case il::Instr::Br { thenTarget, elseTarget, .. } => {

}

/// Check if this is the last use of a register at this instruction.
pub fn isLastUse(info: *LiveInfo, func: *il::Fn, blockIdx: u32, instrIdx: u32, reg: il::Reg) -> bool {
    let block = &func.blocks[blockIdx];
    let instr = block.instrs.list[instrIdx];
    let instr = block.instrs[instrIdx];

    if not instrUsesReg(instr, reg) {
        return false;
    }
    if bitset::contains(&info.liveOut[blockIdx], reg.n) {
        return false;
    }
    for i in (instrIdx + 1)..block.instrs.len {
        if instrUsesReg(block.instrs.list[i], reg) {
        if instrUsesReg(block.instrs[i], reg) {
            return false;
        }
    }
    return true;
}

lib/std/lang/gen/regalloc/spill.rad +2 -2


        // Walk instructions backwards.
        let mut i = block.instrs.len;
        while i > 0 {
            i -= 1;
            let instr = block.instrs.list[i];
            let instr = block.instrs[i];

            // Limit register pressure before processing this instruction.
            limitPressure(&mut scratch, &mut spilled, costs, numRegs);

            // Enforce cross-call pressure at call sites.

                costs[p.value.n].defs = costs[p.value.n].defs + weight;
            }
        }
        // Count instruction defs and uses.
        for i in 0..block.instrs.len {
            let instr = block.instrs.list[i];
            let instr = block.instrs[i];

            // Count definition.
            if let dst = il::instrDst(instr) {
                if dst.n < costs.len {
                    costs[dst.n].defs = costs[dst.n].defs + weight;

lib/std/lang/il.rad +1 -31

    /// Block label.
    label: *[u8],
    /// Block parameters.
    params: *[Param],
    /// Instructions in the block. The last instruction must be a terminator.
    instrs: InstrList,
    instrs: *mut [Instr],
    /// Source locations for debugging and error reporting.
    /// One entry per instruction when debug info is enabled, empty otherwise.
    locs: *[SrcLoc],
    /// Predecessor block indices. Used for control flow analysis.
    preds: *[u32],

    fns: *[*Fn],
    /// Index of entry point function, if any.
    defaultFnIdx: ?u32,
}

///////////////////////
// Instruction Lists //
///////////////////////

/// A growable list of instructions backed by arena storage.
pub record InstrList {
    /// Pre-allocated instruction storage.
    list: *mut [Instr],
    /// Current number of instructions.
    len: u32,
}

/// Create a new instruction list with the given capacity.
pub fn instrList(arena: *mut alloc::Arena, capacity: u32) -> InstrList throws (alloc::AllocError) {
    if capacity == 0 {
        return InstrList { list: undefined, len: 0 };
    }
    let instrs = try alloc::allocSlice(arena, @sizeOf(Instr), @alignOf(Instr), capacity);
    return InstrList { list: instrs as *mut [Instr], len: 0 };
}

/// Push an instruction onto the list. Panics if at capacity.
pub fn instrListPush(self: *mut InstrList, instr: Instr) {
    if self.len >= self.list.len {
        panic "instrListPush: out of space";
    }
    self.list[self.len] = instr;
    self.len += 1;
}

///////////////////////
// Utility Functions //
///////////////////////

/// Get the destination register of an instruction, if any.

lib/std/lang/il/printer.rad +7 -9

    sexpr::printStringTo(out, s);
}

/// Check if name contains the path separator.
fn needsQuoting(name: *[u8]) -> bool {
    for i in 0..name.len {
        if name[i] == ':' {
    for ch in name {
        if ch == ':' {
            return true;
        }
    }
    return false;
}

            }
        }
        case super::Instr::Switch { val, defaultTarget, defaultArgs, cases } => {
            write(out, "switch ");
            writeVal(out, a, val);
            for i in 0..cases.len {
                let c = cases[i];
            for c in cases {
                write(out, " (");
                write(out, formatI64(a, c.value));
                write(out, " @");
                write(out, blocks[c.target].label);
                if c.args.len > 0 {

        write(out, ")");
    }
    write(out, "\n");

    // Instructions.
    let instrs = &block.instrs.list[0..block.instrs.len];
    for i in 0..instrs.len {
    for instr in block.instrs {
        indent(out, 1);
        writeInstr(out, a, blocks, instrs[i]);
        writeInstr(out, a, blocks, instr);
        write(out, ";\n");
    }
}

///////////////////////

    writeSymbol(out, d.name);
    write(out, " align ");
    write(out, formatU32(a, d.alignment));
    write(out, " {\n");

    for i in 0..d.values.len {
    for v in d.values {
        indent(out, 1);
        writeDataValue(out, a, d.values[i]);
        writeDataValue(out, a, v);
        write(out, ";\n");
    }
    write(out, "}\n");
}


lib/std/lang/lower.rad +214 -433


///////////////
// Constants //
///////////////

/// Initial capacity for instructions per block.
const INITIAL_BLOCK_INSTRS: u32 = 8;
/// Initial capacity for blocks per function.
const INITIAL_BLOCKS: u32 = 8;
/// Initial capacity for predecessor lists.
const INITIAL_PREDS: u32 = 4;
/// Initial capacity for global data.
const INITIAL_DATA: u32 = 8;
/// Initial capacity for functions.
const INITIAL_FNS: u32 = 16;
/// Initial capacity for the error tag table.
const INITIAL_ERR_TAGS: u32 = 8;
/// Maximum nesting depth of loops.
const MAX_LOOP_DEPTH: u32 = 16;
/// Maximum number of function symbols to track.
const MAX_FN_SYMS: u32 = 2048;
/// Maximum number of `catch` clauses per `try`.
const MAX_CATCH_CLAUSES: u32 = 32;

// Slice Layout
//

/// Holds global state like the data section (strings, constants) and provides
/// access to the resolver for type queries.
pub record Lowerer {
    /// Arena for IL allocations. All IL nodes are allocated here.
    arena: *mut alloc::Arena,
    /// Allocator backed by the arena.
    allocator: alloc::Allocator,
    /// Resolver for type information. Used to query types, symbols, and
    /// compile-time constant values during lowering.
    resolver: *resolver::Resolver,
    /// Module graph for cross-module symbol resolution.
    moduleGraph: ?*module::ModuleGraph,

    /// Current module being lowered.
    currentMod: ?u16,
    /// Global data items (string literals, constants, static arrays).
    /// These become the data sections in the final binary.
    data: *mut [il::Data],
    /// Number of data items currently stored.
    dataCount: u32,
    /// Lowered functions.
    fns: *mut [*il::Fn],
    /// Number of functions currently stored.
    fnCount: u32,
    /// Map of function symbols to qualified names.
    fnSyms: *mut [FnSymEntry],
    /// Number of entries in fnSyms.
    fnSymsLen: u32,
    /// Global error type tag table. Maps nominal types to unique tags.
    errTags: *mut [ErrTagEntry],
    /// Number of entries in the error tag table.
    errTagsLen: u32,
    /// Next error tag to assign (starts at 1; 0 = success).
    errTagCounter: u32,
    /// Lowering options.
    options: LowerOptions,
}

}

/// Compute the maximum size of any error type in a throw list.
fn maxErrSize(throwList: *[*resolver::Type]) -> u32 {
    let mut maxSize: u32 = 0;
    for i in 0..throwList.len {
        let size = resolver::getTypeLayout(*throwList[i]).size;
    for ty in throwList {
        let size = resolver::getTypeLayout(*ty).size;
        if size > maxSize {
            maxSize = size;
        }
    }
    return maxSize;
}

/// Get or assign a globally unique error tag for the given error type.
/// Tag `0` is reserved for success; error tags start at `1`.
fn getOrAssignErrorTag(self: *mut Lowerer, errType: resolver::Type) -> u32 {
    for i in 0..self.errTagsLen {
        if self.errTags[i].ty == errType {
            return self.errTags[i].tag;
    for entry in self.errTags {
        if entry.ty == errType {
            return entry.tag;
        }
    }
    let tag = self.errTagCounter;
    self.errTagCounter += 1;

    if self.errTagsLen >= self.errTags.len {
        self.errTags = try! alloc::growSlice(
            self.arena,
            self.errTags as *mut [opaque],
            self.errTagsLen,
            @sizeOf(ErrTagEntry),
            @alignOf(ErrTagEntry)
        ) as *mut [ErrTagEntry];
    }
    self.errTags[self.errTagsLen] = ErrTagEntry { ty: errType, tag };
    self.errTagsLen += 1;
    self.errTagCounter += 1;
    self.errTags.append(ErrTagEntry { ty: errType, tag }, self.allocator);

    return tag;
}

/// Builder for accumulating data values during constant lowering.
record DataValueBuilder {
    arena: *mut alloc::Arena,
    allocator: alloc::Allocator,
    values: *mut [il::DataValue],
    len: u32,
    /// Whether all values pushed are undefined.
    allUndef: bool,
}

/// Result of lowering constant data.
record ConstDataResult {
    values: *[il::DataValue],
    isUndefined: bool,
}

/// Create a new builder with an initial capacity.
fn dataBuilder(arena: *mut alloc::Arena) -> DataValueBuilder {
    let values = try! alloc::allocSlice(
        arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), INITIAL_DATA
    ) as *mut [il::DataValue];

    return DataValueBuilder { arena, values, len: 0, allUndef: true };
/// Create a new builder.
fn dataBuilder(allocator: alloc::Allocator) -> DataValueBuilder {
    return DataValueBuilder { allocator, values: &mut [], allUndef: true };
}

/// Append a data value to the builder, growing the backing array if needed.
/// Append a data value to the builder.
fn dataBuilderPush(b: *mut DataValueBuilder, value: il::DataValue) {
    if b.len >= b.values.len {
        b.values = try! alloc::growSlice(
            b.arena, b.values, b.len,
            @sizeOf(il::DataValue), @alignOf(il::DataValue)
        ) as *mut [il::DataValue];
    }
    b.values[b.len] = value;
    b.len += 1;
    b.values.append(value, b.allocator);

    if value.item != il::DataItem::Undef {
        b.allUndef = false;
    }
}

/// Return the accumulated values.
fn dataBuilderFinish(b: *DataValueBuilder) -> ConstDataResult {
    return ConstDataResult {
        values: &b.values[..b.len],
        values: &b.values[..],
        isUndefined: b.allUndef,
    };
}

///////////////////////////

    var: Var,
    /// SSA register containing the parameter value from the caller.
    reg: il::Reg,
}

/// A growable list of u32 values.
// TODO: I don't love these `u32` lists.
record U32List {
    list: *mut [u32],
    len: u32,
}

////////////////////////////////
// Basic Block Representation //
////////////////////////////////

// During lowering, we build a CFG of basic blocks. Each block accumulates

pub record BlockId {
    /// Index into the function's block array.
    n: u32,
}

/// A growable list of block parameters.
record BlockParams {
    list: *mut [il::Param],
    len: u32,
}

/// Internal block state during construction.
///
/// The key invariants:
///
/// - A block is "open" if it has no terminator; instructions can be added.

record BlockData {
    /// Block label for debugging and IL printing.
    label: *[u8],
    /// Block parameters for merging values at control flow joins. These
    /// receive values from predecessor edges when control flow merges.
    params: BlockParams,
    params: *mut [il::Param],
    /// Variable ids corresponding to each parameter. Used to map block params
    /// back to source variables when building argument lists for jumps.
    paramVars: U32List,
    paramVars: *mut [u32],
    /// Instructions accumulated so far. The last instruction should eventually
    /// be a terminator.
    instrs: il::InstrList,
    /// Debug source locations, one per instruction. Only populated when debug
    /// info is enabled.
    instrs: *mut [il::Instr],
    /// Debug source locations, one per instruction. Only populated when
    /// debug info is enabled.
    locs: *mut [il::SrcLoc],
    /// Number of debug locations stored.
    locsLen: u32,
    /// Predecessor block ids. Used for SSA construction to propagate values
    /// from predecessors when a variable is used before being defined locally.
    preds: U32List,
    preds: *mut [u32],
    /// The current SSA value of each variable in this block. Indexed by variable
    /// id. A `nil` means the variable wasn't assigned in this block. Updated by
    /// [`defVar`], queried by [`useVarInBlock`].
    vars: *mut [?il::Val],
    /// Sealing state. Once sealed, all predecessors are known and we can resolve

/// During this time, variables used before being defined locally are tracked.
/// Once all predecessors are known, the block is sealed and those variables
/// are resolved via [`resolveBlockArgs`].
union Sealed {
    /// Block is unsealed; predecessors may still be added.
    No { incompleteVars: U32List },
    No { incompleteVars: *mut [u32] },
    /// Block is sealed; all predecessors are known.
    Yes,
}

///////////////////////////////////

/// Per-function lowering state. Created fresh for each function and contains
/// all the mutable state needed during function body lowering.
record FnLowerer {
    /// Reference to the module-level lowerer.
    low: *mut Lowerer,
    /// Allocator for IL allocations.
    allocator: alloc::Allocator,
    /// Type signature of the function being lowered.
    fnType: *resolver::FnType,
    /// Function name, used as prefix for generated data symbols.
    fnName: *[u8],



    /// Metadata (name, type, mutability) for each variable. Indexed by variable
    /// id. Doesn't change after declaration. For the SSA value of a variable in
    /// a specific block, see [`BlockData::vars`].
    vars: *mut [VarData],
    /// Number of declared variables.
    varsLen: u32,

    // ~ Function parameters ~ //

    /// Parameter-to-variable bindings, initialized in the entry block.
    params: *mut [FnParamBinding],
    /// Number of function parameters.
    paramsLen: u32,

    // ~ Basic block management ~ //

    /// Block storage array, indexed by block id.
    blockData: *mut [BlockData],
    /// Number of blocks created so far.
    blockCount: u32,
    /// The entry block for this function.
    entryBlock: ?BlockId,
    /// The block currently receiving new instructions.
    currentBlock: ?BlockId,


    res: *resolver::Resolver,
    root: *ast::Node,
    pkgName: *[u8],
    arena: *mut alloc::Arena
) -> il::Program throws (LowerError) {
    let data = try! alloc::allocSlice(arena, @sizeOf(il::Data), @alignOf(il::Data), INITIAL_DATA) as *mut [il::Data];
    let fns = try! alloc::allocSlice(arena, @sizeOf(*il::Fn), @alignOf(*il::Fn), INITIAL_FNS) as *mut [*il::Fn];
    let fnSyms = try! alloc::allocSlice(arena, @sizeOf(FnSymEntry), @alignOf(FnSymEntry), INITIAL_FNS) as *mut [FnSymEntry];
    let errTags = try! alloc::allocSlice(arena, @sizeOf(ErrTagEntry), @alignOf(ErrTagEntry), INITIAL_ERR_TAGS) as *mut [ErrTagEntry];
    let mut low = Lowerer {
        arena: arena,
        allocator: alloc::arenaAllocator(arena),
        resolver: res,
        moduleGraph: nil,
        pkgName,
        currentMod: nil,
        data,
        dataCount: 0,
        fns,
        fnCount: 0,
        fnSyms,
        fnSymsLen: 0,
        errTags,
        errTagsLen: 0,
        data: &mut [],
        fns: &mut [],
        fnSyms: &mut [],
        errTags: &mut [],
        errTagCounter: 1,
        options: LowerOptions { debug: false, buildTest: false },
    };
    let defaultFnIdx = try lowerDecls(&mut low, root, true);

    return il::Program {
        data: &low.data[..low.dataCount],
        fns: &low.fns[..low.fnCount],
        data: &low.data[..],
        fns: &low.fns[..],
        defaultFnIdx,
    };
}

/////////////////////////////////

    graph: *module::ModuleGraph,
    pkgName: *[u8],
    arena: *mut alloc::Arena,
    options: LowerOptions
) -> Lowerer {
    let data = try! alloc::allocSlice(
        arena, @sizeOf(il::Data), @alignOf(il::Data), INITIAL_DATA
    ) as *mut [il::Data];

    let fns = try! alloc::allocSlice(
        arena, @sizeOf(*il::Fn), @alignOf(*il::Fn), INITIAL_FNS
    ) as *mut [*il::Fn];

    let fnSyms = try! alloc::allocSlice(
        arena, @sizeOf(FnSymEntry), @alignOf(FnSymEntry), MAX_FN_SYMS
    ) as *mut [FnSymEntry];

    let errTags = try! alloc::allocSlice(
        arena, @sizeOf(ErrTagEntry), @alignOf(ErrTagEntry), INITIAL_ERR_TAGS
    ) as *mut [ErrTagEntry];

    return Lowerer {
        arena,
        allocator: alloc::arenaAllocator(arena),
        resolver: res,
        moduleGraph: graph,
        pkgName,
        currentMod: nil,
        data,
        dataCount: 0,
        fns,
        fnCount: 0,
        fnSyms,
        fnSymsLen: 0,
        errTags,
        errTagsLen: 0,
        data: &mut [],
        fns: &mut [],
        fnSyms: &mut [],
        errTags: &mut [],
        errTagCounter: 1,
        options,
    };
}


/// Lower all top-level declarations in a block.
fn lowerDecls(low: *mut Lowerer, root: *ast::Node, isRoot: bool) -> ?u32 throws (LowerError) {
    let case ast::NodeValue::Block(block) = root.value else {
        throw LowerError::ExpectedBlock(root);
    };
    let stmtsList = block.statements.list;
    let stmtsLen = block.statements.len;
    let stmtsList = block.statements;
    let mut defaultFnIdx: ?u32 = nil;

    for i in 0..stmtsLen {
        let node = stmtsList[i];
    for node in stmtsList {
        match node.value {
            case ast::NodeValue::FnDecl(decl) => {
                if let f = try lowerFnDecl(low, node, decl) {
                    if isRoot and checkAttr(decl.attrs, ast::Attribute::Default) {
                        defaultFnIdx = low.fnCount;
                        defaultFnIdx = low.fns.len;
                    }
                    try pushFn(low, f);
                }
            }
            case ast::NodeValue::ConstDecl(decl) => {

            }
            case ast::NodeValue::StaticDecl(decl) => {
                try lowerDataDecl(low, node, decl.value, false);
            }
            case ast::NodeValue::InstanceDecl { traitName, targetType, methods } => {
                try lowerInstanceDecl(low, node, traitName, targetType, &methods);
                try lowerInstanceDecl(low, node, traitName, targetType, methods);
            }
            else => {},
        }
    }
    return defaultFnIdx;
}

/// Finalize lowering and return the unified IL program.
pub fn finalize(low: *Lowerer, defaultFnIdx: ?u32) -> il::Program {
    return il::Program {
        data: &low.data[..low.dataCount],
        fns: &low.fns[..low.fnCount],
        data: &low.data[..],
        fns: &low.fns[..],
        defaultFnIdx,
    };
}

/////////////////////////////////

    }
    return il::formatQualifiedName(self.arena, path, name);
}

/// Register a function symbol with its qualified name.
/// Called when lowering function declarations, so cross-package calls can find the function
/// by name.
/// Called when lowering function declarations, so cross-package calls can find
/// the function by name.
fn registerFnSym(self: *mut Lowerer, sym: *resolver::Symbol, qualName: *[u8]) {
    if self.fnSymsLen >= self.fnSyms.len {
        panic "registerFnSym: symbol table full";
    }
    self.fnSyms[self.fnSymsLen] = FnSymEntry { sym, qualName };
    self.fnSymsLen += 1;
    self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);
}

/// Look up a function's qualified name by its symbol.
/// Returns `nil` if the symbol wasn't registered (e.g. callee's module is not yet lowered).
// TODO: This is kind of dubious as an optimization, if it depends on the order
// in which modules are lowered.
// TODO: Use a hash table here?
fn lookupFnSym(self: *Lowerer, sym: *resolver::Symbol) -> ?*[u8] {
    for i in 0..self.fnSymsLen {
        if self.fnSyms[i].sym == sym {
            return self.fnSyms[i].qualName;
    for entry in self.fnSyms {
        if entry.sym == sym {
            return entry.qualName;
        }
    }
    return nil;
}


    self: *mut Lowerer,
    node: *ast::Node,
    fnType: *resolver::FnType,
    qualName: *[u8]
) -> FnLowerer {
    let vars = try! alloc::allocSlice(self.arena, @sizeOf(VarData), @alignOf(VarData), fnType.localCount) as *mut [VarData];
    let params = try! alloc::allocSlice(self.arena, @sizeOf(FnParamBinding), @alignOf(FnParamBinding), fnType.paramTypesLen) as *mut [FnParamBinding];
    let blockData = try! alloc::allocSlice(self.arena, @sizeOf(BlockData), @alignOf(BlockData), INITIAL_BLOCKS) as *mut [BlockData];
    let loopStack = try! alloc::allocSlice(self.arena, @sizeOf(LoopCtx), @alignOf(LoopCtx), MAX_LOOP_DEPTH) as *mut [LoopCtx];

    let mut fnLow = FnLowerer {
        low: self,
        allocator: alloc::arenaAllocator(self.arena),
        fnType: fnType,
        fnName: qualName,
        vars,
        varsLen: 0,
        params,
        paramsLen: 0,
        blockData,
        blockCount: 0,
        vars: &mut [],
        params: &mut [],
        blockData: &mut [],
        entryBlock: nil,
        currentBlock: nil,
        loopStack,
        loopDepth: 0,
        labelCounter: 0,

    };
    // Throwing functions return a result aggregate (word-sized pointer).
    // TODO: The resolver should set an appropriate type that takes into account
    //       the throws list. It shouldn't set the return type to the "success"
    //       value only.
    if fnType.throwListLen > 0 {
    if fnType.throwList.len > 0 {
        func.returnType = il::Type::W64;
    } else {
        func.returnType = ilType(self, *fnType.returnType);
    }
    let body = decl.body else {

fn lowerInstanceDecl(
    self: *mut Lowerer,
    node: *ast::Node,
    traitNameNode: *ast::Node,
    targetTypeNode: *ast::Node,
    methods: *ast::NodeList
    methods: *mut [*ast::Node]
) throws (LowerError) {
    // Look up the trait and type from the resolver.
    let traitSym = resolver::nodeData(self.resolver, traitNameNode).sym
        else throw LowerError::MissingSymbol(traitNameNode);
    let case resolver::SymbolData::Trait(traitInfo) = traitSym.data

    // Collect qualified names for the v-table. Empty entries are filled
    // later from inherited supertrait methods.
    let mut methodNames: [*[u8]; ast::MAX_TRAIT_METHODS] = undefined;
    let mut methodNameSet: [bool; ast::MAX_TRAIT_METHODS] = [false; ast::MAX_TRAIT_METHODS];

    for i in 0..methods.len {
        let methodNode = methods.list[i];
    for methodNode in methods {
        let case ast::NodeValue::InstanceMethodDecl {
            name, receiverName, receiverType, sig, body
        } = methodNode.value else continue;

        let case ast::NodeValue::Ident(mName) = name.value else {

            params: lowParams,
            returnType: ilType(self, *fnType.returnType),
            isExtern: false,
            blocks: &[],
        };
        if fnType.throwListLen > 0 {
        if fnType.throwList.len > 0 {
            func.returnType = il::Type::W64;
        }
        func.blocks = try lowerFnBody(&mut fnLow, body);
        try pushFn(self, func);


    }

    // Fill inherited method slots from supertraits.
    // These methods were already lowered as part of the supertrait instance
    // declarations and use the same `Type::method` qualified name.
    for i in 0..traitInfo.methodsLen {
    for i in 0..traitInfo.methods.len {
        if not methodNameSet[i] {
            let mName = traitInfo.methods[i].name;
            methodNames[i] = instanceMethodName(self, nil, typeName, mName);
        }
    }

    // Create v-table in data section, used for dynamic dispatch.
    let vName = vtableName(self, nil, typeName, tName);
    let values = try! alloc::allocSlice(
        self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), traitInfo.methodsLen
        self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), traitInfo.methods.len as u32
    ) as *mut [il::DataValue];

    for i in 0..traitInfo.methodsLen {
    for i in 0..traitInfo.methods.len {
        values[i] = il::DataValue {
            item: il::DataItem::Fn(methodNames[i]),
            count: 1,
        };
    }
    try pushData(self, il::Data {
        name: vName,
        size: traitInfo.methodsLen * resolver::PTR_SIZE,
        size: traitInfo.methods.len as u32 * resolver::PTR_SIZE,
        alignment: resolver::PTR_SIZE,
        readOnly: true,
        isUndefined: false,
        values: &values[..traitInfo.methodsLen],
        values: &values[..traitInfo.methods.len as u32],
    });
}

/// Check if a function should be lowered.
fn shouldLowerFn(decl: *ast::FnDecl, buildTest: bool) -> bool {

    if data.ty == resolver::Type::Unknown {
        throw LowerError::MissingType(node);
    }
    let layout = resolver::getTypeLayout(data.ty);
    let qualName = qualifyName(self, nil, sym.name);
    let mut b = dataBuilder(self.arena);
    let mut b = dataBuilder(self.allocator);
    try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);
    let result = dataBuilderFinish(&b);

    try pushData(self, il::Data {
        name: qualName,

    let targetTy = resolver::typeFor(self.resolver, addr.target)
        else throw LowerError::MissingType(addr.target);
    let case resolver::Type::Array(arrInfo) = targetTy
        else throw LowerError::ExpectedArray;

    let mut nested = dataBuilder(self.arena);
    let mut nested = dataBuilder(self.allocator);
    let layout = resolver::getTypeLayout(targetTy);
    try lowerConstDataInto(self, addr.target, targetTy, layout.size, dataPrefix, &mut nested);

    let backing = dataBuilderFinish(&nested);
    let readOnly = not mutable;

}

/// Flatten a constant array literal `[a, b, c]` into a builder.
fn lowerConstArrayLitInto(
    self: *mut Lowerer,
    elems: ast::NodeList,
    elems: *mut [*ast::Node],
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
) throws (LowerError) {
    let case resolver::Type::Array(arrInfo) = ty
        else throw LowerError::ExpectedArray;
    let elemTy = *arrInfo.item;
    let elemLayout = resolver::getTypeLayout(elemTy);

    for i in 0..elems.len {
        let elem = elems.list[i];
    for elem in elems {
        try lowerConstDataInto(self, elem, elemTy, elemLayout.size, dataPrefix, b);
    }
}

/// Build data values for a constant array repeat literal `[item; count]`.

}

/// Build data values for record constants.
fn lowerConstRecordCtorInto(
    self: *mut Lowerer,
    args: ast::NodeList,
    args: *mut [*ast::Node],
    recInfo: resolver::RecordType,
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
) throws (LowerError) {
    let layout = recInfo.layout;
    for i in 0..args.len {
        let argNode = args.list[i];
        let argNode = args[i];
        let mut valueNode = argNode;
        if let case ast::NodeValue::RecordLitField(fieldLit) = argNode.value {
            valueNode = fieldLit.value;
        }
        let fieldInfo = recInfo.fields[i];
        let fieldOffset = fieldInfo.offset as u32;

        // Slot extends to the next field's offset,
        // or record size for the last field.
        let slotEnd = recInfo.fields[i + 1].offset as u32 if i + 1 < recInfo.fieldsLen else layout.size;
        let slotEnd = recInfo.fields[i + 1].offset as u32 if i + 1 < recInfo.fields.len else layout.size;
        let slotSize = slotEnd - fieldOffset;

        try lowerConstDataInto(self, valueNode, fieldInfo.fieldType, slotSize, dataPrefix, b);
    }
}

fn lowerConstUnionVariantInto(
    self: *mut Lowerer,
    node: *ast::Node,
    variantSym: *mut resolver::Symbol,
    ty: resolver::Type,
    payloadArgs: ast::NodeList,
    payloadArgs: *mut [*ast::Node],
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
) throws (LowerError) {
    let case resolver::SymbolData::Variant { type: payloadType, index, .. } = variantSym.data
        else throw LowerError::UnexpectedNodeValue(node);

        });
    }
}

/// Add a data item to the lowerer's data list.
// XXX: Inline this.
fn pushData(self: *mut Lowerer, data: il::Data) throws (LowerError) {
    if self.dataCount >= self.data.len {
        self.data = try! alloc::growSlice(
            self.arena, self.data, self.dataCount,
            @sizeOf(il::Data), @alignOf(il::Data)
        ) as *mut [il::Data];
    }
    self.data[self.dataCount] = data;
    self.dataCount += 1;
    self.data.append(data, self.allocator);
}

/// Add a function to the lowerer's function list.
// XXX: Inline this.
fn pushFn(self: *mut Lowerer, f: *il::Fn) throws (LowerError) {
    if self.fnCount >= self.fns.len {
        self.fns = try! alloc::growSlice(
            self.arena, self.fns, self.fnCount,
            @sizeOf(*il::Fn), @alignOf(*il::Fn)
        ) as *mut [*il::Fn];
    }
    self.fns[self.fnCount] = f;
    self.fnCount += 1;
    self.fns.append(f, self.allocator);
}

/// Find an existing string data entry with matching content.
// TODO: Optimize with hash table or remove?
fn findStringData(self: *Lowerer, s: *[u8]) -> ?*[u8] {
    for i in 0..self.dataCount {
        let data = self.data[i];
        if data.values.len == 1 {
            if let case il::DataItem::Str(existing) = data.values[0].item {
    for d in self.data {
        if d.values.len == 1 {
            if let case il::DataItem::Str(existing) = d.values[0].item {
                if mem::eq(existing, s) {
                    return data.name;
                    return d.name;
                }
            }
        }
    }
    return nil;

    alignment: u32,
    readOnly: bool,
    values: *[il::DataValue],
    dataPrefix: *[u8]
) -> *[u8] throws (LowerError) {
    let name = nextDeclDataName(self, dataPrefix, self.dataCount);
    let name = nextDeclDataName(self, dataPrefix, self.data.len);
    try pushData(self, il::Data { name, size, alignment, readOnly, isUndefined: false, values });

    return name;
}


}

/// Find an existing read-only slice data entry with matching values.
// TODO: Optimize with hash table or remove?
fn findSliceData(self: *Lowerer, values: *[il::DataValue], alignment: u32) -> ?*[u8] {
    for i in 0..self.dataCount {
        let data = self.data[i];
        if data.alignment == alignment and data.readOnly and dataValuesEq(data.values, values) {
            return data.name;
    for d in self.data {
        if d.alignment == alignment and d.readOnly and dataValuesEq(d.values, values) {
            return d.name;
        }
    }
    return nil;
}


    let reg = il::Reg { n: self.regCounter };
    self.regCounter += 1;
    return reg;
}

/// Initialize a growable parameter list.
fn paramList(self: *mut FnLowerer, cap: u32) -> BlockParams throws (LowerError) {
    let list = try! alloc::allocSlice(self.low.arena, @sizeOf(il::Param), @alignOf(il::Param), cap) as *mut [il::Param];
    return BlockParams { list, len: 0 };
}

/// Push a parameter onto a parameter list.
fn paramListPush(self: *mut FnLowerer, list: *mut BlockParams, param: il::Param) throws (LowerError) {
    if list.len >= list.list.len {
        list.list = try! alloc::growSlice(
            self.low.arena, list.list, list.len,
            @sizeOf(il::Param), @alignOf(il::Param)
        ) as *mut [il::Param];
    }
    list.list[list.len] = param;
    list.len += 1;
}

/// Remove the last block parameter and its associated variable.
/// Used when detecting a trivial phi that can be eliminated.
fn removeLastBlockParam(self: *mut FnLowerer, block: BlockId) {
    let blk = getBlockMut(self, block);
    if blk.params.len > 0 {
        blk.params.len -= 1;
        // TODO: Use `pop`?
        blk.params = @sliceOf(blk.params.ptr, blk.params.len - 1, blk.params.cap);
    }
    if blk.paramVars.len > 0 {
        blk.paramVars.len -= 1;
        // TODO: Use `pop`?
        blk.paramVars = @sliceOf(blk.paramVars.ptr, blk.paramVars.len - 1, blk.paramVars.cap);
    }
}

/// Rewrite cached SSA values for a variable across all blocks, and also
/// rewrite any terminator arguments that reference the provisional register.
/// The latter is necessary because recursive SSA resolution may have already
/// patched terminator arguments with the provisional value before it was
/// found to be trivial.
fn rewriteCachedVarValue(self: *mut FnLowerer, v: Var, from: il::Val, to: il::Val) {
    for i in 0..self.blockCount {
    for i in 0..self.blockData.len {
        let blk = getBlockMut(self, BlockId { n: i });
        if blk.vars[v.id] == from {
            blk.vars[v.id] = to;
        }
        if blk.instrs.len > 0 {
            let ix = blk.instrs.len - 1;
            match &mut blk.instrs.list[ix] {
            match &mut blk.instrs[ix] {
                case il::Instr::Jmp { args, .. } =>
                    rewriteValInSlice(*args, from, to),
                case il::Instr::Br { thenArgs, elseArgs, .. } => {
                    rewriteValInSlice(*thenArgs, from, to);
                    rewriteValInSlice(*elseArgs, from, to);

            args[i] = to;
        }
    }
}

/// Initialize a growable u32 list.
fn u32List(self: *mut FnLowerer, cap: u32) -> U32List throws (LowerError) {
    let list = try! alloc::allocSlice(self.low.arena, @sizeOf(u32), @alignOf(u32), cap) as *mut [u32];
    return U32List { list, len: 0 };
}

/// Push a value onto a u32 list.
fn u32ListPush(self: *mut FnLowerer, list: *mut U32List, value: u32) throws (LowerError) {
    if list.len >= list.list.len {
        list.list = try! alloc::growSlice(
            self.low.arena, list.list, list.len,
            @sizeOf(u32), @alignOf(u32)
        ) as *mut [u32];
    }
    list.list[list.len] = value;
    list.len += 1;
}

////////////////////////////
// Basic Block Management //
////////////////////////////

// Basic blocks are the fundamental unit of the CFG. Each block contains a

///
/// The block is initially unsealed (predecessors may be added later) and empty.
/// Returns a [`BlockId`] that can be used for jumps and branches. The block must
/// be switched to via [`switchToBlock`] before instructions can be emitted.
fn createBlock(self: *mut FnLowerer, labelBase: *[u8]) -> BlockId throws (LowerError) {
    if self.blockCount >= self.blockData.len {
        self.blockData = try! alloc::growSlice(
            self.low.arena, self.blockData, self.blockCount,
            @sizeOf(BlockData), @alignOf(BlockData)
        ) as *mut [BlockData];
    }
    let label = try nextLabel(self, labelBase);
    let id = BlockId { n: self.blockCount };
    let instrs = try! il::instrList(self.low.arena, INITIAL_BLOCK_INSTRS);
    let params = try paramList(self, 0);
    let paramVars = try u32List(self, 0);
    let preds = try u32List(self, INITIAL_PREDS);
    let vars = try! alloc::allocSlice(self.low.arena, @sizeOf(?il::Val), @alignOf(?il::Val), self.vars.len) as *mut [?il::Val];

    for i in 0..self.vars.len {
    let id = BlockId { n: self.blockData.len };
    let varCount = self.fnType.localCount;
    let vars = try! alloc::allocSlice(self.low.arena, @sizeOf(?il::Val), @alignOf(?il::Val), varCount) as *mut [?il::Val];

    for i in 0..varCount {
        vars[i] = nil;
    }
    // Allocate source location list if debug info is enabled.
    let mut locs: *mut [il::SrcLoc] = &mut [];
    if self.low.options.debug {
        locs = try! alloc::allocSlice(
            self.low.arena, @sizeOf(il::SrcLoc), @alignOf(il::SrcLoc), INITIAL_BLOCK_INSTRS
        ) as *mut [il::SrcLoc];
    }
    self.blockData[self.blockCount] = BlockData {
    self.blockData.append(BlockData {
        label,
        params,
        paramVars,
        instrs,
        locs,
        locsLen: 0,
        preds,
        params: &mut [],
        paramVars: &mut [],
        instrs: &mut [],
        locs: &mut [],
        preds: &mut [],
        vars,
        sealState: Sealed::No { incompleteVars: try u32List(self, 0) },
        sealState: Sealed::No { incompleteVars: &mut [] },
        loopDepth: self.loopDepth,
    };
    self.blockCount += 1;
    }, self.allocator);

    return id;
}

/// Create a new block with a single parameter.

    labelBase: *[u8],
    param: il::Param
) -> BlockId throws (LowerError) {
    let block = try createBlock(self, labelBase);
    let blk = getBlockMut(self, block);
    try paramListPush(self, &mut blk.params, param);
    blk.params.append(param, self.allocator);

    return block;
}

/// Switch to building a different block.

        return; // Already sealed.
    };
    blk.sealState = Sealed::Yes;

    // Complete all incomplete block parameters.
    for i in 0..incompleteVars.len {
        let v = Var { id: incompleteVars.list[i] };
        try resolveBlockArgs(self, block, v);
    for varId in incompleteVars {
        try resolveBlockArgs(self, block, Var { id: varId });
    }
}

/// Seal a block and switch to it.
fn switchToAndSeal(self: *mut FnLowerer, block: BlockId) throws (LowerError) {

//////////////////////////

/// Emit an instruction to the current block.
fn emit(self: *mut FnLowerer, instr: il::Instr) {
    let blk = self.currentBlock else panic;
    // TODO: Add language support for this.
    let mut block = getBlockMut(self, blk);
    let instrs = &mut block.instrs;

    // Grow instruction list if needed.
    if instrs.len >= instrs.list.len {
        instrs.list = try! alloc::growSlice(
            self.low.arena, instrs.list, instrs.len,
            @sizeOf(il::Instr), @alignOf(il::Instr)
        ) as *mut [il::Instr];
    }
    // Record source location alongside instruction when enabled.
    if self.low.options.debug {
        if block.locsLen >= block.locs.len {
            block.locs = try! alloc::growSlice(
                self.low.arena, block.locs, block.locsLen,
                @sizeOf(il::SrcLoc), @alignOf(il::SrcLoc)
            ) as *mut [il::SrcLoc];
        }
        block.locs[block.locsLen] = self.srcLoc;
        block.locsLen += 1;
        block.locs.append(self.srcLoc, self.allocator);
    }
    il::instrListPush(instrs, instr);
    block.instrs.append(instr, self.allocator);
}

/// Emit an unconditional jump to `target`.
fn emitJmp(self: *mut FnLowerer, target: BlockId) throws (LowerError) {
    emit(self, il::Instr::Jmp { target: target.n, args: &mut [] });

/// causes a jump to the match block. If no patterns match, we jump to the
/// fallthrough block.
fn emitPatternMatches(
    self: *mut FnLowerer,
    subject: *MatchSubject,
    patterns: ast::NodeList,
    patterns: *mut [*ast::Node],
    matchBlock: BlockId,
    fallthrough: BlockId
) throws (LowerError) {
    assert patterns.len > 0;

    for i in 0..(patterns.len - 1) {
        let pattern = patterns.list[i];
        let pattern = patterns[i];
        let nextArm = try createBlock(self, "arm");
        try emitPatternMatch(self, subject, pattern, matchBlock, nextArm);

        // Seal the intermediate arm block: all predecessor edges are known
        // This ensures SSA construction can resolve variable uses through
        // single-predecessor optimization instead of creating unresolved block
        // parameters.
        try switchToAndSeal(self, nextArm);
    }
    // Handle last pattern: go to fallthrough block on failure.
    let last = patterns.list[patterns.len - 1];
    let last = patterns[patterns.len - 1];
    try emitPatternMatch(self, subject, last, matchBlock, fallthrough);
}

/// Emit a match binding pattern.
/// Binding patterns always match for regular values, but for optionals they

fn blockHasTerminator(self: *FnLowerer) -> bool {
    let blk = getBlock(self, currentBlock(self));
    if blk.instrs.len == 0 {
        return false;
    }
    match blk.instrs.list[blk.instrs.len - 1] {
    match blk.instrs[blk.instrs.len - 1] {
        case il::Instr::Ret { .. },
             il::Instr::Jmp { .. },
             il::Instr::Br { .. },
             il::Instr::Switch { .. },
             il::Instr::Unreachable =>

    if blk.sealState == Sealed::Yes {
        panic "addPredecessor: adding predecessor to sealed block";
    }
    let preds = &mut blk.preds;
    for i in 0..preds.len {
        if preds.list[i] == pred.n { // Avoid duplicate predecessor entries.
        if preds[i] == pred.n { // Avoid duplicate predecessor entries.
            return;
        }
    }
    try u32ListPush(self, preds, pred.n);
    preds.append(pred.n, self.allocator);
}

/// Finalize all blocks and return the block array.
fn finalizeBlocks(self: *mut FnLowerer) -> *[il::Block] throws (LowerError) {
    let blocks = try! alloc::allocSlice(
        self.low.arena, @sizeOf(il::Block), @alignOf(il::Block), self.blockCount
        self.low.arena, @sizeOf(il::Block), @alignOf(il::Block), self.blockData.len
    ) as *mut [il::Block];
    let mut count: u32 = 0;

    for i in 0..self.blockCount {
    for i in 0..self.blockData.len {
        let data = &self.blockData[i];

        let params = &data.params.list[..data.params.len];
        let preds = &data.preds.list[..data.preds.len];
        blocks[count] = il::Block {
        blocks[i] = il::Block {
            label: data.label,
            params,
            params: &data.params[..],
            instrs: data.instrs,
            locs: &data.locs[..data.locsLen],
            preds,
            locs: &data.locs[..],
            preds: &data.preds[..],
            loopDepth: data.loopDepth,
        };
        count += 1;
    }
    return &blocks[..count];
    return &blocks[..self.blockData.len];
}

/////////////////////
// Loop Management //
/////////////////////

    name: ?*[u8],
    type: il::Type,
    mutable: bool,
    val: il::Val
) -> Var {
    if self.varsLen >= self.vars.len {
        panic "newVar: out of capacity";
    }
    let id = self.varsLen;
    self.vars[id] = VarData { name, type, mutable, addressTaken: false };
    self.varsLen += 1;
    let id = self.vars.len;
    self.vars.append(VarData { name, type, mutable, addressTaken: false }, self.allocator);

    let v = Var { id };
    if self.currentBlock != nil {
        defVar(self, v, val);
    }

/// Define (write) a variable. Record the SSA value of a variable in the
/// current block. Called when a variable is assigned or initialized (`let`
/// bindings, assignments, loop updates). When [`useVar`] is later called,
/// it will retrieve this value.
fn defVar(self: *mut FnLowerer, v: Var, val: il::Val) {
    assert v.id < self.varsLen;
    assert v.id < self.vars.len;
    getBlockMut(self, currentBlock(self)).vars[v.id] = val;
}

/// Use (read) the current value of a variable in the current block.
/// May insert block parameters if the value must come from predecessors.

/// Given a variable and a block where it's used, this function finds the
/// correct [`il::Val`] that holds the variable's value at that program point.
/// When control flow merges from multiple predecessors with different
/// definitions, it creates a block parameter to unify them.
fn useVarInBlock(self: *mut FnLowerer, block: BlockId, v: Var) -> il::Val throws (LowerError) {
    assert v.id < self.varsLen;
    assert v.id < self.vars.len;

    let blk = getBlockMut(self, block);
    if let val = blk.vars[v.id] {
        return val;
    }

            throw LowerError::InvalidUse;
        }
        // Single predecessor means no merge needed, variable is implicitly
        // available without a block parameter.
        if blk.preds.len == 1 {
            let pred = BlockId { n: blk.preds.list[0] };
            let pred = BlockId { n: blk.preds[0] };
            if pred.n != block.n {
                let val = try useVarInBlock(self, pred, v);
                blk.vars[v.id] = val; // Cache.
                return val;
            }

}

/// Look up a variable by name in the current scope.
/// Searches from most recently declared to first, enabling shadowing.
fn lookupVarByName(self: *FnLowerer, name: *[u8]) -> ?Var {
    let mut id = self.varsLen;
    let mut id = self.vars.len;
    while id > 0 {
        id -= 1;
        if let varName = self.vars[id].name {
            if mem::eq(varName, name) {
                return Var { id };

    return lookupVarByName(self, name);
}

/// Save current lexical variable scope depth.
fn enterVarScope(self: *FnLowerer) -> u32 {
    return self.varsLen;
    return self.vars.len;
}

/// Restore lexical variable scope depth.
fn exitVarScope(self: *mut FnLowerer, savedVarsLen: u32) {
    self.varsLen = savedVarsLen;
    self.vars = @sliceOf(self.vars.ptr, savedVarsLen, self.vars.cap);
}

/// Get the metadata for a variable.
fn getVar(self: *FnLowerer, v: Var) -> *VarData {
    assert v.id < self.varsLen;
    assert v.id < self.vars.len;
    return &self.vars[v.id];
}

/// Create a block parameter to merge a variable's value from multiple
/// control flow paths.

    let type = getVar(self, v).type;

    // Create block parameter and add it to the block.
    let param = il::Param { value: reg, type };
    let blk = getBlockMut(self, block);
    try paramListPush(self, &mut blk.params, param);
    try u32ListPush(self, &mut blk.paramVars, v.id); // Associate variable with parameter.
    blk.params.append(param, self.allocator);
    blk.paramVars.append(v.id, self.allocator); // Associate variable with parameter.

    // Record that this variable's value in this block is now the parameter register.
    // This must happen before the predecessor loop to handle self-referential loops.
    blk.vars[v.id] = il::Val::Reg(reg);

    match &mut blk.sealState {
        case Sealed::No { incompleteVars } => {
            // Block unsealed: defer until sealing.
            try u32ListPush(self, incompleteVars, v.id);
            incompleteVars.append(v.id, self.allocator);
        },
        case Sealed::Yes => {
            // Block sealed: check for trivial phi before committing. If all
            // predecessors provide the same value, we can remove the param we
            // just created and use that value directly.


    // Find the parameter index corresponding to this variable.
    // Each variable that needs merging gets its own block parameter slot.
    let mut paramIdx: u32 = 0;
    for i in 0..blk.paramVars.len {
        if blk.paramVars.list[i] == v.id {
        if blk.paramVars[i] == v.id {
            paramIdx = i;
            break;
        }
    }

    // For each predecessor, recursively look up the variable's reaching definition
    // in that block, then patch the predecessor's terminator to pass that value
    // as an argument to this block's parameter.
    for i in 0..blk.preds.len {
        let pred = BlockId { n: blk.preds.list[i] };
    for predId in blk.preds {
        let pred = BlockId { n: predId };
        // This may recursively trigger more block arg resolution if the
        // predecessor also needs to look up the variable from its predecessors.
        let val = try useVarInBlock(self, pred, v);
        if val == il::Val::Undef {
            panic "createBlockParam: predecessor provides undef value for block parameter";

    // Get the block parameter register.
    let paramReg = blk.vars[v.id];
    // Check if all predecessors provide the same value.
    let mut sameVal: ?il::Val = nil;

    for i in 0..blk.preds.len {
        let pred = BlockId { n: blk.preds.list[i] };
    for predId in blk.preds {
        let pred = BlockId { n: predId };
        let val = try useVarInBlock(self, pred, v);

        // Check if this is a self-reference.
        // This happens in cycles where the loop back-edge passes the phi to
        // itself. We skip self-references when checking for trivial phis.

    let data = getBlockMut(self, from);
    let ix = data.instrs.len - 1; // The terminator is always the last instruction.

    // TODO: We shouldn't need to use a mutable subscript here, given that the
    // fields are already mutable.
    match &mut data.instrs.list[ix] {
    match &mut data.instrs[ix] {
        case il::Instr::Jmp { args, .. } => {
            *args = growArgs(self, *args, paramIdx + 1);
            args[paramIdx] = val;
        }
        case il::Instr::Br { thenTarget, thenArgs, elseTarget, elseArgs, .. } => {

/// Lower function parameters. Declares variables for each parameter.
/// When a receiver name is passed, we're handling a trait method.
fn lowerParams(
    self: *mut FnLowerer,
    fnType: resolver::FnType,
    astParams: ast::NodeList,
    astParams: *mut [*ast::Node],
    receiverName: ?*ast::Node
) -> *[il::Param] throws (LowerError) {
    let offset: u32 = 1 if self.returnReg != nil else 0;
    let totalLen = fnType.paramTypesLen + offset;
    let totalLen = fnType.paramTypes.len as u32 + offset;
    if totalLen == 0 {
        return &[];
    }
    assert fnType.paramTypesLen <= resolver::MAX_FN_PARAMS;
    assert fnType.paramTypes.len as u32 <= resolver::MAX_FN_PARAMS;

    let params = try! alloc::allocSlice(
        self.low.arena, @sizeOf(il::Param), @alignOf(il::Param), totalLen
    ) as *mut [il::Param];

    if let reg = self.returnReg {
        params[0] = il::Param { value: reg, type: il::Type::W64 };
    }
    for i in 0..fnType.paramTypesLen {
    for i in 0..fnType.paramTypes.len as u32 {
        let type = ilType(self.low, *fnType.paramTypes[i]);
        let reg = nextReg(self);

        params[i + offset] = il::Param { value: reg, type };


                let case ast::NodeValue::Ident(recName) = recNode.value else {
                    throw LowerError::ExpectedIdentifier;
                };
                name = recName;
            } else {
                name = try paramName(&astParams.list[i - 1].value);
                name = try paramName(&astParams[i - 1].value);
            }
        } else {
            name = try paramName(&astParams.list[i].value);
            name = try paramName(&astParams[i].value);
        }
        let v = newVar(self, name, type, false, il::Val::Undef);

        self.params[self.paramsLen] = FnParamBinding { var: v, reg };
        self.paramsLen += 1;
        self.params.append(FnParamBinding { var: v, reg }, self.allocator);
    }
    return params;
}

/// Resolve match subject.

    // Declare the variable in the current block's scope.
    return newVar(self, name, ilType(self.low, subject.bindType), false, subject.val);
}

/// Bind variables from inside case patterns (union variants, records, slices).
fn bindPatternVariables(self: *mut FnLowerer, subject: *MatchSubject, patterns: ast::NodeList) throws (LowerError) {
    for i in 0..patterns.len {
        let pattern = patterns.list[i];
fn bindPatternVariables(self: *mut FnLowerer, subject: *MatchSubject, patterns: *mut [*ast::Node]) throws (LowerError) {
    for pattern in patterns {

        // Handle simple variant patterns like `Variant(x)`.
        // TODO: Why is this handled differently from the cases below?
        if let arg = resolver::variantPatternBinding(self.low.resolver, pattern) {
            if let case ast::NodeValue::Ident(name) = arg.value {

    let base = try emitValToReg(self, subject.val);
    let valOffset = unionInfo.valOffset as i32;
    let payloadBase = emitPtrOffset(self, base, valOffset);

    // Bind each field.
    for i in 0..lit.fields.len {
        let fieldNode = lit.fields.list[i];
    for fieldNode in lit.fields {
        let case ast::NodeValue::RecordLitField(field) = fieldNode.value else {
            throw LowerError::UnexpectedNodeValue(fieldNode);
        };
        let fieldIdx = resolver::recordFieldIndexFor(self.low.resolver, fieldNode)
            else throw LowerError::MissingMetadata;
        if fieldIdx >= recInfo.fieldsLen {
        if fieldIdx >= recInfo.fields.len {
            throw LowerError::MissingMetadata;
        }
        let fieldInfo = recInfo.fields[fieldIdx];

        try bindFieldVariable(self, field.value, payloadBase, fieldInfo, subject.by);

    let entry = try createBlock(self, "entry");
    self.entryBlock = entry;
    switchToBlock(self, entry);

    /// Bind parameter registers to variables in the entry block.
    for i in 0..self.paramsLen {
        let def = self.params[i];
    for def in self.params {
        defVar(self, def.var, il::Val::Reg(def.reg));
    }
    /// Lower function body.
    try lowerBlock(self, body);

    // Add implicit return if body doesn't diverge.
    if not blockHasTerminator(self) {
        if self.fnType.throwListLen > 0 {
        if self.fnType.throwList.len > 0 {
            if *self.fnType.returnType == resolver::Type::Void {
                // Implicit `void` return in throwing function: wrap in result success.
                let val = try buildResult(self, 0, nil, resolver::Type::Void);
                try emitRetVal(self, val);
            } else {

    }
    return try finalizeBlocks(self);
}

/// Lower a scalar match as a switch instruction.
fn lowerMatchSwitch(self: *mut FnLowerer, prongs: *ast::NodeList, subject: *MatchSubject, mergeBlock: *mut ?BlockId) throws (LowerError) {
fn lowerMatchSwitch(self: *mut FnLowerer, prongs: *mut [*ast::Node], subject: *MatchSubject, mergeBlock: *mut ?BlockId) throws (LowerError) {
    let mut blocks: [BlockId; 32] = undefined;
    let mut cases: *mut [il::SwitchCase] = &mut [];
    let mut caseIdx: u32 = 0;
    let mut defaultIdx: u32 = 0;
    let entry = currentBlock(self);

    for i in 0..prongs.len {
        let p = prongs.list[i];
        let p = prongs[i];
        let case ast::NodeValue::MatchProng(prong) = p.value
            else throw LowerError::UnexpectedNodeValue(p);

        match prong.arm {
            case ast::ProngArm::Binding(_), ast::ProngArm::Else => {
                blocks[i] = try createBlock(self, "default");
                defaultIdx = i;
            }
            case ast::ProngArm::Case(pats) => {
                blocks[i] = try createBlock(self, "case");
                for j in 0..pats.len {
                    if caseIdx >= cases.len {
                        cases = try! alloc::growSlice(
                            self.low.arena,
                            cases as *mut [opaque],
                            caseIdx,
                            @sizeOf(il::SwitchCase),
                            @alignOf(il::SwitchCase)
                        ) as *mut [il::SwitchCase];
                    }
                    let cv = resolver::constValueFor(self.low.resolver, pats.list[j])
                        else throw LowerError::MissingConst(pats.list[j]);
                for pat in pats {
                    let cv = resolver::constValueFor(self.low.resolver, pat)
                        else throw LowerError::MissingConst(pat);

                    cases[caseIdx] = il::SwitchCase {
                    cases.append(il::SwitchCase {
                        value: constToScalar(cv),
                        target: blocks[i].n,
                        args: &mut []
                    };
                    caseIdx += 1;
                    }, self.allocator);
                }
            }
        }
        try addPredecessor(self, blocks[i], entry);
    }
    emit(self, il::Instr::Switch {
        val: subject.val,
        defaultTarget: blocks[defaultIdx].n,
        defaultArgs: &mut [],
        cases: &mut cases[..caseIdx]
        cases: &mut cases[..]
    });

    for i in 0..prongs.len {
        let p = prongs.list[i];
        let p = prongs[i];
        let case ast::NodeValue::MatchProng(prong) = p.value
            else throw LowerError::UnexpectedNodeValue(p);

        try switchToAndSeal(self, blocks[i]);
        try lowerNode(self, prong.body);

///       ret 0;                          // `else` body
///
fn lowerMatch(self: *mut FnLowerer, node: *ast::Node, m: ast::Match) throws (LowerError) {
    assert m.prongs.len > 0;

    let prongs = &m.prongs;
    let prongs = m.prongs;
    // Lower the subject expression once; reused across all arms.
    let subject = try lowerMatchSubject(self, m.subject);
    // Merge block created lazily if any arm needs it (i.e., doesn't diverge).
    let mut mergeBlock: ?BlockId = nil;


    try emitJmp(self, firstArm);
    try switchToAndSeal(self, firstArm);

    for i in 0..prongs.len {
        let prongScope = enterVarScope(self);
        let prongNode = prongs.list[i];
        let prongNode = prongs[i];
        let case ast::NodeValue::MatchProng(prong) = prongNode.value
            else panic "lowerMatch: expected match prong";

        let isLastArm = i + 1 == prongs.len;
        let hasGuard = prong.guard != nil;

    } else {
        targetBlock = *successBlock;
    }
    match pat.kind {
        case ast::PatternKind::Case => {
            let patterns = ast::NodeList { list: &mut [pat.pattern], len: 1 };
            let patterns: *mut [*ast::Node] = &mut [pat.pattern];
            // Jump to `targetBlock` if the pattern matches, `failBlock` otherwise.
            try emitPatternMatches(self, subject, patterns, targetBlock, failBlock);
            try switchToAndSeal(self, targetBlock);
            // Bind any variables inside the pattern.
            try bindPatternVariables(self, subject, patterns);

fn lowerBlock(self: *mut FnLowerer, node: *ast::Node) throws (LowerError) {
    let case ast::NodeValue::Block(blk) = node.value else {
        throw LowerError::ExpectedBlock(node);
    };
    let savedVarsLen = enterVarScope(self);
    for i in 0..blk.statements.len {
        let stmt = blk.statements.list[i];
    for stmt in blk.statements {
        try lowerNode(self, stmt);

        // If the statement diverges, further statements are unreachable.
        if blockHasTerminator(self) {
            exitVarScope(self, savedVarsLen);

///
/// This is the case for throwing functions, which return a result aggregate,
/// and for functions returning large aggregates that cannot be passed in
/// registers.
fn requiresReturnParam(fnType: *resolver::FnType) -> bool {
    return fnType.throwListLen > 0
    return fnType.throwList.len > 0
        or (isAggregateType(*fnType.returnType)
        and not isSmallAggregate(*fnType.returnType));
}

/// Check if a node is a void union variant literal (e.g. `Color::Red`).

    payload: ?il::Val,
    payloadType: resolver::Type
) -> il::Val throws (LowerError) {
    let successType = *self.fnType.returnType;
    let layout = resolver::getResultLayout(
        successType, &self.fnType.throwList[..self.fnType.throwListLen]
        successType, self.fnType.throwList
    );
    return try buildTagged(self, layout, tag, payload, payloadType, 8, RESULT_VAL_OFFSET);
}

/// Build a slice aggregate from a data pointer, length and capacity.

    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
    let mut result: ?il::Val = nil;

    for i in 0..recInfo.fieldsLen {
        let field = recInfo.fields[i];
    for field in recInfo.fields {
        let cmp = try emitEqAtOffset(self, a, b, offset + field.offset, field.fieldType);

        result = emitLogicalAnd(self, result, cmp);
    }
    if let r = result {


    // Create comparison blocks for each non-void variant and build switch cases.
    // Void variants jump directly to merge with `true`.
    let trueArgs = try allocVal(self, il::Val::Imm(1));
    let cases = try! alloc::allocSlice(
        self.low.arena, @sizeOf(il::SwitchCase), @alignOf(il::SwitchCase), unionInfo.variantsLen
        self.low.arena, @sizeOf(il::SwitchCase), @alignOf(il::SwitchCase), unionInfo.variants.len as u32
    ) as *mut [il::SwitchCase];

    let mut caseBlocks: [?BlockId; resolver::MAX_UNION_VARIANTS] = undefined;
    for i in 0..unionInfo.variantsLen {
    for i in 0..unionInfo.variants.len {
        if unionInfo.variants[i].valueType == resolver::Type::Void {
            cases[i] = il::SwitchCase {
                value: i as i64,
                target: mergeBlock.n,
                args: trueArgs

        cases
    });

    // Add predecessor edges for switch targets.
    try addPredecessor(self, unreachableBlock, tagBlock);
    for i in 0..unionInfo.variantsLen {
    for i in 0..unionInfo.variants.len {
        if let caseBlock = caseBlocks[i] {
            try addPredecessor(self, caseBlock, tagBlock);
        } else {
            try addPredecessor(self, mergeBlock, tagBlock);
        }
    }
    let valOffset = unionInfo.valOffset as i32;

    // Emit payload comparison blocks for non-void variants.
    for i in 0..unionInfo.variantsLen {
    for i in 0..unionInfo.variants.len {
        if let caseBlock = caseBlocks[i] {
            try switchToAndSeal(self, caseBlock);
            let payloadEq = try emitEqAtOffset(
                self, a, b, offset + valOffset, unionInfo.variants[i].valueType
            );

/// The `offset` is added to each field's offset when storing.
fn lowerRecordFields(
    self: *mut FnLowerer,
    dst: il::Reg,
    recInfo: *resolver::RecordType,
    fields: ast::NodeList,
    fields: *mut [*ast::Node],
    offset: i32
) throws (LowerError) {
    for i in 0..fields.len {
        let fieldNode = fields.list[i];
        let fieldNode = fields[i];
        let case ast::NodeValue::RecordLitField(field) = fieldNode.value else {
            throw LowerError::UnexpectedNodeValue(fieldNode);
        };
        let mut fieldIdx: u32 = i;
        if recInfo.labeled {

        }
    }
}

/// Lower an unlabeled record constructor call.
fn lowerRecordCtor(self: *mut FnLowerer, nominal: *resolver::NominalType, args: ast::NodeList) -> il::Val throws (LowerError) {
fn lowerRecordCtor(self: *mut FnLowerer, nominal: *resolver::NominalType, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
    let case resolver::NominalType::Record(recInfo) = *nominal else {
        throw LowerError::ExpectedRecord;
    };
    let typ = resolver::Type::Nominal(nominal);
    let dst = try emitReserve(self, typ);

    for i in 0..args.len {
        let argNode = args.list[i];
        let argNode = args[i];
        // Skip `undefined` arguments.
        if not isUndef(argNode) {
            let fieldTy = recInfo.fields[i].fieldType;
            let argVal = try lowerExpr(self, argNode);
            try emitStore(self, dst, recInfo.fields[i].offset, fieldTy, argVal);

    }
    return il::Val::Reg(dst);
}

/// Lower an array literal expression like `[1, 2, 3]`.
fn lowerArrayLit(self: *mut FnLowerer, node: *ast::Node, elements: ast::NodeList) -> il::Val
fn lowerArrayLit(self: *mut FnLowerer, node: *ast::Node, elements: *mut [*ast::Node]) -> il::Val
    throws (LowerError)
{
    let typ = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };

    let elemTy = *arrInfo.item;
    let elemLayout = resolver::getTypeLayout(elemTy);
    let dst = try emitReserve(self, typ);

    for i in 0..elements.len {
        let elemNode = elements.list[i];
        let elemNode = elements[i];
        let elemVal = try lowerExpr(self, elemNode);
        let offset = i * elemLayout.size;

        try emitStore(self, dst, offset as i32, elemTy, elemVal);
    }

/// stack space and stores elements at runtime.
fn lowerSliceLiteral(
    self: *mut FnLowerer,
    sliceNode: *ast::Node,
    arrayNode: *ast::Node,
    elements: ast::NodeList
    elements: *mut [*ast::Node]
) -> il::Val throws (LowerError) {
    // Get the slice type from the address-of expression.
    let sliceTy = resolver::typeFor(self.low.resolver, sliceNode) else {
        throw LowerError::MissingType(sliceNode);
    };

/// Lower a slice literal with all constant elements to static data.
fn lowerConstSliceLiteral(
    self: *mut FnLowerer,
    elemTy: *resolver::Type,
    mutable: bool,
    elements: ast::NodeList,
    elements: *mut [*ast::Node],
    elemLayout: resolver::Layout
) -> il::Val throws (LowerError) {
    // Build data values for all elements using standard data lowering.
    let mut b = dataBuilder(self.low.arena);
    for i in 0..elements.len {
        let elem = elements.list[i];
    let mut b = dataBuilder(self.low.allocator);
    for elem in elements {
        try lowerConstDataInto(self.low, elem, *elemTy, elemLayout.size, self.fnName, &mut b);
    }
    let result = dataBuilderFinish(&b);
    let readOnly = not mutable;


/// Lower a slice literal with non-constant elements.
fn lowerRuntimeSliceLiteral(
    self: *mut FnLowerer,
    elemTy: *resolver::Type,
    mutable: bool,
    elements: ast::NodeList
    elements: *mut [*ast::Node]
) -> il::Val throws (LowerError) {
    let elemLayout = resolver::getTypeLayout(*elemTy);
    let arraySize = elements.len * elemLayout.size;
    let arrayReg = nextReg(self);


        size: il::Val::Imm(arraySize as i64),
        alignment: elemLayout.alignment
    });
    // Store each element.
    for i in 0..elements.len {
        let elemNode = elements.list[i];
        let elemNode = elements[i];
        let elemVal = try lowerExpr(self, elemNode);
        let offset = i * elemLayout.size;

        try emitStore(self, arrayReg, offset as i32, *elemTy, elemVal);
    }

    }
}

/// Compute the size of the return buffer for the current function.
fn retBufSize(self: *mut FnLowerer) -> u32 {
    if self.fnType.throwListLen > 0 {
    if self.fnType.throwList.len > 0 {
        let successType = *self.fnType.returnType;

        return resolver::getResultLayout(successType, &self.fnType.throwList[..self.fnType.throwListLen]).size;
        return resolver::getResultLayout(successType, self.fnType.throwList).size;
    }
    return resolver::getTypeLayout(*self.fnType.returnType).size;
}

/// Lower a return statement.

    try emitRetVal(self, val);
}

/// Lower a throw statement.
fn lowerThrowStmt(self: *mut FnLowerer, expr: *ast::Node) throws (LowerError) {
    assert self.fnType.throwListLen > 0;
    assert self.fnType.throwList.len > 0;

    let errType = resolver::typeFor(self.low.resolver, expr) else {
        throw LowerError::MissingType(expr);
    };
    let tag = getOrAssignErrorTag(self.low, errType) as i64;


    return try lowerConstDataAsSlice(self, @sliceOf(ptr, 1), 1, true, item, mutable, s.len);
}

/// Lower a builtin call expression.
fn lowerBuiltinCall(self: *mut FnLowerer, node: *ast::Node, kind: ast::Builtin, args: ast::NodeList) -> il::Val throws (LowerError) {
fn lowerBuiltinCall(self: *mut FnLowerer, node: *ast::Node, kind: ast::Builtin, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
    match kind {
        case ast::Builtin::SliceOf => return try lowerSliceOf(self, node, args),
        case ast::Builtin::SizeOf, ast::Builtin::AlignOf => {
            let constVal = resolver::constValueFor(self.low.resolver, node) else {
                throw LowerError::MissingConst(node);

        }
    }
}

/// Lower a `@sliceOf(ptr, len)` or `@sliceOf(ptr, len, cap)` builtin call.
fn lowerSliceOf(self: *mut FnLowerer, node: *ast::Node, args: ast::NodeList) -> il::Val throws (LowerError) {
fn lowerSliceOf(self: *mut FnLowerer, node: *ast::Node, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
    if args.len != 2 and args.len != 3 {
        throw LowerError::InvalidArgCount;
    }
    let sliceTy = resolver::typeFor(self.low.resolver, node) else {
        throw LowerError::MissingType(node);
    };
    let case resolver::Type::Slice { item, mutable } = sliceTy else {
        throw LowerError::ExpectedSliceOrArray;
    };
    let ptrVal = try lowerExpr(self, args.list[0]);
    let lenVal = try lowerExpr(self, args.list[1]);
    let ptrVal = try lowerExpr(self, args[0]);
    let lenVal = try lowerExpr(self, args[1]);
    let mut capVal = lenVal;
    if args.len == 3 {
        capVal = try lowerExpr(self, args.list[2]);
        capVal = try lowerExpr(self, args[2]);
    }
    return try buildSliceValue(self, item, mutable, ptrVal, lenVal, capVal);
}

/// Lower a `try` expression.

            try emitStore(self, slot, 0, tryExprTy, errVal);
        }
        try emitMergeIfUnterminated(self, &mut mergeBlock);
    } else if t.catches.len > 0 {
        // `try ... catch` -- handle the error.
        let firstNode = t.catches.list[0];
        let firstNode = t.catches[0];
        let case ast::NodeValue::CatchClause(first) = firstNode.value
            else panic "lowerTry: expected CatchClause";

        if first.typeNode != nil or t.catches.len > 1 {
            // Typed multi-catch: switch on global error tag.

        emit(self, il::Instr::Unreachable);
    } else {
        // Plain `try` -- propagate the error to the caller by returning early.
        // Forward the callee's global error tag and payload directly.
        let callerLayout = resolver::getResultLayout(
            *self.fnType.returnType, &self.fnType.throwList[..self.fnType.throwListLen]
            *self.fnType.returnType, self.fnType.throwList
        );
        let calleeErrSize = maxErrSize(&calleeInfo.throwList[..calleeInfo.throwListLen]);
        let calleeErrSize = maxErrSize(calleeInfo.throwList);
        let dst = try emitReserveLayout(self, callerLayout);

        emitStoreW64At(self, il::Val::Reg(tagReg), dst, TVAL_TAG_OFFSET);
        let srcPayload = emitPtrOffset(self, base, RESULT_VAL_OFFSET);
        let dstPayload = emitPtrOffset(self, dst, RESULT_VAL_OFFSET);

/// Emits a switch on the global error tag to dispatch to the correct catch
/// clause. Each typed clause extracts the error payload for its specific type
/// and binds it to the clause's identifier.
fn lowerMultiCatch(
    self: *mut FnLowerer,
    catches: ast::NodeList,
    catches: *mut [*ast::Node],
    calleeInfo: *resolver::FnType,
    base: il::Reg,
    tagReg: il::Reg,
    mergeBlock: *mut ?BlockId
) throws (LowerError) {
    let entry = currentBlock(self);

    // First pass: create blocks, resolve error types, and build switch cases.
    let mut blocks: [BlockId; MAX_CATCH_CLAUSES] = undefined;
    let mut errTypes: [?resolver::Type; MAX_CATCH_CLAUSES] = undefined;
    let cases = try! alloc::allocSlice(
        self.low.arena,
        @sizeOf(il::SwitchCase),
        @alignOf(il::SwitchCase),
        catches.len
    ) as *mut [il::SwitchCase];
    let mut caseIdx: u32 = 0;
    let mut cases: *mut [il::SwitchCase] = &mut [];
    let mut defaultIdx: ?u32 = nil;

    for i in 0..catches.len {
        let clauseNode = catches.list[i];
        let clauseNode = catches[i];
        let case ast::NodeValue::CatchClause(clause) = clauseNode.value
            else panic "lowerMultiCatch: expected CatchClause";

        blocks[i] = try createBlock(self, "catch");
        try addPredecessor(self, blocks[i], entry);

            let errTy = resolver::typeFor(self.low.resolver, typeNode) else {
                throw LowerError::MissingType(typeNode);
            };
            errTypes[i] = errTy;

            cases[caseIdx] = il::SwitchCase {
            cases.append(il::SwitchCase {
                value: getOrAssignErrorTag(self.low, errTy) as i64,
                target: blocks[i].n,
                args: &mut []
            };
            caseIdx += 1;
            }, self.allocator);
        } else {
            errTypes[i] = nil;
            defaultIdx = i;
        }
    }

    }
    emit(self, il::Instr::Switch {
        val: il::Val::Reg(tagReg),
        defaultTarget: defaultTarget.n,
        defaultArgs: &mut [],
        cases: &mut cases[..caseIdx]
        cases
    });

    // Second pass: emit each catch clause body.
    for i in 0..catches.len {
        let clauseNode = catches.list[i];
        let clauseNode = catches[i];
        let case ast::NodeValue::CatchClause(clause) = clauseNode.value
            else panic "lowerMultiCatch: expected CatchClause";

        try switchToAndSeal(self, blocks[i]);
        let savedVarsLen = enterVarScope(self);

    // Get the address of the slice header.
    let sliceVal = try lowerExpr(self, access.parent);
    let sliceReg = try emitValToReg(self, sliceVal);

    // Lower the value to append and the allocator.
    let elemVal = try lowerExpr(self, call.args.list[0]);
    let allocVal = try lowerExpr(self, call.args.list[1]);
    let elemVal = try lowerExpr(self, call.args[0]);
    let allocVal = try lowerExpr(self, call.args[1]);
    let allocReg = try emitValToReg(self, allocVal);

    let elemLayout = resolver::getTypeLayout(*elemType);
    let stride = elemLayout.size;
    let alignment = elemLayout.alignment;

    // Get slice header address.
    let sliceVal = try lowerExpr(self, access.parent);
    let sliceReg = try emitValToReg(self, sliceVal);

    // Lower the index argument.
    let indexVal = try lowerExpr(self, call.args.list[0]);
    let indexVal = try lowerExpr(self, call.args[0]);

    // Load len and bounds-check: index must be smaller than length.
    let lenVal = loadSliceLen(self, sliceReg);
    try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, indexVal, lenVal);


    // Data pointer is the receiver (first argument after hidden return param).
    args[argOffset] = il::Val::Reg(dataReg);

    // Lower user arguments.
    for i in 0..call.args.len {
        args[i + 1 + argOffset] = try lowerExpr(self, call.args.list[i]);
        args[i + 1 + argOffset] = try lowerExpr(self, call.args[i]);
    }

    // Allocate the return buffer when needed.
    if returnParam {
        if methodFnType.throwListLen > 0 {
        if methodFnType.throwList.len > 0 {
            let successType = *methodFnType.returnType;
            let layout = resolver::getResultLayout(
                successType, &methodFnType.throwList[..methodFnType.throwListLen]);
                successType, methodFnType.throwList);

            args[0] = il::Val::Reg(try emitReserveLayout(self, layout));
        } else {
            args[0] = il::Val::Reg(try emitReserve(self, retTy));
        }

/// Lower an ecall intrinsic: `ecall(num, a0, a1, a2, a3) -> i32`.
fn lowerEcall(self: *mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
    if call.args.len != 5 {
        throw LowerError::InvalidArgCount;
    }
    let num = try lowerExpr(self, call.args.list[0]);
    let a0 = try lowerExpr(self, call.args.list[1]);
    let a1 = try lowerExpr(self, call.args.list[2]);
    let a2 = try lowerExpr(self, call.args.list[3]);
    let a3 = try lowerExpr(self, call.args.list[4]);
    let num = try lowerExpr(self, call.args[0]);
    let a0 = try lowerExpr(self, call.args[1]);
    let a1 = try lowerExpr(self, call.args[2]);
    let a2 = try lowerExpr(self, call.args[3]);
    let a3 = try lowerExpr(self, call.args[4]);
    let dst = nextReg(self);

    emit(self, il::Instr::Ecall { dst, num, a0, a1, a2, a3 });

    return il::Val::Reg(dst);

    // hidden return buffer when needed.
    let callee = try lowerCallee(self, call.callee);
    let offset: u32 = 1 if returnParam else 0;
    let args = try allocVals(self, call.args.len + offset);
    for i in 0..call.args.len {
        args[i + offset] = try lowerExpr(self, call.args.list[i]);
        args[i + offset] = try lowerExpr(self, call.args[i]);
    }

    // Allocate the return buffer when needed.
    if returnParam {
        if fnInfo.throwListLen > 0 {
        if fnInfo.throwList.len > 0 {
            let successType = *fnInfo.returnType;
            let layout = resolver::getResultLayout(successType, &fnInfo.throwList[..fnInfo.throwListLen]);
            let layout = resolver::getResultLayout(successType, fnInfo.throwList);

            args[0] = il::Val::Reg(try emitReserveLayout(self, layout));
        } else {
            args[0] = il::Val::Reg(try emitReserve(self, retTy));
        }

lib/std/lang/parser.rad +48 -50

    previous: scanner::Token,
    /// Collection of errors encountered during parsing.
    errors: ErrorList,
    /// Arena for all node allocations.
    arena: *mut ast::NodeArena,
    /// 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 and node arena.

        scanner: scanner::scanner("", source, pool),
        current: scanner::invalid(0, ""),
        previous: scanner::invalid(0, ""),
        errors: ErrorList { list: undefined, count: 0 },
        arena,
        allocator: ast::nodeAllocator(arena),
        context: Context::Normal,
    };
}

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

fn parseArrayLiteral(p: *mut Parser) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LBracket, "expected `[`");
    if consume(p, scanner::TokenKind::RBracket) { // Empty array: `[]`.
        return node(p, ast::NodeValue::ArrayLit(ast::nodeList(p.arena, 0)));
        let empty: *mut [*ast::Node] = &mut [];
        return node(p, ast::NodeValue::ArrayLit(empty));
    }
    let firstExpr = try parseExpr(p);

    if consume(p, scanner::TokenKind::Semicolon) {
        // Array repeat literal: `[item; count]`.

        return node(p, ast::NodeValue::ArrayRepeatLit(
            ast::ArrayRepeatLit { item: firstExpr, count }
        ));
    }
    // Regular array literal: `[a, b, ...]`.
    let mut items = ast::nodeList(p.arena, 64);
    ast::nodeListPush(&mut items, firstExpr);
    let mut items = ast::nodeSlice(p.arena, 64);
    items.append(firstExpr, p.allocator);

    while consume(p, scanner::TokenKind::Comma) and not check(p, scanner::TokenKind::RBracket) {
        let elem = try parseExpr(p);
        ast::nodeListPush(&mut items, elem);
        items.append(elem, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBracket, "expected `]` after array elements");

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

    }
    try expect(p, scanner::TokenKind::LParen, "expected `(` after builtin name");

    // Parse arguments into a list. Use capacity 4 to handle any valid argument count
    // plus some extra for error recovery.
    let mut args = ast::nodeList(p.arena, 4);
    let mut args = ast::nodeSlice(p.arena, 4);

    if kind == ast::Builtin::SliceOf {
        // Parse comma-separated expressions until closing paren.
        // Argument count validation is done in semantic analysis.
        if p.current.kind != scanner::TokenKind::RParen {
            ast::nodeListPush(&mut args, try parseExpr(p));
            args.append(try parseExpr(p), p.allocator);
            while p.current.kind == scanner::TokenKind::Comma {
                advance(p);
                ast::nodeListPush(&mut args, try parseExpr(p));
                args.append(try parseExpr(p), p.allocator);
            }
        }
    } else {
        ast::nodeListPush(&mut args, try parseType(p));
        args.append(try parseType(p), p.allocator);
    }
    try expect(p, scanner::TokenKind::RParen, "expected `)` after builtin argument");

    return node(p, ast::NodeValue::BuiltinCall { kind, args });
}

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

/// Parse leading attributes attached to the next declaration statement.
fn parseAttributes(p: *mut Parser) -> ?ast::Attributes {
    let mut attrs = ast::nodeList(p.arena, 4);
    let mut attrs = ast::nodeSlice(p.arena, 4);

    if let attr = tryParseAnnotation(p) {
        ast::nodeListPush(&mut attrs, attr);
        attrs.append(attr, p.allocator);
    }
    if consume(p, scanner::TokenKind::Pub) {
        let attrNode = nodeAttribute(p, ast::Attribute::Pub);
        ast::nodeListPush(&mut attrs, attrNode);
        attrs.append(attrNode, p.allocator);
    }
    if consume(p, scanner::TokenKind::Extern) {
        let attrNode = nodeAttribute(p, ast::Attribute::Extern);
        ast::nodeListPush(&mut attrs, attrNode);
        attrs.append(attrNode, p.allocator);
    }
    if attrs.len > 0 {
        return ast::Attributes { list: attrs };
    }
    return nil;

pub fn parseStmtsUntil(p: *mut Parser, end: scanner::TokenKind, blk: *mut ast::Block)
    throws (ParseError)
{
    while not check(p, end) {
        let stmt = try parseStmt(p);
        ast::nodeListPush(&mut blk.statements, stmt);
        blk.statements.append(stmt, p.allocator);

        if check(p, end) or check(p, scanner::TokenKind::Eof) {
            break;
        }
        if not consume(p, scanner::TokenKind::Semicolon) {

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

/// Create an empty block with no statements.
fn mkBlock(p: *mut Parser, cap: u32) -> ast::Block {
    return ast::Block { statements: ast::nodeList(p.arena, cap) };
    return ast::Block { statements: ast::nodeSlice(p.arena, cap) };
}

/// Create a block containing a single statement node.
fn mkBlockWith(p: *mut Parser, node: *ast::Node) -> ast::Block {
    let mut stmts = ast::nodeList(p.arena, 1);
    ast::nodeListPush(&mut stmts, node);
    let mut stmts = ast::nodeSlice(p.arena, 1);
    stmts.append(node, p.allocator);

    return ast::Block { statements: stmts };
}

/// Parse the branch that follows `else` in let-else style constructs.

    try expect(p, scanner::TokenKind::Try, "expected `try`");

    let shouldPanic = consume(p, scanner::TokenKind::Bang);
    let returnsOptional = consume(p, scanner::TokenKind::Question);
    let expr = try parsePrimary(p);
    let mut catches = ast::nodeList(p.arena, 4);
    let mut catches = ast::nodeSlice(p.arena, 4);

    while consume(p, scanner::TokenKind::Catch) {
        let mut binding: ?*ast::Node = nil;
        let mut typeNode: ?*ast::Node = nil;


        }
        let body = try parseBlock(p);
        let clause = node(p, ast::NodeValue::CatchClause(
            ast::CatchClause { binding, typeNode, body }
        ));
        ast::nodeListPush(&mut catches, clause);
        catches.append(clause, p.allocator);
    }
    return node(p, ast::NodeValue::Try(
        ast::Try { expr, catches, shouldPanic, returnsOptional }
    ));
}

    try expect(p, scanner::TokenKind::Match, "expected `match`");

    let subject = try parseCond(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` before match prongs");

    let mut prongs = ast::nodeList(p.arena, 128);
    let mut prongs = ast::nodeSlice(p.arena, 128);
    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof) // TODO: We shouldn't have to manually check for EOF.
    {
        let prongNode = try parseMatchProng(p);
        ast::nodeListPush(&mut prongs, prongNode);
        prongs.append(prongNode, p.allocator);
        consume(p, scanner::TokenKind::Comma);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after match prongs");

    return node(p, ast::NodeValue::Match(

{
    let mut guard: ?*ast::Node = nil;

    // Case prong: `case <pattern>, ... if <guard> => <body>`.
    if consume(p, scanner::TokenKind::Case) {
        let mut patterns = ast::nodeList(p.arena, 16);
        let mut patterns = ast::nodeSlice(p.arena, 16);
        loop {
            let pattern = try parseMatchPattern(p);
            ast::nodeListPush(&mut patterns, pattern);
            patterns.append(pattern, p.allocator);

            if not consume(p, scanner::TokenKind::Comma) {
                break;
            }
        }

/// For labeled fields: `{ name: T, ... }`.
/// For unlabeled fields: `(T, T, ...)`.
fn parseRecordFields(
    p: *mut Parser,
    mode: RecordFieldMode
) -> ast::NodeList
) -> *mut [*ast::Node]
    throws (ParseError)
{
    let terminator = scanner::TokenKind::RBrace if mode == RecordFieldMode::Labeled
        else scanner::TokenKind::RParen;
    let mut fields = ast::nodeList(p.arena, MAX_RECORD_FIELDS);
    let mut fields = ast::nodeSlice(p.arena, MAX_RECORD_FIELDS);
    while not check(p, terminator) {
        let mut recordField: ast::NodeValue = undefined;
        match mode {
            case RecordFieldMode::Labeled => {
                // Allow optional `let` keyword before field name.

                recordField = ast::NodeValue::RecordField {
                    field: nil, type, value: nil,
                };
            }
        }
        ast::nodeListPush(&mut fields, node(p, recordField));
        fields.append(node(p, recordField), p.allocator);

        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }


    return fields;
}

/// Parse an optional derives list (`: Trait + Trait`).
fn parseDerives(p: *mut Parser) -> ast::NodeList throws (ParseError) {
    let mut derives = ast::nodeList(p.arena, 4);
fn parseDerives(p: *mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    let mut derives = ast::nodeSlice(p.arena, 4);

    if not consume(p, scanner::TokenKind::Colon) {
        return derives;
    }
    loop {
        let t = try parseIdent(p, "expected trait name in derive list");
        ast::nodeListPush(&mut derives, t);
        derives.append(t, p.allocator);

        if not consume(p, scanner::TokenKind::Plus) {
            break;
        }
    }

/// Eg. `{ x: 1, y: 2 }`
/// Eg. `{ x: 1, .. }`
fn parseRecordLit(p: *mut Parser, typeName: ?*ast::Node) -> *ast::Node
    throws (ParseError)
{
    let mut fields = ast::nodeList(p.arena, MAX_RECORD_FIELDS);
    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");

    while not check(p, scanner::TokenKind::RBrace) {
        // Check for `..` to ignore remaining fields.
        if consume(p, scanner::TokenKind::DotDot) {
            ignoreRest = true;
            break;
        }
        let field = try parseRecordLitField(p);
        ast::nodeListPush(&mut fields, field);
        fields.append(field, p.allocator);

        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }

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

    try expect(p, scanner::TokenKind::LBrace, "expected `{` before union body");

    let mut variants = ast::nodeList(p.arena, 128);
    let mut variants = ast::nodeSlice(p.arena, 128);
    while not check(p, scanner::TokenKind::RBrace) {
        // Allow optional `case` keyword before variant name.
        consume(p, scanner::TokenKind::Case);

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

            explicitValue = nodeNumber(p, literal);
        }

        let variant = node(p, ast::NodeValue::UnionDeclVariant(
            ast::UnionDeclVariant {
                name: variantName, index: variants.len, value: explicitValue, type: payloadType,
                name: variantName, index: variants.len as u32, value: explicitValue, type: payloadType,
            }
        ));
        ast::nodeListPush(&mut variants, variant);
        variants.append(variant, p.allocator);

        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }

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

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

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

    if not check(p, scanner::TokenKind::RParen) {
        loop {
            let param = try parseFnParam(p);
            if params.len >= params.list.len {
                throw failParsing(p, "too many function parameters");
            }
            ast::nodeListPush(&mut params, param);
            params.append(param, p.allocator);

            if not consume(p, scanner::TokenKind::Comma) {
                break;
            }
        }

    try expect(p, scanner::TokenKind::Trait, "expected `trait`");
    let name = try parseIdent(p, "expected trait name");
    let supertraits = try parseDerives(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` after trait name");

    let mut methods = ast::nodeList(p.arena, ast::MAX_TRAIT_METHODS);
    let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);
    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof)
    {
        let method = try parseTraitMethodSig(p);
        ast::nodeListPush(&mut methods, method);
        methods.append(method, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after trait methods");

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

    let traitName = try parseTypePath(p);
    try expect(p, scanner::TokenKind::For, "expected `for` after trait name");
    let targetType = try parseTypePath(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` after target type");

    let mut methods = ast::nodeList(p.arena, ast::MAX_TRAIT_METHODS);
    let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);
    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof)
    {
        let method = try parseInstanceMethodDecl(p);
        ast::nodeListPush(&mut methods, method);
        methods.append(method, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after instance methods");

    return node(p, ast::NodeValue::InstanceDecl { traitName, targetType, methods });
}

fn parseList(
    p: *mut Parser,
    open: scanner::TokenKind,
    close: scanner::TokenKind,
    parseItem: fn (*mut Parser) -> *ast::Node throws (ParseError)
) -> ast::NodeList throws (ParseError) {
) -> *mut [*ast::Node] throws (ParseError) {
    try expect(p, open, listExpectMessage(open));
    let mut items = ast::nodeList(p.arena, 8);
    let mut items = ast::nodeSlice(p.arena, 8);

    while not check(p, close) {
        let item = try parseItem(p);
        if items.len >= items.list.len {
            throw failParsing(p, "too many items in list");
        }
        ast::nodeListPush(&mut items, item);
        items.append(item, p.allocator);

        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }

lib/std/lang/parser/tests.rad +81 -84

    try testing::expect(width == expectedWidth);
    try testing::expect(sign == expectedSign);
}

/// Extract a union variant and verify its name and index.
/// Returns the payload's fields NodeList for further checking with `expectField`.
fn expectVariant(varNode: *ast::Node, name: *[u8], index: u32) -> *ast::NodeList
/// Returns the payload's fields slice for further checking with `expectField`.
fn expectVariant(varNode: *ast::Node, name: *[u8], index: u32) -> *mut [*ast::Node]
    throws (testing::TestError)
{
    let case ast::NodeValue::UnionDeclVariant(v) = varNode.value
        else throw testing::TestError::Failed;
    try expectIdent(v.name, name);

    let case ast::NodeValue::TypeSig(sig) = payloadType.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Record { fields, .. } = sig
        else throw testing::TestError::Failed;

    return &fields;
    return fields;
}

/// Check a record field has the expected name and type signature.
fn expectFieldSig(
    fields: *ast::NodeList, index: u32, name: ?*[u8], sig: ast::TypeSig
    fields: *mut [*ast::Node], index: u32, name: ?*[u8], sig: ast::TypeSig
) throws (testing::TestError) {
    let fieldNode = fields.list[index];
    let fieldNode = fields[index];
    let case ast::NodeValue::RecordField { field, type: fieldType, .. } = fieldNode.value
        else throw testing::TestError::Failed;

    if let expectedName = name {
        let actualName = field else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;

    if block.statements.len == 0 {
        throw testing::TestError::Failed;
    }
    return block.statements.list[0];
    return block.statements[0];
}

/// Get the last statement from a block node.
pub fn getBlockLastStmt(blk: *ast::Node) -> *ast::Node
    throws (testing::TestError)

        else throw testing::TestError::Failed;

    if block.statements.len == 0 {
        throw testing::TestError::Failed;
    }
    return block.statements.list[block.statements.len - 1];
    return block.statements[block.statements.len - 1];
}

/// Test parsing boolean literals (`true` and `false`).
@test fn testParseBool() throws (testing::TestError) {
    let r1 = try! parseExprStr("true");

    let root = try! parseStmtStr("{ first; second; third }");
    let case ast::NodeValue::Block(body) = root.value
        else throw testing::TestError::Failed;
    try testing::expect(body.statements.len == 3);

    let firstStmt = body.statements.list[0];
    let firstStmt = body.statements[0];
    let case ast::NodeValue::ExprStmt(firstExpr) = firstStmt.value
        else throw testing::TestError::Failed;
    try expectIdent(firstExpr, "first");

    let secondStmt = body.statements.list[1];
    let secondStmt = body.statements[1];
    let case ast::NodeValue::ExprStmt(secondExpr) = secondStmt.value
        else throw testing::TestError::Failed;
    try expectIdent(secondExpr, "second");

    let thirdStmt = body.statements.list[2];
    let thirdStmt = body.statements[2];
    let case ast::NodeValue::ExprStmt(thirdExpr) = thirdStmt.value
        else throw testing::TestError::Failed;
    try expectIdent(thirdExpr, "third");
}



    let case ast::NodeValue::Block(body) = node.thenBranch.value
        else throw testing::TestError::Failed;
    try testing::expect(body.statements.len == 1);

    let stmt = body.statements.list[0];
    let stmt = body.statements[0];
    let case ast::NodeValue::ExprStmt(expr) = stmt.value
        else throw testing::TestError::Failed;
    try expectIdent(expr, "only");
}



    try expectIdent(decl.name, "io");
    let attrs = decl.attrs
        else throw testing::TestError::Failed;

    try testing::expect(ast::attributesLen(&attrs) == 1);
    try testing::expect(attrs.list.len == 1);

    let attr_node = ast::attributesGet(&attrs, 0);
    let case ast::NodeValue::Attribute(attr) = attr_node.value
    let case ast::NodeValue::Attribute(attr) = attrs.list[0].value
        else throw testing::TestError::Failed;

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


    try expectIdent(decl.name, "R");
    try testing::expect(decl.derives.len == 0);
    try testing::expect(decl.fields.len == 2);

    try expectFieldSig(&decl.fields, 0, "x", ast::TypeSig::Void);
    try expectFieldSig(&decl.fields, 1, "y", ast::TypeSig::Bool);
    try expectFieldSig(decl.fields, 0, "x", ast::TypeSig::Void);
    try expectFieldSig(decl.fields, 1, "y", ast::TypeSig::Bool);
}

/// Test parsing a record declaration with derives.
@test fn testParseRecordDeclDerives() throws (testing::TestError) {
    let node = try! parseStmtStr("record R: Eq + Debug { field: i32 }");
    let case ast::NodeValue::RecordDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "R");
    try testing::expect(decl.derives.len == 2);
    try expectIdent(decl.derives.list[0], "Eq");
    try expectIdent(decl.derives.list[1], "Debug");
    try expectIdent(decl.derives[0], "Eq");
    try expectIdent(decl.derives[1], "Debug");
}

/// Test parsing a record declaration with field initializers.
@test fn testParseRecordDeclFieldDefaults() throws (testing::TestError) {
    let node = try! parseStmtStr("record Config { size: opaque = 42, flag: bool = true }");


    try expectIdent(decl.name, "Config");
    try testing::expect(decl.derives.len == 0);
    try testing::expect(decl.fields.len == 2);

    try expectFieldSig(&decl.fields, 0, "size", ast::TypeSig::Opaque);
    try expectFieldSig(&decl.fields, 1, "flag", ast::TypeSig::Bool);
    try expectFieldSig(decl.fields, 0, "size", ast::TypeSig::Opaque);
    try expectFieldSig(decl.fields, 1, "flag", ast::TypeSig::Bool);

    // Check default values.
    let case ast::NodeValue::RecordField { value: val0, .. } = decl.fields.list[0].value
    let case ast::NodeValue::RecordField { value: val0, .. } = decl.fields[0].value
        else throw testing::TestError::Failed;
    let v0 = val0 else throw testing::TestError::Failed;
    try expectNumber(v0, "42");

    let case ast::NodeValue::RecordField { value: val1, .. } = decl.fields.list[1].value
    let case ast::NodeValue::RecordField { value: val1, .. } = decl.fields[1].value
        else throw testing::TestError::Failed;
    let v1 = val1 else throw testing::TestError::Failed;
    let case ast::NodeValue::Bool(flagValue) = v1.value
        else throw testing::TestError::Failed;
    try testing::expect(flagValue);

    try expectIdent(decl.name, "Pair");
    try testing::expect(not decl.labeled);
    try testing::expect(decl.derives.len == 0);
    try testing::expect(decl.fields.len == 2);

    try expectFieldSig(&decl.fields, 0, nil, ast::TypeSig::Void);
    try expectFieldSig(&decl.fields, 1, nil, ast::TypeSig::Bool);
    try expectFieldSig(decl.fields, 0, nil, ast::TypeSig::Void);
    try expectFieldSig(decl.fields, 1, nil, ast::TypeSig::Bool);
}

/// Test parsing a single-field unlabeled record.
@test fn testParseTupleRecordSingleField() throws (testing::TestError) {
    let node = try! parseStmtStr("record R(bool);");


    try expectIdent(decl.name, "R");
    try testing::expect(not decl.labeled);
    try testing::expect(decl.fields.len == 1);

    try expectFieldSig(&decl.fields, 0, nil, ast::TypeSig::Bool);
    try expectFieldSig(decl.fields, 0, nil, ast::TypeSig::Bool);
}

/// Test parsing empty record literals.
@test fn testParseEmptyRecordLiteral() throws (testing::TestError) {
    let r1 = try! parseExprStr("{}");

    let case ast::TypeSig::Fn(sig) = sigValue
        else throw testing::TestError::Failed;

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

    let param0 = sig.params.list[0];
    let param0 = sig.params[0];
    try expectIntType(param0, 4, ast::Signedness::Signed);

    let param1 = sig.params.list[1];
    let param1 = sig.params[1];
    let case ast::NodeValue::TypeSig(p1) = param1.value
        else throw testing::TestError::Failed;
    let case ast::TypeSig::Pointer { valueType: ptrTarget, mutable: _ } = p1
        else throw testing::TestError::Failed;
    try expectIntType(ptrTarget, 1, ast::Signedness::Unsigned);

        else throw testing::TestError::Failed;
    let case ast::TypeSig::Fn(sig) = sigValue
        else throw testing::TestError::Failed;

    try testing::expect(sig.params.len == 1);
    try expectIntType(sig.params.list[0], 4, ast::Signedness::Signed);
    try expectIntType(sig.params[0], 4, ast::Signedness::Signed);

    try testing::expect(sig.throwList.len == 2);
    try expectTypeIdent(sig.throwList.list[0], "Error");
    try expectTypeIdent(sig.throwList.list[1], "Other");
    try expectTypeIdent(sig.throwList[0], "Error");
    try expectTypeIdent(sig.throwList[1], "Other");

    let returnType = sig.returnType
        else throw testing::TestError::Failed;
    try expectType(returnType, ast::TypeSig::Bool);
}


    try expectIdent(decl.name, "add");
    try testing::expect(decl.sig.params.len == 2);

    {
        let param0 = decl.sig.params.list[0];
        let param0 = decl.sig.params[0];
        let case ast::NodeValue::FnParam(p0) = param0.value
            else throw testing::TestError::Failed;
        try expectIdent(p0.name, "x");
        try expectIntType(p0.type, 4, ast::Signedness::Signed);
    }
    {
        let param1 = decl.sig.params.list[1];
        let param1 = decl.sig.params[1];
        let case ast::NodeValue::FnParam(p1) = param1.value
            else throw testing::TestError::Failed;
        try expectIdent(p1.name, "y");
        let case ast::NodeValue::TypeSig(sig1) = p1.type.value
            else throw testing::TestError::Failed;

    let returnType = decl.sig.returnType
        else throw testing::TestError::Failed;
    try expectType(returnType, ast::TypeSig::Void);

    try testing::expect(decl.sig.throwList.len == 2);
    try expectTypeIdent(decl.sig.throwList.list[0], "Error");
    try expectTypeIdent(decl.sig.throwList.list[1], "Crash");
    try expectTypeIdent(decl.sig.throwList[0], "Error");
    try expectTypeIdent(decl.sig.throwList[1], "Crash");

    let body = decl.body else throw testing::TestError::Failed;
    let case ast::NodeValue::Block(_) = body.value
        else throw testing::TestError::Failed;
}

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

    let attrs = decl.attrs
        else throw testing::TestError::Failed;

    try testing::expect(ast::attributesLen(&attrs) == 2);
    try testing::expect(attrs.list.len == 2);

    let first = ast::attributesGet(&attrs, 0);
    let case ast::NodeValue::Attribute(attr0) = first.value
    let case ast::NodeValue::Attribute(attr0) = attrs.list[0].value
        else throw testing::TestError::Failed;
    try testing::expect(attr0 == ast::Attribute::Pub);

    let second = ast::attributesGet(&attrs, 1);
    let case ast::NodeValue::Attribute(attr1) = second.value
    let case ast::NodeValue::Attribute(attr1) = attrs.list[1].value
        else throw testing::TestError::Failed;
    try testing::expect(attr1 == ast::Attribute::Extern);

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

        else throw testing::TestError::Failed;

    try expectIdent(node.expr, "value");
    try testing::expect(node.catches.len == 1);

    let case ast::NodeValue::CatchClause(clause) = node.catches.list[0].value
    let case ast::NodeValue::CatchClause(clause) = node.catches[0].value
        else throw testing::TestError::Failed;
    try testing::expect(clause.binding == nil);
    try testing::expect(clause.typeNode == nil);
    try expectBlockExprStmt(clause.body, ast::NodeValue::Ident("alt"));
}

        else throw testing::TestError::Failed;

    try expectIdent(sw.subject, "subject");
    try testing::expect(sw.prongs.len == 1);

    let caseNode = sw.prongs.list[0];
    let caseNode = sw.prongs[0];
    let case ast::NodeValue::MatchProng(prong) = caseNode.value
        else throw testing::TestError::Failed;

    let case ast::ProngArm::Case(patterns) = prong.arm
        else throw testing::TestError::Failed;
    try testing::expect(patterns.len == 1);
    try expectIdent(patterns.list[0], "pattern");
    try expectIdent(patterns[0], "pattern");
    try testing::expect(prong.guard == nil);

    let case ast::NodeValue::ExprStmt(bodyStmt) = prong.body.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Ident(name) = bodyStmt.value

    );
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs.list[0].value
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;

    let case ast::ProngArm::Case(patterns) = prong.arm
        else throw testing::TestError::Failed;
    try testing::expect(patterns.len == 2);
    try expectIdent(patterns.list[0], "left");
    try expectIdent(patterns.list[1], "right");
    try expectIdent(patterns[0], "left");
    try expectIdent(patterns[1], "right");

    let guard = prong.guard
        else throw testing::TestError::Failed;
    try expectIdent(guard, "cond");
}

    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 2);

    let firstCaseNode = sw.prongs.list[0];
    let firstCaseNode = sw.prongs[0];
    let case ast::NodeValue::MatchProng(firstProng) = firstCaseNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Return(firstRetVal) = firstProng.body.value
        else throw testing::TestError::Failed;
    try testing::expect(firstRetVal == nil);

    let secondCaseNode = sw.prongs.list[1];
    let secondCaseNode = sw.prongs[1];
    let case ast::NodeValue::MatchProng(secondProng) = secondCaseNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Return(secondRetVal) = secondProng.body.value
        else throw testing::TestError::Failed;
    try testing::expect(secondRetVal == nil);

    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 2);
    {
        let case ast::NodeValue::MatchProng(prong) = sw.prongs.list[0].value
        let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
            else throw testing::TestError::Failed;
        let case ast::ProngArm::Case(patterns) = prong.arm
            else throw testing::TestError::Failed;
        try testing::expect(patterns.len == 1);
        try expectIdent(patterns.list[0], "First");
        try expectIdent(patterns[0], "First");
        let case ast::NodeValue::ExprStmt(stmt) = prong.body.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Ident(val) = stmt.value
            if mem::eq(val, "first")
            else throw testing::TestError::Failed;
    } {
        let case ast::NodeValue::MatchProng(prong) = sw.prongs.list[1].value
        let case ast::NodeValue::MatchProng(prong) = sw.prongs[1].value
            else throw testing::TestError::Failed;
        let case ast::ProngArm::Case(pats) = prong.arm
            else throw testing::TestError::Failed;

        try testing::expect(pats.len == 1);
        try expectIdent(pats.list[0], "Second");
        try expectIdent(pats[0], "Second");

        let case ast::NodeValue::ExprStmt(stmt) = prong.body.value
            else throw testing::TestError::Failed;
        let case ast::NodeValue::Ident(val) = stmt.value
            if mem::eq(val, "second")

    let root = try! parseStmtStr("match subject { case Pattern => { body; } }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs.list[0].value
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    try expectBlockExprStmt(prong.body, ast::NodeValue::Ident("body"));
}

/// Test parsing a `match` statement with an `else` case.

    let root = try! parseStmtStr("match subject { else => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs.list[0].value
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    // Else prong has no pattern.
    let case ast::ProngArm::Else = prong.arm
        else throw testing::TestError::Failed;
    try testing::expect(prong.guard == nil);

    let root = try! parseStmtStr("match subject { x => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs.list[0].value
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    // Binding prong has single identifier pattern.
    let case ast::ProngArm::Binding(pat) = prong.arm
        else throw testing::TestError::Failed;
    try expectIdent(pat, "x");

    let root = try! parseStmtStr("match subject { x if x > 0 => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs.list[0].value
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    // Binding prong has single identifier pattern.
    let case ast::ProngArm::Binding(pat) = prong.arm
        else throw testing::TestError::Failed;
    try expectIdent(pat, "x");

    let root = try! parseStmtStr("match subject { _ => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs.list[0].value
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    // Wildcard binding prong has single placeholder pattern.
    let case ast::ProngArm::Binding(pat) = prong.arm
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Placeholder = pat.value

    let root = try! parseStmtStr("match subject { _ if cond => body }");
    let case ast::NodeValue::Match(sw) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(sw.prongs.len == 1);
    let case ast::NodeValue::MatchProng(prong) = sw.prongs.list[0].value
    let case ast::NodeValue::MatchProng(prong) = sw.prongs[0].value
        else throw testing::TestError::Failed;
    // Guarded wildcard binding prong has single placeholder pattern.
    let case ast::ProngArm::Binding(pat) = prong.arm
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Placeholder = pat.value

    let case ast::NodeValue::Call(call) = root.value
        else throw testing::TestError::Failed;

    try expectIdent(call.callee, "func");
    try testing::expect(call.args.len == 2);
    try expectIdent(call.args.list[0], "x");
    try expectIdent(call.args.list[1], "y");
    try expectIdent(call.args[0], "x");
    try expectIdent(call.args[1], "y");
}

/// Test parsing chained postfix operators.
@test fn testParseChainedPostfix() throws (testing::TestError) {
    let root = try! parseExprStr("obj.method(arg)[0]");

        else throw testing::TestError::Failed;

    try expectIdent(fieldAccess.parent, "obj");
    try expectIdent(fieldAccess.child, "method");
    try testing::expect(call.args.len == 1);
    try expectIdent(call.args.list[0], "arg");
    try expectIdent(call.args[0], "arg");
}

/// Test parsing a literal cast using `as`.
@test fn testParseAsCastLiteral() throws (testing::TestError) {
    let root = try! parseExprStr("1 as i32");

        else throw testing::TestError::Failed;

    try expectIdent(access.parent, "value");
    try expectIdent(access.child, "method");
    try testing::expect(call.args.len == 1);
    try expectIdent(call.args.list[0], "arg");
    try expectIdent(call.args[0], "arg");
    try expectIntType(asExpr.type, 4, ast::Signedness::Unsigned);
}

/// Test parsing @sizeOf builtin.
@test fn testParseBuiltinSizeOf() throws (testing::TestError) {

    let case ast::NodeValue::BuiltinCall { kind: builtinKind, args: builtinArgs } = expr.value
        else throw testing::TestError::Failed;

    try testing::expect(builtinKind == ast::Builtin::SizeOf);
    try testing::expect(builtinArgs.len == 1);
    try expectType(builtinArgs.list[0], ast::TypeSig::Integer {
    try expectType(builtinArgs[0], ast::TypeSig::Integer {
        width: 4,
        sign: ast::Signedness::Signed,
    });
}


    let case ast::NodeValue::BuiltinCall { kind: builtinKind, args: builtinArgs } = expr.value
        else throw testing::TestError::Failed;

    try testing::expect(builtinKind == ast::Builtin::AlignOf);
    try testing::expect(builtinArgs.len == 1);
    try expectType(builtinArgs.list[0], ast::TypeSig::Integer {
    try expectType(builtinArgs[0], ast::TypeSig::Integer {
        width: 4,
        sign: ast::Signedness::Signed,
    });
}


    try testing::expect(decl.derives.len == 0);

    let variants = decl.variants;
    try testing::expect(variants.len == 3);

    let v0 = variants.list[0];
    let v0 = variants[0];
    let case ast::NodeValue::UnionDeclVariant(var0) = v0.value
        else throw testing::TestError::Failed;
    try expectIdent(var0.name, "Red");
    try testing::expect(var0.index == 0);
    try testing::expect(var0.type == nil);
    try testing::expect(var0.value == nil);

    let v1 = variants.list[1];
    let v1 = variants[1];
    let case ast::NodeValue::UnionDeclVariant(var1) = v1.value
        else throw testing::TestError::Failed;
    try expectIdent(var1.name, "Green");
    try testing::expect(var1.index == 1);
    try testing::expect(var1.type == nil);
    try testing::expect(var1.value == nil);

    let v2 = variants.list[2];
    let v2 = variants[2];
    let case ast::NodeValue::UnionDeclVariant(var2) = v2.value
        else throw testing::TestError::Failed;
    try expectIdent(var2.name, "Blue");
    try testing::expect(var2.index == 2);
    try testing::expect(var2.type == nil);

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

    let variants = decl.variants;
    try testing::expect(variants.len == 3);

    let v0 = variants.list[0];
    let v0 = variants[0];
    let case ast::NodeValue::UnionDeclVariant(var0) = v0.value
        else throw testing::TestError::Failed;
    try expectIdent(var0.name, "Ok");
    try testing::expect(var0.index == 0);
    try testing::expect(var0.type == nil);
    try testing::expect(var0.value != nil);

    let v1 = variants.list[1];
    let v1 = variants[1];
    let case ast::NodeValue::UnionDeclVariant(var1) = v1.value
        else throw testing::TestError::Failed;
    try expectIdent(var1.name, "Error");
    try testing::expect(var1.index == 1);
    try testing::expect(var1.value != nil);

    let v2 = variants.list[2];
    let v2 = variants[2];
    let case ast::NodeValue::UnionDeclVariant(var2) = v2.value
        else throw testing::TestError::Failed;
    try expectIdent(var2.name, "Pending");
    try testing::expect(var2.index == 2);
    try testing::expect(var2.value != nil);

        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Result");
    try testing::expect(decl.variants.len == 2);

    let okFields = try expectVariant(decl.variants.list[0], "Ok", 0);
    let okFields = try expectVariant(decl.variants[0], "Ok", 0);
    try testing::expect(okFields.len == 1);
    try expectFieldSig(okFields, 0, nil, ast::TypeSig::Bool);

    let errFields = try expectVariant(decl.variants.list[1], "Error", 1);
    let errFields = try expectVariant(decl.variants[1], "Error", 1);
    try testing::expect(errFields.len == 1);
    try expectFieldSig(errFields, 0, nil, ast::TypeSig::Void);
}

/// Test parsing a union with derives.

    let case ast::NodeValue::UnionDecl(decl) = node.value
        else throw testing::TestError::Failed;

    try expectIdent(decl.name, "Option");
    try testing::expect(decl.derives.len == 2);
    try expectIdent(decl.derives.list[0], "Debug");
    try expectIdent(decl.derives.list[1], "Eq");
    try expectIdent(decl.derives[0], "Debug");
    try expectIdent(decl.derives[1], "Eq");

    let variants = decl.variants;
    try testing::expect(variants.len == 2);

    let v0 = variants.list[0];
    let v0 = variants[0];
    let case ast::NodeValue::UnionDeclVariant(var0) = v0.value
        else throw testing::TestError::Failed;
    try expectIdent(var0.name, "None");
    try testing::expect(var0.type == nil);

    let v1 = variants.list[1];
    let v1 = variants[1];
    let case ast::NodeValue::UnionDeclVariant(var1) = v1.value
        else throw testing::TestError::Failed;
    try expectIdent(var1.name, "Some");
    try testing::expect(var1.type != nil);
}


    let typeName = lit.typeName else throw testing::TestError::Failed;
    try expectIdent(typeName, "Point");
    try testing::expect(lit.fields.len == 2);

    let field0 = lit.fields.list[0];
    let field0 = lit.fields[0];
    let case ast::NodeValue::RecordLitField(arg0) = field0.value
        else throw testing::TestError::Failed;
    let label0 = arg0.label else throw testing::TestError::Failed;
    try expectIdent(label0, "x");
    try expectNumber(arg0.value, "5");

        else throw testing::TestError::Failed;

    try testing::expect(lit.typeName == nil);
    try testing::expect(lit.fields.len == 2);

    let field0 = lit.fields.list[0];
    let field0 = lit.fields[0];
    let case ast::NodeValue::RecordLitField(arg0) = field0.value
        else throw testing::TestError::Failed;
    let label0 = arg0.label else throw testing::TestError::Failed;
    try expectIdent(label0, "x");
    try expectNumber(arg0.value, "10");

    let field1 = lit.fields.list[1];
    let field1 = lit.fields[1];
    let case ast::NodeValue::RecordLitField(arg1) = field1.value
        else throw testing::TestError::Failed;
    let label1 = arg1.label else throw testing::TestError::Failed;
    try expectIdent(label1, "y");
    try expectNumber(arg1.value, "20");

    let typeName = lit.typeName else throw testing::TestError::Failed;
    try expectIdent(typeName, "Point");
    try testing::expect(lit.fields.len == 2);

    // First field: shorthand `x`.
    let field0 = lit.fields.list[0];
    let field0 = lit.fields[0];
    let case ast::NodeValue::RecordLitField(arg0) = field0.value
        else throw testing::TestError::Failed;
    let label0 = arg0.label else throw testing::TestError::Failed;
    try expectIdent(label0, "x");
    try expectIdent(arg0.value, "x");
    // Label and value should point to the same node.
    try testing::expect(label0 == arg0.value);

    // Second field: shorthand `y`.
    let field1 = lit.fields.list[1];
    let field1 = lit.fields[1];
    let case ast::NodeValue::RecordLitField(arg1) = field1.value
        else throw testing::TestError::Failed;
    let label1 = arg1.label else throw testing::TestError::Failed;
    try expectIdent(label1, "y");
    try expectIdent(arg1.value, "y");

        else throw testing::TestError::Failed;

    try testing::expect(lit.fields.len == 2);

    // First field: shorthand `x`.
    let field0 = lit.fields.list[0];
    let field0 = lit.fields[0];
    let case ast::NodeValue::RecordLitField(arg0) = field0.value
        else throw testing::TestError::Failed;
    let label0 = arg0.label else throw testing::TestError::Failed;
    try expectIdent(label0, "x");
    try expectIdent(arg0.value, "x");

    // Second field: explicit `y: 10`.
    let field1 = lit.fields.list[1];
    let field1 = lit.fields[1];
    let case ast::NodeValue::RecordLitField(arg1) = field1.value
        else throw testing::TestError::Failed;
    let label1 = arg1.label else throw testing::TestError::Failed;
    try expectIdent(label1, "y");
    try expectNumber(arg1.value, "10");


    let case ast::NodeValue::Block(module) = r.value
        else throw testing::TestError::Failed;
    try testing::expect(module.statements.len == 2);

    let first = module.statements.list[0];
    let first = module.statements[0];
    let case ast::NodeValue::FnDecl(fDecl) = first.value
        else throw testing::TestError::Failed;
    try expectIdent(fDecl.name, "f");

    let second = module.statements.list[1];
    let second = module.statements[1];
    let case ast::NodeValue::FnDecl(gDecl) = second.value
        else throw testing::TestError::Failed;
    try expectIdent(gDecl.name, "g");
}


lib/std/lang/resolver.rad +270 -346

/// Trait definition stored in the resolver.
pub record TraitType {
    /// Trait name.
    name: *[u8],
    /// Method signatures, including from supertraits.
    methods: [TraitMethod; ast::MAX_TRAIT_METHODS],
    /// Number of methods.
    methodsLen: u32,
    methods: *mut [TraitMethod],
    /// Supertraits that must also be implemented.
    supertraits: [*TraitType; ast::MAX_SUPERTRAITS],
    /// Number of supertraits.
    supertraitsLen: u32,
    supertraits: *mut [*TraitType],
}

/// A single method signature within a trait.
pub record TraitMethod {
    /// Method name.

    /// Name of the concrete type.
    concreteTypeName: *[u8],
    /// Module where this instance was declared.
    moduleId: u16,
    /// Method symbols for each trait method, in declaration order.
    methods: [*mut Symbol; ast::MAX_TRAIT_METHODS],
    /// Number of methods.
    methodsLen: u32,
    methods: *mut [*mut Symbol],
}

/// Identifier for the synthetic `len` field.
pub const LEN_FIELD: *[u8] = "len";
/// Identifier for the synthetic `ptr` field.

    length: u32,
}

/// Record nominal type.
pub record RecordType {
    fields: [RecordField; parser::MAX_RECORD_FIELDS],
    fieldsLen: u32,
    fields: *[RecordField],
    labeled: bool,
    /// Cached layout.
    layout: Layout,
}

/// Union nominal type.
pub record UnionType {
    variants: [UnionVariant; MAX_UNION_VARIANTS],
    variantsLen: u32,
    variants: *[UnionVariant],
    /// Cached layout.
    layout: Layout,
    /// Cached payload offset within the union aggregate.
    valOffset: u32,
    /// If all variants have void payloads.

    },
}

/// Resolved function signature details.
pub record FnType {
    paramTypes: [*Type; MAX_FN_PARAMS],
    paramTypesLen: u32,
    paramTypes: *[*Type],
    returnType: *Type,
    throwList: [*Type; MAX_FN_THROWS],
    throwListLen: u32,
    throwList: *[*Type],
    localCount: u32,
}

/// Describes a type computed during semantic analysis.
pub union Type {

    MissingSupertraitInstance(*[u8]),
    /// Internal error.
    Internal,
}

/// Fixed-capacity diagnostic sink.
pub record ErrorList {
    list: *mut [Error],
    listLen: u32,
}

/// Diagnostics returned by the analyzer.
pub record Diagnostics {
    errors: ErrorList,
    errors: *mut [Error],
}

/// Call context.
union CallCtx {
    /// Normal function call.

    /// Combined semantic metadata table indexed by node ID.
    nodeData: NodeDataTable,
    /// Linked list of interned types.
    types: ?*TypeNode,
    /// Diagnostics recorded so far.
    errors: ErrorList,
    errors: *mut [Error],
    /// Module graph for the current package.
    moduleGraph: *module::ModuleGraph,
    /// Cache of module scopes indexed by module ID.
    // TODO: Why is this optional?
    moduleScopes: [?*mut Scope; module::MAX_MODULES],

    *entry = info;

    return entry;
}

/// Construct an empty errors list backed by the provided buffer.
fn errorList(list: *mut [Error]) -> ErrorList {
    return ErrorList { list, listLen: 0 };
}

/// Returns an error, if any, associated with the given node.
fn errorForNode(self: *Resolver, node: *ast::Node) -> ?*Error {
    for i in 0..self.errors.listLen {
        let err = &self.errors.list[i];
    for i in 0..self.errors.len {
        let err = &self.errors[i];
        if err.node == node {
            return err;
        }
    }
    return nil;

            extra: NodeExtra::None,
        };
    }

    let mut moduleScopes: [?*mut Scope; module::MAX_MODULES] = undefined;
    // TODO: Simplify.
    for i in 0..moduleScopes.len {
        moduleScopes[i] = nil;
    }
    return Resolver {
        scope: storage.pkgScope,

        currentMod: 0,
        config,
        arena,
        nodeData: NodeDataTable { entries: storage.nodeData },
        types: nil,
        errors: errorList(storage.errors),
        errors: @sliceOf(storage.errors.ptr, 0, storage.errors.len),
        // TODO: Shouldn't be undefined.
        moduleGraph: undefined,
        moduleScopes,
        instances: undefined,
        instancesLen: 0,
    };
}

/// Return `true` if there are no errors in the diagnostics.
pub fn success(diag: *Diagnostics) -> bool {
    return diag.errors.listLen == 0;
    return diag.errors.len == 0;
}

/// Retrieve an error diagnostic by index, if present.
pub fn errorAt(errs: *ErrorList, index: u32) -> ?*Error {
    if index >= errs.listLen {
pub fn errorAt(errs: *[Error], index: u32) -> ?*Error {
    if index >= errs.len {
        return nil;
    }
    return &errs.list[index];
    return &errs[index];
}

/// Record an error diagnostic and return an error sentinel suitable for throwing.
fn emitError(self: *mut Resolver, node: ?*ast::Node, kind: ErrorKind) -> ResolveError {
    // If our error list is full, just return an error without recording it.
    if self.errors.listLen >= self.errors.list.len {
    if self.errors.len >= self.errors.cap {
        return ResolveError::Failure;
    }
    // Don't record more than one error per node.
    if let n = node; errorForNode(self, n) != nil {
        return ResolveError::Failure;
    }
    self.errors.list[self.errors.listLen] = Error { kind, node, moduleId: self.currentMod };
    self.errors.listLen += 1;
    let idx = self.errors.len;
    self.errors = @sliceOf(self.errors.ptr, idx + 1, self.errors.cap);
    self.errors[idx] = Error { kind, node, moduleId: self.currentMod };

    return ResolveError::Failure;
}

/// Like [`emitError`], but for type mismatches specifically.

        else return nil;

    if call.args.len == 0 {
        return nil;
    }
    let arg = call.args.list[0];
    let arg = call.args[0];

    if let case ast::NodeValue::Placeholder = arg.value {
        return nil;
    }
    return arg;

pub fn getResultLayout(payload: Type, throwList: *[*Type]) -> Layout {
    let payloadLayout = getTypeLayout(payload);
    let mut maxSize = payloadLayout.size;
    let mut maxAlign = payloadLayout.alignment;

    for i in 0..throwList.len {
        let errLayout = getTypeLayout(*throwList[i]);
    for errType in throwList {
        let errLayout = getTypeLayout(*errType);
        maxSize = max(maxSize, errLayout.size);
        maxAlign = max(maxAlign, errLayout.alignment);
    }
    return Layout {
        size: PTR_SIZE + maxSize,

    let tagSize: u32 = 1;
    let mut maxVarSize: u32 = 0;
    let mut maxVarAlign: u32 = 1;
    let mut isAllVoid: bool = true;

    for i in 0..variants.len {
        let payloadType = variants[i].valueType;
        if payloadType != Type::Void {
    for variant in variants {
        if variant.valueType != Type::Void {
            isAllVoid = false;
            let payloadLayout = getTypeLayout(payloadType);
            let payloadLayout = getTypeLayout(variant.valueType);
            maxVarSize = max(maxVarSize, payloadLayout.size);
            maxVarAlign = max(maxVarAlign, payloadLayout.alignment);
        }
    }
    let unionAlignment: u32 = max(1, maxVarAlign);

        self.currentMod = prevMod;
    }
}

/// Check if all elements in a node list are assignable to the target type.
fn isListAssignable(self: *mut Resolver, targetType: Type, items: *ast::NodeList) -> bool {
    for i in 0..items.len {
        let itemNode = items.list[i];
fn isListAssignable(self: *mut Resolver, targetType: Type, items: *mut [*ast::Node]) -> bool {
    for itemNode in items {
        let elemTy = typeFor(self, itemNode)
            else return false;
        if let _ = isAssignable(self, targetType, elemTy, itemNode) {
            // Do nothing.
        } else {

                        return Coercion::Identity;
                    }
                    // TODO: This won't work, because we should be setting coercions
                    // for every list item, but we don't. It's best to not have an
                    // `isAssignable` function and just have one that records coercions.
                    if isListAssignable(self, *lhs.item, &items) {
                    if isListAssignable(self, *lhs.item, items) {
                        return Coercion::Identity;
                    }
                    return nil;
                }
                case ast::NodeValue::ArrayRepeatLit(repeat) => {

    return nil;
}

/// Check if two function type descriptors are structurally equivalent.
fn fnTypeEqual(a: *FnType, b: *FnType) -> bool {
    if a.paramTypesLen != b.paramTypesLen {
    if a.paramTypes.len != b.paramTypes.len {
        return false;
    }
    if a.throwListLen != b.throwListLen {
    if a.throwList.len != b.throwList.len {
        return false;
    }
    if not typesEqual(*a.returnType, *b.returnType) {
        return false;
    }
    for i in 0..a.paramTypesLen {
    for i in 0..a.paramTypes.len {
        if not typesEqual(*a.paramTypes[i], *b.paramTypes[i]) {
            return false;
        }
    }
    for i in 0..a.throwListLen {
    for i in 0..a.throwList.len {
        if not typesEqual(*a.throwList[i], *b.throwList[i]) {
            return false;
        }
    }
    return true;

/// Get field info for a record-like type (records, slices) by field index.
pub fn getRecordField(ty: Type, index: u32) -> ?RecordField {
    match ty {
        case Type::Nominal(info) => {
            let case NominalType::Record(recInfo) = *info else return nil;
            if index >= recInfo.fieldsLen {
            if index >= recInfo.fields.len {
                return nil;
            }
            return recInfo.fields[index];
        }
        case Type::Slice { item, mutable } => {

        }
        case ast::NodeValue::Use(_) => {
            // Handled in previous pass.
        }
        case ast::NodeValue::InstanceDecl { traitName, targetType, methods } => {
            try resolveInstanceDecl(self, node, traitName, targetType, &methods);
            try resolveInstanceDecl(self, node, traitName, targetType, methods);
        }
        else => {
            // Ignore non-declaration nodes.
        }
    }

        }
        case ast::NodeValue::TraitDecl { .. } => {
            // Skip: already analyzed in declaration phase.
        }
        case ast::NodeValue::InstanceDecl { methods, .. } => {
            try resolveInstanceMethodBodies(self, &methods);
            try resolveInstanceMethodBodies(self, methods);
        }
        else => {
            // FIXME: This allows module-level statements that should
            // normally only be valid inside function bodies. We currently
            // need this because of how tests are written, but it should

        },
        case ast::NodeValue::Match(sw) => return try resolveMatch(self, node, sw),
        case ast::NodeValue::MatchProng(_) => panic "visit: `MatchProng` not handled here",
        case ast::NodeValue::LetElse(letElse) => return try resolveLetElse(self, node, letElse),
        case ast::NodeValue::Call(call) => return try resolveCall(self, node, call, CallCtx::Normal),
        case ast::NodeValue::BuiltinCall { kind, args } => return try resolveBuiltinCall(self, node, kind, &args),
        case ast::NodeValue::BuiltinCall { kind, args } => return try resolveBuiltinCall(self, node, kind, args),
        case ast::NodeValue::Assign(assign) => return try resolveAssign(self, node, assign),
        case ast::NodeValue::RecordLit(lit) => return try resolveRecordLit(self, node, lit, hint),
        case ast::NodeValue::ArrayLit(items) => return try resolveArrayLit(self, node, &items, hint),
        case ast::NodeValue::ArrayLit(items) => return try resolveArrayLit(self, node, items, hint),
        case ast::NodeValue::ArrayRepeatLit(lit) => return try resolveArrayRepeat(self, node, lit, hint),
        case ast::NodeValue::Subscript { container, index } => return try resolveSubscript(self, node, container, index),
        case ast::NodeValue::FieldAccess(access) => return try resolveFieldAccess(self, node, access),
        case ast::NodeValue::ScopeAccess(access) => return try resolveScopeAccess(self, node, access),
        case ast::NodeValue::AddressOf(addr) => return try resolveAddressOf(self, node, addr, hint),

    }
    return nil;
}

/// Visit every node contained in a list, returning the last resolved type.
fn visitList(self: *mut Resolver, list: *ast::NodeList) -> Type
fn visitList(self: *mut Resolver, list: *mut [*ast::Node]) -> Type
    throws (ResolveError)
{
    let mut diverges = false;
    for i in 0..list.len {
        let item = list.list[i];
    for item in list {
        if try infer(self, item) == Type::Never {
            diverges = true;
        }
    }
    if diverges {

/// Collect attribute flags applied to a declaration.
fn resolveAttributes(self: *mut Resolver, attrs: ?ast::Attributes) -> u32
    throws (ResolveError)
{
    let list = attrs else return 0;
    let attrNodes = &list.list;
    let attrNodes = list.list;
    let mut mask: u32 = 0;

    for i in 0..attrNodes.len {
        let node = attrNodes.list[i];
    for node in attrNodes {
        let case ast::NodeValue::Attribute(attr) = node.value
            else panic "resolveAttributes: invalid attribute node";
        mask |= (attr as u32);
    }
    return mask;

/// Analyze a block node, allocating a nested lexical scope.
fn resolveBlock(self: *mut Resolver, node: *ast::Node, block: ast::Block) -> Type
    throws (ResolveError)
{
    enterScope(self, node);
    let blockTy = try visitList(self, &block.statements) catch {
    let blockTy = try visitList(self, block.statements) catch {
        // One of the statements in the block failed analysis. We simply proceed
        // without checking the rest of the block statements. Return `Never` to
        // avoid spurious `FnMissingReturn` errors.
        exitScope(self);
        return try setNodeType(self, node, Type::Never);

             ast::NodeValue::Undef,
             ast::NodeValue::Nil => {
            return true;
        },
        case ast::NodeValue::ArrayLit(items) => {
            for i in 0..items.len {
                if not isConstExpr(self, items.list[i]) {
            for item in items {
                if not isConstExpr(self, item) {
                    return false;
                }
            }
            return true;
        },

            }
            return false;
        },
        case ast::NodeValue::RecordLit(lit) => {
            // Record literals are constant if all field values are constant.
            for i in 0..lit.fields.len {
                let field = lit.fields.list[i];
            for field in lit.fields {
                if let case ast::NodeValue::RecordLitField(fieldLit) = field.value {
                    if not isConstExpr(self, fieldLit.value) {
                        return false;
                    }
                }

                            return false;
                        }
                    },
                    else => return false,
                }
                for i in 0..call.args.len {
                    if not isConstExpr(self, call.args.list[i]) {
                for arg in call.args {
                    if not isConstExpr(self, arg) {
                        return false;
                    }
                }
                return true;
            }


/// Check that constructor arguments match record fields.
///
/// Verifies argument count matches field count, and that each argument is
/// assignable to its corresponding field type.
fn checkRecordConstructorArgs(self: *mut Resolver, node: *ast::Node, args: *ast::NodeList, recInfo: RecordType)
fn checkRecordConstructorArgs(self: *mut Resolver, node: *ast::Node, args: *mut [*ast::Node], recInfo: RecordType)
    throws (ResolveError)
{
    try checkRecordArity(self, args, recInfo, node);
    for i in 0..args.len {
        let arg = args.list[i];
        let arg = args[i];
        let fieldType = recInfo.fields[i].fieldType;
        try checkAssignable(self, arg, fieldType);
    }
}

/// Check that the argument count of a constructor pattern or call matches the record field count.
fn checkRecordArity(self: *mut Resolver, args: *ast::NodeList, recInfo: RecordType, pattern: *ast::Node) throws (ResolveError) {
    if args.len != recInfo.fieldsLen {
fn checkRecordArity(self: *mut Resolver, args: *mut [*ast::Node], recInfo: RecordType, pattern: *ast::Node) throws (ResolveError) {
    if args.len != recInfo.fields.len {
        throw emitError(self, pattern, ErrorKind::RecordFieldCountMismatch(CountMismatch {
            expected: recInfo.fieldsLen,
            expected: recInfo.fields.len as u32,
            actual: args.len,
        }));
    }
}


    let attrMask = try resolveAttributes(self, decl.attrs);
    let mut retTy = Type::Void;
    if let retNode = decl.sig.returnType {
        retTy = try infer(self, retNode);
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];
    let mut throwList: *mut [*Type] = &mut [];
    let mut fnType = FnType {
        paramTypes: undefined,
        paramTypesLen: 0,
        paramTypes: &[],
        returnType: allocType(self, retTy),
        throwList: undefined,
        throwListLen: 0,
        throwList: &[],
        localCount: 0,
    };
    // Enter the function scope to process parameters.
    enterFn(self, node, &fnType);

    if decl.sig.params.len > fnType.paramTypes.len {
    if decl.sig.params.len > MAX_FN_PARAMS {
        exitFn(self);
        throw emitError(self, node, ErrorKind::FnParamOverflow(CountMismatch {
            expected: fnType.paramTypes.len,
            expected: MAX_FN_PARAMS,
            actual: decl.sig.params.len,
        }));
    }
    for i in 0..decl.sig.params.len {
        let paramNode = decl.sig.params.list[i];
    for paramNode in decl.sig.params {
        let paramTy = try infer(self, paramNode) catch {
            exitFn(self);
            throw ResolveError::Failure;
        };
        fnType.paramTypes[fnType.paramTypesLen] = allocType(self, paramTy);
        fnType.paramTypesLen += 1;
        paramTypes.append(allocType(self, paramTy), a);
    }

    if decl.sig.throwList.len > fnType.throwList.len {
    if decl.sig.throwList.len > MAX_FN_THROWS {
        exitFn(self);
        throw emitError(self, node, ErrorKind::FnThrowOverflow(CountMismatch {
            expected: fnType.throwList.len,
            expected: MAX_FN_THROWS,
            actual: decl.sig.throwList.len,
        }));
    }
    for i in 0..decl.sig.throwList.len {
        let throwNode = decl.sig.throwList.list[i];
    for throwNode in decl.sig.throwList {
        let throwTy = try infer(self, throwNode) catch {
            exitFn(self);
            throw ResolveError::Failure;
        };
        fnType.throwList[fnType.throwListLen] = allocType(self, throwTy);
        fnType.throwListLen += 1;
        throwList.append(allocType(self, throwTy), a);
    }
    exitFn(self);
    fnType.paramTypes = &paramTypes[..];
    fnType.throwList = &throwList[..];

    // Bind the function name.
    let ty = Type::Fn(allocFnType(self, fnType));
    let sym = try bindValueIdent(self, decl.name, node, ty, false, 0, attrMask)
        else throw emitError(self, node, ErrorKind::ExpectedIdentifier);


    return ty;
}

/// Resolve record fields from a node list.
fn resolveRecordFields(self: *mut Resolver, node: *ast::Node, fields: ast::NodeList, labeled: bool) -> RecordType
fn resolveRecordFields(self: *mut Resolver, node: *ast::Node, fields: *mut [*ast::Node], labeled: bool) -> RecordType
    throws (ResolveError)
{
    let mut result: [RecordField; parser::MAX_RECORD_FIELDS] = undefined;
    let mut fieldsLen: u32 = 0;
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut result: *mut [RecordField] = &mut [];
    let mut currentOffset: u32 = 0;
    let mut maxAlignment: u32 = 1;

    if fields.len > result.len {
    if fields.len > parser::MAX_RECORD_FIELDS {
        throw emitError(self, node, ErrorKind::Internal);
    }
    // TODO: Add cycle detection to catch invalid recursive types like `record A { a: A }`.
    for i in 0..fields.len {
        let field = fields.list[i];
    for field in fields {
        let case ast::NodeValue::RecordField {
            field: fieldNode,
            type: typeNode,
            value: valueNode
        } = field.value else panic "resolveRecordFields: invalid record field";


        // Compute field offset by aligning to field's alignment.
        let fieldLayout = getTypeLayout(fieldType);
        currentOffset = mem::alignUp(currentOffset, fieldLayout.alignment);

        result[fieldsLen] = RecordField { name: fieldName, fieldType, offset: currentOffset as i32 };
        fieldsLen += 1;
        result.append(RecordField { name: fieldName, fieldType, offset: currentOffset as i32 }, a);

        // Advance offset past this field.
        currentOffset += fieldLayout.size;

        // Track max alignment for record layout.

    // Compute cached layout.
    let recordLayout = Layout {
        size: mem::alignUp(currentOffset, maxAlignment),
        alignment: maxAlignment
    };
    return RecordType { fields: result, fieldsLen, labeled, layout: recordLayout };
    return RecordType { fields: &result[..], labeled, layout: recordLayout };
}

/// Resolve record field types for a named record declaration.
fn resolveRecordBody(self: *mut Resolver, node: *ast::Node, decl: ast::RecordDecl)
    throws (ResolveError)


    // Skip if already resolved.
    if let case NominalType::Record(_) = *nominalTy {
        return;
    }
    try visitList(self, &decl.derives);
    try visitList(self, decl.derives);
    let recordType = try resolveRecordFields(self, node, decl.fields, decl.labeled);

    *nominalTy = NominalType::Record(recordType);
}



/// Allocate a trait type descriptor and return a pointer to it.
fn allocTraitType(self: *mut Resolver, name: *[u8]) -> *mut TraitType {
    let p = try! alloc::alloc(&mut self.arena, @sizeOf(TraitType), @alignOf(TraitType));
    let entry = p as *mut TraitType;
    *entry = TraitType { name, methods: undefined, methodsLen: 0, supertraits: undefined, supertraitsLen: 0 };
    *entry = TraitType { name, methods: &mut [], supertraits: &mut [] };

    return entry;
}

/// Bind a trait name in the current scope.

    return sym;
}

/// Find a trait method by name.
pub fn findTraitMethod(traitType: *TraitType, name: *[u8]) -> ?*TraitMethod {
    for i in 0..traitType.methodsLen {
    for i in 0..traitType.methods.len {
        if traitType.methods[i].name == name {
            return &traitType.methods[i];
        }
    }
    return nil;
}

/// Resolve a trait declaration body: supertrait methods, then own methods.
fn resolveTraitBody(self: *mut Resolver, node: *ast::Node, supertraits: *ast::NodeList, methods: *ast::NodeList)
fn resolveTraitBody(self: *mut Resolver, node: *ast::Node, supertraits: *mut [*ast::Node], methods: *mut [*ast::Node])
    throws (ResolveError)
{
    let sym = symbolFor(self, node)
        else return;
    let case SymbolData::Trait(traitType) = sym.data
        else return;

    // Resolve supertrait bounds and copy their methods into this trait.
    for i in 0..supertraits.len {
        if traitType.supertraitsLen >= traitType.supertraits.len {
            throw emitError(self, node, ErrorKind::Internal);
        }
        let superNode = supertraits.list[i];
    for superNode in supertraits {
        let superSym = try resolveNamePath(self, superNode);
        let case SymbolData::Trait(superTrait) = superSym.data
            else throw emitError(self, superNode, ErrorKind::Internal);
        try setNodeSymbol(self, superNode, superSym);

        if traitType.methodsLen + superTrait.methodsLen > ast::MAX_TRAIT_METHODS {
        let a = alloc::arenaAllocator(&mut self.arena);
        if traitType.methods.len + superTrait.methods.len > ast::MAX_TRAIT_METHODS {
            throw emitError(self, node, ErrorKind::TraitMethodOverflow(CountMismatch {
                expected: ast::MAX_TRAIT_METHODS,
                actual: traitType.methodsLen + superTrait.methodsLen,
                actual: traitType.methods.len as u32 + superTrait.methods.len as u32,
            }));
        }
        // Copy inherited methods into this trait's method table.
        for j in 0..superTrait.methodsLen {
            let inherited = superTrait.methods[j];
        for inherited in superTrait.methods {
            if let _ = findTraitMethod(traitType, inherited.name) {
                throw emitError(self, superNode, ErrorKind::DuplicateBinding(inherited.name));
            }
            traitType.methods[traitType.methodsLen] = TraitMethod {
            traitType.methods.append(TraitMethod {
                name: inherited.name,
                fnType: inherited.fnType,
                mutable: inherited.mutable,
                index: traitType.methodsLen,
            };
            traitType.methodsLen += 1;
                index: traitType.methods.len as u32,
            }, a);
        }
        traitType.supertraits[traitType.supertraitsLen] = superTrait;
        traitType.supertraitsLen += 1;
        traitType.supertraits.append(superTrait, a);
    }

    if traitType.methodsLen + methods.len > ast::MAX_TRAIT_METHODS {
    if traitType.methods.len + methods.len > ast::MAX_TRAIT_METHODS {
        throw emitError(self, node, ErrorKind::TraitMethodOverflow(CountMismatch {
            expected: ast::MAX_TRAIT_METHODS,
            actual: traitType.methodsLen + methods.len,
            actual: traitType.methods.len as u32 + methods.len as u32,
        }));
    }

    for i in 0..methods.len {
        let methodNode = methods.list[i];
    for methodNode in methods {
        let case ast::NodeValue::TraitMethodSig { name, receiver, sig } = methodNode.value
            else continue;
        let methodName = try nodeName(self, name);

        // Reject duplicate method names.


        if receiverTargetName != traitType.name {
            throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        }
        // Resolve parameter types and return type.
        let mut fnType = FnType {
            paramTypes: undefined,
            paramTypesLen: 0,
            returnType: allocType(self, Type::Void),
            throwList: undefined,
            throwListLen: 0,
            localCount: 0,
        };
        if sig.params.len > fnType.paramTypes.len {
        let a = alloc::arenaAllocator(&mut self.arena);
        let mut paramTypes: *mut [*Type] = &mut [];
        let mut throwList: *mut [*Type] = &mut [];
        let mut retType = allocType(self, Type::Void);

        if sig.params.len > MAX_FN_PARAMS {
            throw emitError(self, methodNode, ErrorKind::FnParamOverflow(CountMismatch {
                expected: fnType.paramTypes.len,
                expected: MAX_FN_PARAMS,
                actual: sig.params.len,
            }));
        }
        for j in 0..sig.params.len {
            let paramNode = sig.params.list[j];
        for paramNode in sig.params {
            let paramTy = try infer(self, paramNode);

            fnType.paramTypes[fnType.paramTypesLen] = allocType(self, paramTy);
            fnType.paramTypesLen += 1;
            paramTypes.append(allocType(self, paramTy), a);
        }
        if let ret = sig.returnType {
            fnType.returnType = allocType(self, try infer(self, ret));
            retType = allocType(self, try infer(self, ret));
        }
        // Resolve throws list.
        if sig.throwList.len > fnType.throwList.len {
        if sig.throwList.len > MAX_FN_THROWS {
            throw emitError(self, methodNode, ErrorKind::FnThrowOverflow(CountMismatch {
                expected: fnType.throwList.len,
                expected: MAX_FN_THROWS,
                actual: sig.throwList.len,
            }));
        }
        for j in 0..sig.throwList.len {
            let throwNode = sig.throwList.list[j];
        for throwNode in sig.throwList {
            let throwTy = try infer(self, throwNode);

            fnType.throwList[fnType.throwListLen] = allocType(self, throwTy);
            fnType.throwListLen += 1;
            throwList.append(allocType(self, throwTy), a);
        }

        traitType.methods[traitType.methodsLen] = TraitMethod {
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: retType,
            throwList: &throwList[..],
            localCount: 0,
        };
        traitType.methods.append(TraitMethod {
            name: methodName,
            fnType: allocFnType(self, fnType),
            mutable,
            index: traitType.methodsLen,
        };
        traitType.methodsLen += 1;
            index: traitType.methods.len as u32,
        }, a);

        try setNodeType(self, methodNode, Type::Void);
    }
}


fn resolveInstanceDecl(
    self: *mut Resolver,
    node: *ast::Node,
    traitName: *ast::Node,
    targetType: *ast::Node,
    methods: *ast::NodeList
    methods: *mut [*ast::Node]
) throws (ResolveError) {
    // Look up the trait.
    let traitSym = try resolveNamePath(self, traitName);
    let case SymbolData::Trait(traitInfo) = traitSym.data
        else throw emitError(self, traitName, ErrorKind::Internal);


    // Build the instance entry.
    if self.instancesLen >= MAX_INSTANCES {
        throw emitError(self, node, ErrorKind::Internal);
    }
    let methodSlice = try! alloc::allocSlice(
        &mut self.arena, @sizeOf(*mut Symbol), @alignOf(*mut Symbol), traitInfo.methods.len as u32
    ) as *mut [*mut Symbol];
    let mut entry = InstanceEntry {
        traitType: traitInfo,
        concreteType,
        concreteTypeName: typeSym.name,
        moduleId: self.currentMod,
        methods: undefined,
        methodsLen: 0,
        methods: methodSlice,
    };
    // Track which trait methods are covered by the instance.
    let mut covered: [bool; ast::MAX_TRAIT_METHODS] = [false; ast::MAX_TRAIT_METHODS];

    // Match each instance method to a trait method.
    for i in 0..methods.len {
        let methodNode = methods.list[i];
    for methodNode in methods {
        let case ast::NodeValue::InstanceMethodDecl {
            name, receiverName, receiverType, sig, body
        } = methodNode.value else continue;

        let methodName = try nodeName(self, name);

            throw emitError(self, receiverType, ErrorKind::ReceiverMutabilityMismatch);
        }

        // Build the function type for the instance method.
        // The receiver becomes the first parameter.
        let mut fnType = FnType {
            paramTypes: undefined,
            paramTypesLen: 0,
            returnType: allocType(self, Type::Void),
            throwList: undefined,
            throwListLen: 0,
            localCount: 0,
        };
        // First param is the receiver.
        let receiverPtrType = Type::Pointer {
            target: allocType(self, concreteType),
            mutable: receiverMut,
        };
        fnType.paramTypes[0] = allocType(self, receiverPtrType);
        fnType.paramTypesLen = 1;

        // Validate that the instance method's signature matches the
        // trait method's signature exactly (params, return type, throws).
        if sig.params.len != tm.fnType.paramTypesLen {
        if sig.params.len != tm.fnType.paramTypes.len {
            throw emitError(self, methodNode, ErrorKind::FnArgCountMismatch(CountMismatch {
                expected: tm.fnType.paramTypesLen,
                expected: tm.fnType.paramTypes.len as u32,
                actual: sig.params.len,
            }));
        }
        for j in 0..sig.params.len {
            let paramNode = sig.params.list[j];
            let paramNode = sig.params[j];
            let case ast::NodeValue::FnParam(param) = paramNode.value
                else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);
            let instanceParamTy = try resolveValueType(self, param.type);
            if not typesEqual(instanceParamTy, *tm.fnType.paramTypes[j]) {
                throw emitTypeMismatch(self, paramNode, TypeMismatch {

            throw emitTypeMismatch(self, methodNode, TypeMismatch {
                expected: *tm.fnType.returnType,
                actual: instanceRetTy,
            });
        }
        if sig.throwList.len != tm.fnType.throwListLen {
        if sig.throwList.len != tm.fnType.throwList.len {
            throw emitError(self, methodNode, ErrorKind::FnThrowCountMismatch(CountMismatch {
                expected: tm.fnType.throwListLen,
                expected: tm.fnType.throwList.len as u32,
                actual: sig.throwList.len,
            }));
        }
        for j in 0..sig.throwList.len {
            let instanceThrowTy = try resolveValueType(self, sig.throwList.list[j]);
            let instanceThrowTy = try resolveValueType(self, sig.throwList[j]);
            if not typesEqual(instanceThrowTy, *tm.fnType.throwList[j]) {
                throw emitTypeMismatch(self, sig.throwList.list[j], TypeMismatch {
                throw emitTypeMismatch(self, sig.throwList[j], TypeMismatch {
                    expected: *tm.fnType.throwList[j],
                    actual: instanceThrowTy,
                });
            }
        }

        // Copy the trait's canonical types into the final function type.
        for j in 0..tm.fnType.paramTypesLen {
            fnType.paramTypes[fnType.paramTypesLen] = tm.fnType.paramTypes[j];
            fnType.paramTypesLen += 1;
        }
        fnType.returnType = tm.fnType.returnType;
        for j in 0..tm.fnType.throwListLen {
            fnType.throwList[fnType.throwListLen] = tm.fnType.throwList[j];
            fnType.throwListLen += 1;
        // Build final function type: receiver plus trait's canonical types.
        let a = alloc::arenaAllocator(&mut self.arena);
        // TODO: Improve this pattern, maybe via something like `(&[]).append(..)`?
        let mut paramTypes: *mut [*Type] = &mut [];
        paramTypes.append(allocType(self, receiverPtrType), a);

        for ty in tm.fnType.paramTypes {
            paramTypes.append(ty, a);
        }
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: tm.fnType.returnType,
            throwList: tm.fnType.throwList,
            localCount: 0,
        };

        // Create a symbol for the instance method without binding it into the
        // module scope. Instance methods are dispatched via v-table, so they
        // must not pollute the enclosing scope.
        let fnTy = Type::Fn(allocFnType(self, fnType));

        try setNodeType(self, methodNode, fnTy);
        try setNodeType(self, name, fnTy);

        // Store in instance entry at the matching v-table slot.
        entry.methods[tm.index] = sym;
        entry.methodsLen += 1;

        covered[tm.index] = true;
    }

    // Fill inherited method slots from supertrait instances.
    for si in 0..traitInfo.supertraitsLen {
        let superTrait = traitInfo.supertraits[si];
    for superTrait in traitInfo.supertraits {
        let superInst = findInstance(self, superTrait, concreteType)
            else throw emitError(self, node, ErrorKind::MissingSupertraitInstance(superTrait.name));
        for mi in 0..superTrait.methodsLen {
        for mi in 0..superTrait.methods.len {
            let merged = findTraitMethod(traitInfo, superTrait.methods[mi].name)
                else panic "resolveInstanceDecl: inherited method not found";
            if not covered[merged.index] {
                entry.methods[merged.index] = superInst.methods[mi];
                entry.methodsLen += 1;
                covered[merged.index] = true;
            }
        }
    }

    // Check that all trait methods are implemented.
    for i in 0..traitInfo.methodsLen {
    for i in 0..traitInfo.methods.len {
        if not covered[i] {
            throw emitError(self, node, ErrorKind::MissingTraitMethod(traitInfo.methods[i].name));
        }
    }
    self.instances[self.instancesLen] = entry;


    try setNodeType(self, node, Type::Void);
}

/// Resolve instance method bodies.
fn resolveInstanceMethodBodies(self: *mut Resolver, methods: *ast::NodeList)
fn resolveInstanceMethodBodies(self: *mut Resolver, methods: *mut [*ast::Node])
    throws (ResolveError)
{
    for i in 0..methods.len {
        let methodNode = methods.list[i];
    for methodNode in methods {
        let case ast::NodeValue::InstanceMethodDecl {
            name, receiverName, receiverType, sig, body
        } = methodNode.value else continue;

        // Symbol may be absent if [`resolveInstanceDecl`] reported an error

        try bindValueIdent(self, receiverName, receiverName, receiverTy, false, 0, 0) catch {
            exitFn(self);
            throw ResolveError::Failure;
        };
        // Bind the remaining parameters from the signature.
        for j in 0..sig.params.len {
            let paramNode = sig.params.list[j];
        for paramNode in sig.params {
            let paramTy = try infer(self, paramNode) catch {
                exitFn(self);
                throw ResolveError::Failure;
            };
        }

    // Check if already resolved, in which case there's no need to
    // do it again.
    if let case NominalType::Union(_) = *nominalTy {
        return;
    }
    let mut variants: [UnionVariant; MAX_UNION_VARIANTS] = undefined;
    let mut variantCount: u32 = 0;
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut variants: *mut [UnionVariant] = &mut [];

    // Create a temporary nominal type to replace the placeholder.This prevents infinite recursion
    // when a variant references this union type (e.g. record payloads with `*[Self]`).
    // TODO: It would be best to have a resolving state eg. `Visiting` for this situation.
    *nominalTy = NominalType::Union(UnionType {
        variants,
        variantsLen: variantCount,
        variants: &[],
        layout: Layout { size: 0, alignment: 0 },
        valOffset: 0,
        isAllVoid: true
    });

    try visitList(self, &decl.derives);
    try visitList(self, decl.derives);

    if decl.variants.len > variants.len {
    if decl.variants.len > MAX_UNION_VARIANTS {
        panic "resolveUnionBody: maximum union variants exceeded";
    }
    let mut iota: u32 = 0;
    for i in 0..decl.variants.len {
        let variantNode = decl.variants.list[i];
        let variantNode = decl.variants[i];
        let case ast::NodeValue::UnionDeclVariant(variantDecl) = variantNode.value
            else panic "resolveUnionBody: invalid union variant";
        let variantName = try nodeName(self, variantDecl.name);
        // Resolve the variant's payload type if present.
        let mut variantType = Type::Void;

        let tag = variantTag(variantDecl, &mut iota);
        // Create a symbol for this variant.
        let data = SymbolData::Variant { type: variantType, decl: node, ordinal: i, index: tag };
        let variantSym = allocSymbol(self, data, variantName, variantNode, 0);

        variants[variantCount] = UnionVariant {
        variants.append(UnionVariant {
            name: variantName,
            valueType: variantType,
            symbol: variantSym,
        };
        variantCount += 1;
        }, a);
    }
    let info = computeUnionLayout(&variants[..variantCount]);
    let info = computeUnionLayout(&variants[..]);

    // Update the nominal type with the resolved variants.
    *nominalTy = NominalType::Union(UnionType {
        variants,
        variantsLen: variantCount,
        variants: &variants[..],
        layout: info.layout,
        valOffset: info.valOffset,
        isAllVoid: info.isAllVoid,
    });
}

            }
        }
        case Type::Array(arrayInfo) => {
            if let case ast::NodeValue::ArrayLit(items) = pattern.value {
                let elemTy = *arrayInfo.item;
                for i in 0..items.len {
                    try resolveCasePattern(self, items.list[i], elemTy, IdentMode::Bind, matchBy);
                for item in items {
                    try resolveCasePattern(self, item, elemTy, IdentMode::Bind, matchBy);
                }
                return;
            }
        } else => {}
    }


    return try setNodeType(self, node, Type::Void);
}

/// Check whether any pattern in a case prong is a wildcard `_`.
fn hasWildcardPattern(patterns: ast::NodeList) -> bool {
    for i in 0..patterns.len {
        if let case ast::NodeValue::Placeholder = patterns.list[i].value {
fn hasWildcardPattern(patterns: *mut [*ast::Node]) -> bool {
    for pattern in patterns {
        if let case ast::NodeValue::Placeholder = pattern.value {
            return true;
        }
    }
    return false;
}

    } else {
        try resolveMatchGeneric(self, node, sw, subject.effectiveTy);
    }

    // Mark last non-guarded prong as exhaustive.
    let lastProng = sw.prongs.list[sw.prongs.len - 1];
    let lastProng = sw.prongs[sw.prongs.len - 1];
    let case ast::NodeValue::MatchProng(p) = lastProng.value
        else panic "resolveMatch: expected match prong";
    if p.guard == nil {
        try setProngCatchAll(self, lastProng, true);
    }

/// Analyze a `match` expression on an optional subject.
fn resolveMatchOptional(self: *mut Resolver, node: *ast::Node, sw: ast::Match, innerTy: *Type) -> Type
    throws (ResolveError)
{
    let subjectTy = Type::Optional(innerTy);
    let prongs = &sw.prongs;
    let prongs = sw.prongs;
    let mut hasValue = false;
    let mut hasNil = false;
    let mut catchAll = false;
    let mut matchType = Type::Never;

    for i in 0..prongs.len {
        let prongNode = prongs.list[i];
    for prongNode in prongs {
        let case ast::NodeValue::MatchProng(prong) = prongNode.value
            else panic "resolveMatchOptional: expected match prong";

        // For optionals, a binding prong only covers the value case, not `nil`.
        // Only `else` without a guard is a true catch-all.

                if hasValue {
                    throw emitError(self, prongNode, ErrorKind::DuplicateMatchPattern);
                }
                hasValue = true;
            } else if let case ast::ProngArm::Case(patterns) = prong.arm {
                for idx in 0..patterns.len {
                    if let case ast::NodeValue::Nil = patterns.list[idx].value {
                for pat in patterns {
                    if let case ast::NodeValue::Nil = pat.value {
                        if hasNil {
                            throw emitError(self, patterns.list[idx], ErrorKind::DuplicateMatchPattern);
                            throw emitError(self, pat, ErrorKind::DuplicateMatchPattern);
                        }
                        hasNil = true;
                    }
                }
            }

    sw: ast::Match,
    subjectTy: Type,
    info: UnionType,
    matchBy: MatchBy
) -> Type throws (ResolveError) {
    let prongs = &sw.prongs;
    let prongs = sw.prongs;
    let mut covered: [bool; MAX_UNION_VARIANTS] = [false; MAX_UNION_VARIANTS];
    let mut coveredCount: u32 = 0;
    let mut state = MatchState { catchAll: false, isConst: false };
    let mut matchType = Type::Never;

    for i in 0..prongs.len {
        let prongNode = prongs.list[i];
    for prongNode in prongs {
        let case ast::NodeValue::MatchProng(prong) = prongNode.value
            else panic "resolveMatchUnion: expected match prong";

        matchType = try resolveMatchProng(self, prongNode, prong, subjectTy, &mut state, matchType, matchBy);

        // Record covered variants. Guarded prongs don't count as covering.
        if prong.guard == nil {
            if let case ast::ProngArm::Case(patterns) = prong.arm {
                for idx in 0..patterns.len {
                    let pattern = patterns.list[idx];
                for pattern in patterns {
                    if let case NodeExtra::UnionVariant { ordinal: ix, .. } = self.nodeData.entries[pattern.id].extra {
                        if covered[ix] {
                            throw emitError(self, pattern, ErrorKind::DuplicateMatchPattern);
                        }
                        covered[ix] = true;

            }
        }
    }
    // Check that all variants are covered.
    if not state.catchAll {
        for i in 0..info.variantsLen {
        for i in 0..info.variants.len {
            if not covered[i] {
                throw emitError(
                    self, node, ErrorKind::UnionMatchNonExhaustive(info.variants[i].name)
                );
            }
        }
    } else if coveredCount == info.variantsLen as u32 {
    } else if coveredCount == info.variants.len as u32 {
        throw emitError(self, node, ErrorKind::UnreachableElse);
    }
    return try setNodeType(self, node, matchType);
}

/// Analyze a `match` expression on a generic subject type. Requires exhaustiveness:
/// booleans must cover both `true` and `false`, other types require a catch-all.
fn resolveMatchGeneric(self: *mut Resolver, node: *ast::Node, sw: ast::Match, subjectTy: Type) -> Type
    throws (ResolveError)
{
    let prongs = &sw.prongs;
    let prongs = sw.prongs;
    let mut state = MatchState { catchAll: false, isConst: true };
    let mut matchType = Type::Never;
    let mut hasTrue = false;
    let mut hasFalse = false;
    let mut hasConstCase = false;

    for i in 0..prongs.len {
        let prongNode = prongs.list[i];
    for prongNode in prongs {
        let case ast::NodeValue::MatchProng(prong) = prongNode.value
            else panic "resolveMatchGeneric: expected match prong";

        matchType = try resolveMatchProng(
            self, prongNode, prong, subjectTy, &mut state, matchType, MatchBy::Value
        );
        // Track boolean coverage. Guarded prongs don't count as covering.
        if let case ast::ProngArm::Case(patterns) = prong.arm {
            for idx in 0..patterns.len {
                let p = patterns.list[idx];
            for p in patterns {
                if prong.guard == nil {
                    if let case ast::NodeValue::Bool(val) = p.value {
                        if (val and hasTrue) or (not val and hasFalse) {
                            throw emitError(self, p, ErrorKind::DuplicateMatchPattern);
                        }

                bindTy = *inner;
            }
            try bindPatternVar(self, pat, bindTy, matchBy);
        }
        case ast::ProngArm::Case(patterns) => {
            for i in 0..patterns.len {
                try resolveCasePattern(self, patterns.list[i], subjectTy, IdentMode::Compare, matchBy);
            for pattern in patterns {
                try resolveCasePattern(self, pattern, subjectTy, IdentMode::Compare, matchBy);
            }
        }
        case ast::ProngArm::Else => {}
    }
    if let g = prong.guard {

    matchBy: MatchBy
) throws (ResolveError) {
    match pattern.value {
        case ast::NodeValue::Call(call) => {
            // Unlabeled patterns: `S(x, y)`.
            try checkRecordArity(self, &call.args, recInfo, pattern);
            try checkRecordArity(self, call.args, recInfo, pattern);

            for i in 0..call.args.len {
                let binding = call.args.list[i];
                let binding = call.args[i];
                let fieldType = recInfo.fields[i].fieldType;
                try bindPatternVar(self, binding, fieldType, matchBy);
            }
        }
        case ast::NodeValue::RecordLit(lit) => {
            // Labeled patterns: `T { x, y }` or `T { x: binding }`.
            if not lit.ignoreRest {
                try checkRecordArity(self, &lit.fields, recInfo, pattern);
                try checkRecordArity(self, lit.fields, recInfo, pattern);
            }
            for i in 0..lit.fields.len {
                let fieldNode = lit.fields.list[i];
            for fieldNode in lit.fields {
                let case ast::NodeValue::RecordLitField(field) = fieldNode.value
                    else panic "expected RecordLitField";

                // Brace patterns require labeled fields.
                let label = field.label else panic "expected labeled field";

/// Analyze builtin function calls like `@sizeOf(T)` and `@alignOf(T)`.
fn resolveBuiltinCall(
    self: *mut Resolver,
    node: *ast::Node,
    kind: ast::Builtin,
    args: *ast::NodeList
    args: *mut [*ast::Node]
) -> Type throws (ResolveError) {
    // Handle `@sliceOf(ptr, len)` and `@sliceOf(ptr, len, cap)`.
    if kind == ast::Builtin::SliceOf {
        if args.len != 2 and args.len != 3 {
            throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
                expected: 2,
                actual: args.len as u32,
            }));
        }
        let ptrType = try visit(self, args.list[0], Type::Unknown);
        let ptrType = try visit(self, args[0], Type::Unknown);
        let case Type::Pointer { target, mutable } = ptrType else {
            throw emitError(self, node, ErrorKind::ExpectedPointer);
        };
        let _ = try checkAssignable(self, args.list[1], Type::U32);
        let _ = try checkAssignable(self, args[1], Type::U32);
        if args.len == 3 {
            let _ = try checkAssignable(self, args.list[2], Type::U32);
            let _ = try checkAssignable(self, args[2], Type::U32);
        }
        return try setNodeType(self, node, Type::Slice { item: target, mutable });
    }
    if args.len != 1 {
        throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
            expected: 1,
            actual: args.len as u32,
        }));
    }

    let ty = try resolveValueType(self, args.list[0]);
    let ty = try resolveValueType(self, args[0]);
    // Ensure the type body is resolved before computing layout.
    // TODO: Somehow, ensuring the type is resolved should just happen all
    // the time, lazily.
    try ensureTypeResolved(self, ty, args.list[0]);
    try ensureTypeResolved(self, ty, args[0]);
    // TODO: This should be stored in `symbol` instead of having to recompute it.
    // That way there's a canonical place to look for code gen.
    let layout = getTypeLayout(ty);

    // Evaluate the built-in.

/// Validate call arguments against a function type: check argument count,
/// type-check each argument, and verify that throwing functions use `try`.
fn checkCallArgs(self: *mut Resolver, node: *ast::Node, call: ast::Call, info: *FnType, ctx: CallCtx)
    throws (ResolveError)
{
    if ctx == CallCtx::Normal and info.throwListLen > 0 {
    if ctx == CallCtx::Normal and info.throwList.len > 0 {
        throw emitError(self, node, ErrorKind::MissingTry);
    }
    if call.args.len != info.paramTypesLen {
    if call.args.len != info.paramTypes.len as u32 {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: info.paramTypesLen,
            expected: info.paramTypes.len as u32,
            actual: call.args.len,
        }));
    }
    for i in 0..call.args.len {
        assert i < MAX_FN_PARAMS;

        let argNode = call.args.list[i];
        let argNode = call.args[i];
        let expectedTy = *info.paramTypes[i];

        try checkAssignable(self, argNode, expectedTy);
    }
}

        let subjectTy = autoDeref(parentTy);

        if let case Type::Slice { item, mutable } = subjectTy {
            let methodName = try nodeName(self, access.child);
            if methodName == "append" {
                return try resolveSliceAppend(self, node, access.parent, &call.args, item, mutable);
                return try resolveSliceAppend(self, node, access.parent, call.args, item, mutable);
            }
            if methodName == "delete" {
                return try resolveSliceDelete(self, node, access.parent, &call.args, item, mutable);
                return try resolveSliceDelete(self, node, access.parent, call.args, item, mutable);
            }
        }
    }
    let calleeTy = try infer(self, call.callee);


/// Resolve `slice.append(val, allocator)`.
fn resolveSliceAppend(
    self: *mut Resolver,
    node: *ast::Node,
    parent: *ast::Node,
    args: *ast::NodeList,
    args: *mut [*ast::Node],
    elemType: *Type,
    mutable: bool
) -> Type throws (ResolveError) {
    if not mutable {
        throw emitError(self, parent, ErrorKind::ImmutableBinding);

            expected: 2,
            actual: args.len as u32,
        }));
    }
    // First argument must be assignable to the element type.
    try checkAssignable(self, args.list[0], *elemType);
    try checkAssignable(self, args[0], *elemType);
    // Second argument: the allocator. We accept any type -- the lowerer
    // reads .func and .ctx at fixed offsets (structurally typed).
    try visit(self, args.list[1], Type::Unknown);
    try visit(self, args[1], Type::Unknown);
    self.nodeData.entries[node.id].extra = NodeExtra::SliceAppend { elemType };

    return try setNodeType(self, node, Type::Void);
}

/// Resolve `slice.delete(index)`.
fn resolveSliceDelete(
    self: *mut Resolver,
    node: *ast::Node,
    parent: *ast::Node,
    args: *ast::NodeList,
    args: *mut [*ast::Node],
    elemType: *Type,
    mutable: bool
) -> Type throws (ResolveError) {
    if not mutable {
        throw emitError(self, parent, ErrorKind::ImmutableBinding);

        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: 1,
            actual: args.len as u32,
        }));
    }
    try checkAssignable(self, args.list[0], Type::U32);
    try checkAssignable(self, args[0], Type::U32);
    self.nodeData.entries[node.id].extra = NodeExtra::SliceDelete { elemType };

    return try setNodeType(self, node, Type::Void);
}


    }
}

/// Find a record field by name.
fn findRecordField(s: *RecordType, fieldName: *[u8]) -> ?u32 {
    for i in 0..s.fieldsLen {
    for i in 0..s.fields.len {
        if let name = s.fields[i].name {
            if name == fieldName {
                return i;
            }
        }

    // Check if this variant expects a payload.
    let payloadType = variant.valueType;
    if payloadType != Type::Void {
        let recInfo = getRecord(payloadType)
            else panic "resolveUnionVariantConstructor: payload is not a record";
        try checkRecordConstructorArgs(self, node, &call.args, recInfo);
        try checkRecordConstructorArgs(self, node, call.args, recInfo);
    } else {
        if call.args.len > 0 {
            throw emitError(self, node, ErrorKind::UnionVariantPayloadUnexpected(variant.name));
        }
    }

    throws (ResolveError)
{
    let case NominalType::Record(recInfo) = *recordType
        else panic "resolveRecordConstructorCall: not a record type";

    try checkRecordConstructorArgs(self, node, &call.args, recInfo);
    try checkRecordConstructorArgs(self, node, call.args, recInfo);
    return try setNodeType(self, node, Type::Nominal(recordType));
}

/// Resolve the type name of a record literal, handling both record types and
/// union variant payloads like `Union::Variant { ... }`.

    // Unlabeled records must use constructor call syntax `R(...)`, not brace syntax.
    if not recordType.labeled {
        throw emitError(self, node, ErrorKind::RecordFieldStyleMismatch);
    }
    // Check field count. With `{ .. }` syntax, fewer fields are allowed.
    if lit.fields.len > recordType.fieldsLen {
    if lit.fields.len > recordType.fields.len {
        throw emitError(self, node, ErrorKind::RecordFieldCountMismatch(CountMismatch {
            expected: recordType.fieldsLen,
            expected: recordType.fields.len as u32,
            actual: lit.fields.len,
        }));
    }
    if not lit.ignoreRest and lit.fields.len < recordType.fieldsLen {
    if not lit.ignoreRest and lit.fields.len < recordType.fields.len {
        let missingName = recordType.fields[lit.fields.len].name else panic;
        throw emitError(self, node, ErrorKind::RecordFieldMissing(missingName));
    }

    // Fields must be in declaration order.
    for idx in 0..lit.fields.len {
        let fieldNode = lit.fields.list[idx];
        let fieldNode = lit.fields[idx];
        let case ast::NodeValue::RecordLitField(fieldArg) = fieldNode.value
            else panic "resolveRecordLit: expected field node value";
        let label = fieldArg.label
            else panic "resolveRecordLit: expected labeled field";
        let fieldName = try nodeName(self, label);

    let targetInfo = hintInfo else {
        throw emitError(self, node, ErrorKind::CannotInferType);
    };

    // Check field count.
    if lit.fields.len != targetInfo.fieldsLen {
        if lit.fields.len < targetInfo.fieldsLen {
    if lit.fields.len != targetInfo.fields.len {
        if lit.fields.len < targetInfo.fields.len {
            let missingName = targetInfo.fields[lit.fields.len].name else panic;
            throw emitError(self, node, ErrorKind::RecordFieldMissing(missingName));
        } else {
            throw emitError(self, node, ErrorKind::RecordFieldCountMismatch(CountMismatch {
                expected: targetInfo.fieldsLen,
                expected: targetInfo.fields.len as u32,
                actual: lit.fields.len,
            }));
        }
    }

    // Fields must be in declaration order.
    for idx in 0..lit.fields.len {
        let fieldNode = lit.fields.list[idx];
        let fieldNode = lit.fields[idx];
        let case ast::NodeValue::RecordLitField(fieldArg) = fieldNode.value
            else panic "resolveAnonRecordLit: expected field node value";
        let label = fieldArg.label
            else panic "resolveAnonRecordLit: expected labeled field";
        let fieldName = try nodeName(self, label);

    }
    return try setNodeType(self, node, innerHint);
}

/// Analyze an array literal expression.
fn resolveArrayLit(self: *mut Resolver, node: *ast::Node, items: *ast::NodeList, hint: Type) -> Type
fn resolveArrayLit(self: *mut Resolver, node: *ast::Node, items: *mut [*ast::Node], hint: Type) -> Type
    throws (ResolveError)
{
    let length = items.len;
    let mut expectedTy: Type = Type::Unknown;

    if let case Type::Array(ary) = hint {
        expectedTy = *ary.item;
    };
    for i in 0..length {
        let itemNode = items.list[i];
    for itemNode in items {
        let itemTy = try visit(self, itemNode, expectedTy);
        assert itemTy != Type::Unknown;

        // Set the expected type to the first type we encounter.
        if expectedTy == Type::Unknown {

    access: ast::Access,
    unionType: UnionType,
    variantName: *[u8]
) -> *mut Symbol throws (ResolveError) {
    // Look up the variant in the union's nominal type.
    for i in 0..unionType.variantsLen {
    for i in 0..unionType.variants.len {
        let variant = &unionType.variants[i];
        if variant.name == variantName {
            let case SymbolData::Variant { ordinal, index, .. } = variant.symbol.data
                else panic "resolveUnionVariantAccess: expected variant symbol";


    let calleeTy = typeFor(self, callExpr.callee)
        else return try setNodeType(self, node, resultTy);
    let case Type::Fn(calleeInfo) = calleeTy
        else throw emitError(self, callExpr.callee, ErrorKind::TryNonThrowing);

    if calleeInfo.throwListLen == 0 {
    if calleeInfo.throwList.len == 0 {
        throw emitError(self, callExpr.callee, ErrorKind::TryNonThrowing);
    }
    // If we're not catching the error, nor panicking on error, nor returning
    // optional, then the current function must be able to propagate it.
    let mut tryResultTy = resultTy;

        // `try ... catch` -- one or more catch clauses.
        tryResultTy = try resolveTryCatches(self, node, tryExpr.catches, calleeInfo, resultTy, hint);
    } else if not tryExpr.shouldPanic {
        let fnInfo = self.currentFn
            else throw emitError(self, node, ErrorKind::TryRequiresThrows);
        if fnInfo.throwListLen == 0 {
        if fnInfo.throwList.len == 0 {
            throw emitError(self, node, ErrorKind::TryRequiresThrows);
        }
        // Check that *all* thrown errors of the callee can be propagated by
        // the caller.
        for i in 0..calleeInfo.throwListLen {
            let throwTy = calleeInfo.throwList[i];
        for throwTy in calleeInfo.throwList {
            let mut found = false;

            for j in 0..fnInfo.throwListLen {
                if fnInfo.throwList[j] == throwTy {
            for callerThrowTy in fnInfo.throwList {
                if callerThrowTy == throwTy {
                    found = true;
                    break;
                }
            }
            if not found {

/// body and returns the result type. Multi-error callees with inferred bindings
/// are rejected; you must use typed catches.
fn resolveTryCatches(
    self: *mut Resolver,
    node: *ast::Node,
    catches: ast::NodeList,
    catches: *mut [*ast::Node],
    calleeInfo: *FnType,
    resultTy: Type,
    hint: Type
) -> Type throws (ResolveError) {
    let firstNode = catches.list[0];
    let firstNode = catches[0];
    let case ast::NodeValue::CatchClause(first) = firstNode.value else
        throw emitError(self, node, ErrorKind::UnexpectedNode(firstNode));

    // Typed catches: dispatch to dedicated handler.
    if first.typeNode != nil {
        return try resolveTypedCatches(self, node, catches, calleeInfo, resultTy, hint);
    }
    // Single untyped catch clause.
    if let binding = first.binding {
        if calleeInfo.throwListLen > 1 {
        if calleeInfo.throwList.len > 1 {
            throw emitError(self, binding, ErrorKind::TryCatchMultiError);
        }
        enterScope(self, node);

        let errTy = *calleeInfo.throwList[0];

/// Validates that each type annotation is in the callee's throw list, that
/// there are no duplicate catch types, and that the clauses are exhaustive.
fn resolveTypedCatches(
    self: *mut Resolver,
    node: *ast::Node,
    catches: ast::NodeList,
    catches: *mut [*ast::Node],
    calleeInfo: *FnType,
    resultTy: Type,
    hint: Type
) -> Type throws (ResolveError) {
    // Track which of the callee's throw types have been covered.
    let mut covered: [bool; MAX_FN_THROWS] = [false; MAX_FN_THROWS];
    let mut hasCatchAll = false;

    for i in 0..catches.len {
        let clauseNode = catches.list[i];
    for clauseNode in catches {
        let case ast::NodeValue::CatchClause(clause) = clauseNode.value else
            throw emitError(self, node, ErrorKind::UnexpectedNode(clauseNode));

        if let typeNode = clause.typeNode {
            // Typed catch clause: validate against callee's throw list.
            let errTy = try infer(self, typeNode);
            let mut foundIdx: ?u32 = nil;

            for j in 0..calleeInfo.throwListLen {
            for j in 0..calleeInfo.throwList.len {
                if errTy == *calleeInfo.throwList[j] {
                    foundIdx = j;
                    break;
                }
            }

        try checkCatchBody(self, clause.body, resultTy, hint);
    }

    // Check exhaustiveness: all callee error types must be covered.
    if not hasCatchAll {
        for i in 0..calleeInfo.throwListLen {
        for i in 0..calleeInfo.throwList.len {
            if not covered[i] {
                throw emitError(self, node, ErrorKind::TryCatchNonExhaustive);
            }
        }
    }

fn resolveThrow(self: *mut Resolver, node: *ast::Node, expr: *ast::Node) -> Type
    throws (ResolveError)
{
    let fnInfo = self.currentFn
        else throw emitError(self, node, ErrorKind::ThrowRequiresThrows);
    if fnInfo.throwListLen == 0 {
    if fnInfo.throwList.len == 0 {
        throw emitError(self, node, ErrorKind::ThrowRequiresThrows);
    }
    let throwTy = try infer(self, expr);
    for i in 0..fnInfo.throwListLen {
        if let coerce = isAssignable(self, *fnInfo.throwList[i], throwTy, expr) {
    for errTy in fnInfo.throwList {
        if let coerce = isAssignable(self, *errTy, throwTy, expr) {
            try setNodeCoercion(self, expr, coerce);
            return try setNodeType(self, node, Type::Never);
        }
    }
    throw emitError(self, expr, ErrorKind::ThrowIncompatibleError);

        let _actualTy = try checkAssignable(self, val, expected);
    } else if expected != Type::Void {
        throw emitTypeMismatch(self, node, TypeMismatch { expected, actual: Type::Void });
    }
    // In throwing functions, return values are wrapped in the success variant.
    if f.throwListLen > 0 {
    if f.throwList.len > 0 {
        try setNodeCoercion(self, node, Coercion::ResultWrap);
    }
    return try setNodeType(self, node, Type::Never);
}


            let recordType = try resolveRecordFields(self, node, fields, labeled);
            let nominalTy = allocNominalType(self, NominalType::Record(recordType));
            return Type::Nominal(nominalTy);
        }
        case ast::TypeSig::Fn(t) => {
             let mut fnType = FnType {
                paramTypes: undefined,
                paramTypesLen: 0,
                returnType: allocType(self, Type::Void),
                throwList: undefined,
                throwListLen: 0,
                localCount: 0,
            };
            if t.params.len > fnType.paramTypes.len {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut paramTypes: *mut [*Type] = &mut [];
            let mut throwList: *mut [*Type] = &mut [];

            if t.params.len > MAX_FN_PARAMS {
                throw emitError(self, node, ErrorKind::FnParamOverflow(CountMismatch {
                    expected: fnType.paramTypes.len,
                    expected: MAX_FN_PARAMS,
                    actual: t.params.len,
                }));
            }
            if t.throwList.len > fnType.throwList.len {
            if t.throwList.len > MAX_FN_THROWS {
                throw emitError(self, node, ErrorKind::FnThrowOverflow(CountMismatch {
                    expected: fnType.throwList.len,
                    expected: MAX_FN_THROWS,
                    actual: t.throwList.len,
                }));
            }

            for i in 0..t.params.len {
                let paramTy = try infer(self, t.params.list[i]);

                fnType.paramTypes[fnType.paramTypesLen] = allocType(self, paramTy);
                fnType.paramTypesLen += 1;
            for paramNode in t.params {
                let paramTy = try infer(self, paramNode);
                paramTypes.append(allocType(self, paramTy), a);
            }
            for i in 0..t.throwList.len {
                let tyNode = t.throwList.list[i];
            for tyNode in t.throwList {
                let throwTy = try infer(self, tyNode);

                fnType.throwList[fnType.throwListLen] = allocType(self, throwTy);
                fnType.throwListLen += 1;
                throwList.append(allocType(self, throwTy), a);
            }
            let mut retType = allocType(self, Type::Void);
            if let ret = t.returnType {
                fnType.returnType = allocType(self, try infer(self, ret));
            } else {
                fnType.returnType = allocType(self, Type::Void);
                retType = allocType(self, try infer(self, ret));
            }
            let fnType = FnType {
                paramTypes: &paramTypes[..],
                returnType: retType,
                throwList: &throwList[..],
                localCount: 0,
            };
            return Type::Fn(allocFnType(self, fnType));
        }
        case ast::TypeSig::TraitObject { traitName, mutable } => {
            let sym = try resolveNamePath(self, traitName);
            let case SymbolData::Trait(traitInfo) = sym.data


/// Analyze a standalone expression by wrapping it in a synthetic function.
pub fn resolveExpr(
    self: *mut Resolver, expr: *ast::Node, arena: *mut ast::NodeArena
) -> Diagnostics throws (ResolveError) {
    let mut bodyStmts = ast::nodeList(arena, 1);
    let a = ast::nodeAllocator(arena);
    let mut bodyStmts = ast::nodeSlice(arena, 1);
    let exprStmt = ast::synthNode(arena, ast::NodeValue::ExprStmt(expr));
    ast::nodeListPush(&mut bodyStmts, exprStmt);
    bodyStmts.append(exprStmt, a);
    let module = ast::synthFnModule(arena, ANALYZE_EXPR_FN_NAME, bodyStmts);

    let case ast::NodeValue::Block(block) = module.modBody.value
        else panic "resolveExpr: expected block for module body";
    enterScope(self, module.modBody);

/// and scopes for them, and also binds type names in each module so that cross-module
/// type references work regardless of declaration order.
fn resolveModuleGraph(self: *mut Resolver, block: *ast::Block) throws (ResolveError) {
    try bindTypeNames(self, block);

    for i in 0..block.statements.len {
        let node = block.statements.list[i];
    for node in block.statements {
        if let case ast::NodeValue::Mod(decl) = node.value {
            try resolveModGraph(self, node, decl);
        }
    }
}

/// Bind all type names in a module.
/// Skips declarations that have already been bound.
fn bindTypeNames(self: *mut Resolver, block: *ast::Block) throws (ResolveError) {
    for i in 0..block.statements.len {
        let node = block.statements.list[i];
    for node in block.statements {
        match node.value {
            case ast::NodeValue::RecordDecl(decl) => {
                if symbolFor(self, node) == nil {
                    try bindTypeName(self, node, decl.name, decl.attrs) catch {};
                }

    }
}

/// Resolve all type bodies in a module.
fn resolveTypeBodies(self: *mut Resolver, block: *ast::Block) throws (ResolveError) {
    for i in 0..block.statements.len {
        let node = block.statements.list[i];
    for node in block.statements {
        match node.value {
            case ast::NodeValue::RecordDecl(decl) => {
                try resolveRecordBody(self, node, decl) catch {
                    // Continue resolving other types even if one fails.
                };

                try resolveUnionBody(self, node, decl) catch {
                    // Continue resolving other types even if one fails.
                };
            }
            case ast::NodeValue::TraitDecl { supertraits, methods, .. } => {
                try resolveTraitBody(self, node, &supertraits, &methods) catch {
                try resolveTraitBody(self, node, supertraits, methods) catch {
                    // Continue resolving other types even if one fails.
                };
            }
            else => {
                // Ignore other declarations.

fn resolveModuleDecls(res: *mut Resolver, block: *ast::Block) throws (ResolveError) {
    // Phase 1: Bind all type names as placeholders.
    try bindTypeNames(res, block);
    // Phase 2: Process non-wildcard imports so module names are available
    // for submodule resolution and type lookups.
    for i in 0..block.statements.len {
        let node = block.statements.list[i];
    for node in block.statements {
        if let case ast::NodeValue::Use(decl) = node.value {
            if not decl.wildcard {
                try resolveUse(res, node, decl);
            }
        }
    }
    // Phase 3: Process submodule declarations -- recurses into child modules.
    // Child modules may trigger on-demand type resolution via
    // [`ensureNominalResolved`] which switches to the declaring module's
    // scope.
    for i in 0..block.statements.len {
        let node = block.statements.list[i];
    for node in block.statements {
        if let case ast::NodeValue::Mod(decl) = node.value {
            try resolveModDecl(res, node, decl);
        }
    }
    // Phase 3b: Process wildcard imports after submodules are resolved,
    // so that transitive re-exports (pub use foo::*) are visible.
    for i in 0..block.statements.len {
        let node = block.statements.list[i];
    for node in block.statements {
        if let case ast::NodeValue::Use(decl) = node.value {
            if decl.wildcard {
                try resolveUse(res, node, decl);
            }
        }
    }
    // Phase 4: Bind function signatures so that function references are
    // available in constant and static initializers.
    for i in 0..block.statements.len {
        let node = block.statements.list[i];
    for node in block.statements {
        if let case ast::NodeValue::FnDecl(decl) = node.value {
            try resolveFnDecl(res, node, decl);
        }
    }
    // Phase 5: Process constants.
    for i in 0..block.statements.len {
        let node = block.statements.list[i];
    for node in block.statements {
        if let case ast::NodeValue::ConstDecl(_) = node.value {
            try infer(res, node);
        }
    }
    // Phase 6: Resolve type bodies (record fields, union variants).
    try resolveTypeBodies(res, block);
    // Phase 7: Process all other declarations (statics, etc.).
    for i in 0..block.statements.len {
    for stmt in block.statements {
        // TODO: This error should propagate, since we catch errors in the `resolveModule` entry point.
        try visitDecl(res, block.statements.list[i]) catch {
        try visitDecl(res, stmt) catch {
            break;
        };
    }
}

/// Analyze module definitions. This pass analyzes function bodies, recursing into sub-modules.
fn resolveModuleDefs(self: *mut Resolver, block: *ast::Block) throws (ResolveError) {
    for i in 0..block.statements.len {
        let stmt = block.statements.list[i];
    for stmt in block.statements {
        try visitDef(self, stmt);
    }
}

/// Resolve all packages.

    let case ast::NodeValue::Block(block) = node.value
        else panic "resolvePackage: expected block for module root";

    // Module graph analysis phase: bind all module name symbols and scopes.
    try resolveModuleGraph(self, &block) catch {
        assert self.errors.listLen > 0, "resolvePackage: failure should have diagnostics";
        assert self.errors.len > 0, "resolvePackage: failure should have diagnostics";
        return Diagnostics { errors: self.errors };
    };

    // Declaration phase: bind all names and analyze top-level declarations.
    try resolveModuleDecls(self, &block) catch {
        assert self.errors.listLen > 0, "resolvePackage: failure should have diagnostics";
        assert self.errors.len > 0, "resolvePackage: failure should have diagnostics";
    };
    if self.errors.listLen > 0 {
    if self.errors.len > 0 {
        return Diagnostics { errors: self.errors };
    }

    // Definition phase: analyze function bodies and sub-module definitions.
    try resolveModuleDefs(self, &block) catch {
        assert self.errors.listLen > 0, "resolvePackage: failure should have diagnostics";
        assert self.errors.len > 0, "resolvePackage: failure should have diagnostics";
    };
    try setNodeType(self, node, Type::Void);

    return Diagnostics { errors: self.errors };
}

lib/std/lang/resolver/printer.rad +13 -13

            io::print("?");
            printTypeBody(*inner, brief);
        }
        case super::Type::Fn(fnType) => {
            io::print("fn(");
            for i in 0..fnType.paramTypesLen {
            for i in 0..fnType.paramTypes.len {
                if i > 0 {
                    io::print(", ");
                }
                printTypeName(*fnType.paramTypes[i]);
            }
            io::print(")");
            io::print(" -> ");
            printTypeName(*fnType.returnType);
            if fnType.throwListLen > 0 {
            if fnType.throwList.len > 0 {
                io::print(" throws ");
                for i in 0..fnType.throwListLen {
                for i in 0..fnType.throwList.len {
                    if i > 0 {
                        io::print(", ");
                    }
                    printTypeName(*fnType.throwList[i]);
                }

        case super::NominalType::Placeholder(_) => {
            io::print("<placeholder>");
        }
        case super::NominalType::Record(recordType) => {
            io::print("record {");
            if recordType.fieldsLen > 0 {
            if recordType.fields.len > 0 {
                io::print(" ");
                for i in 0..recordType.fieldsLen {
                for i in 0..recordType.fields.len {
                    if i > 0 {
                        io::print(", ");
                    }
                    let field = &recordType.fields[i];
                    if let name = field.name {
                        io::print(name);
                        io::print(": ");
                    }
                    printTypeName(field.fieldType);

                    if i >= 4 and i < recordType.fieldsLen - 1 {
                    if i >= 4 and i < recordType.fields.len - 1 {
                        io::print(", ...");
                        break;
                    }
                }
                io::print(" ");
            }
            io::print("}");
        }
        case super::NominalType::Union(unionType) => {
            io::print("union {");
            if unionType.variantsLen > 0 {
            if unionType.variants.len > 0 {
                io::print(" ");
                for i in 0..unionType.variantsLen {
                for i in 0..unionType.variants.len {
                    if i > 0 {
                        io::print(", ");
                    }
                    let variant = &unionType.variants[i];
                    io::print(variant.name);
                    io::print(": ");
                    printTypeName(variant.valueType);

                    if i >= 4 and i < unionType.variantsLen - 1 {
                    if i >= 4 and i < unionType.variants.len - 1 {
                        io::print(", ...");
                        break;
                    }
                }
                io::print(" ");

        io::print("<root>");
    }
    io::print("\n");
    printScope(scope, depth);

    for i in 0..res.nodeData.entries.len {
        if let childScopePtr = res.nodeData.entries[i].scope {
    for entry in res.nodeData.entries {
        if let childScopePtr = entry.scope {
            if childScopePtr.parent != nil and childScopePtr.parent == scope {
                printScopeTree(res, childScopePtr, depth + 1);
            }
        }
    }

    }
}

/// Entry point for printing resolver diagnostics in vim quickfix format.
pub fn printDiagnostics(diag: *super::Diagnostics, res: *super::Resolver) {
    for i in 0..diag.errors.listLen {
        printError(&diag.errors.list[i], res);
    for i in 0..diag.errors.len {
        printError(&diag.errors[i], res);
    }
}

lib/std/lang/resolver/tests.rad +21 -21

    try testing::expect(super::success(&r.diagnostics));
}

/// Extract the first error from a test result, failing if none exists.
fn expectError(result: *TestResult) -> *super::Error throws (testing::TestError) {
    let err = super::errorAt(&result.diagnostics.errors, 0)
    let err = super::errorAt(&result.diagnostics.errors[..], 0)
        else throw testing::TestError::Failed;
    return err;
}

/// Check if two error kinds match.

        else throw testing::TestError::Failed;

    if index >= body.statements.len {
        throw testing::TestError::Failed;
    }
    return body.statements.list[index];
    return body.statements[index];
}

/// Retrieve a function body block by function name from the program scope.
fn getFnBody(a: *super::Resolver, root: *ast::Node, name: *[u8]) -> ast::Block
    throws (testing::TestError)

/// Get the payload type of a union variant, if it has one.
/// For single-field unlabeled variants like `Variant(i32)`, unwraps to return the inner type.
fn getUnionVariantPayload(nominalTy: *super::NominalType, variantName: *[u8]) -> super::Type {
    let case super::NominalType::Union(unionType) = *nominalTy
        else panic "getUnionVariantPayload: not a union";
    for i in 0..unionType.variantsLen {
    for i in 0..unionType.variants.len {
        if mem::eq(unionType.variants[i].name, variantName) {
            let payloadType = unionType.variants[i].valueType;
            // Unwrap single-field unlabeled records to get the inner type.
            if let case super::Type::Nominal(nominalInfo) = payloadType {
                if let case super::NominalType::Record(recInfo) = *nominalInfo {
                    if not recInfo.labeled and recInfo.fieldsLen == 1 {
                    if not recInfo.labeled and recInfo.fields.len == 1 {
                        return recInfo.fields[0].fieldType;
                    }
                }
            }
            return payloadType;

    try expectNoErrors(&result);

    let fnBlock = try getFnBody(&a, result.root, "f");
    try testing::expect(fnBlock.statements.len > 0);

    let matchNode = fnBlock.statements.list[0];
    let matchNode = fnBlock.statements[0];
    let case ast::NodeValue::Match(sw) = matchNode.value
        else throw testing::TestError::Failed;
    let caseNode = sw.prongs.list[0];
    let caseNode = sw.prongs[0];

    let scope = super::scopeFor(&a, caseNode)
        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;

        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;

        let case super::Type::Fn(fnTy) = valType
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypesLen == 0);
        try testing::expect(fnTy.paramTypes.len == 0);
        try testing::expect(*fnTy.returnType == super::Type::Void);
    }
    { // Checking that the type of the call matches the function return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);


            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;
        let case super::Type::Fn(fnTy) = valType
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypesLen == 0);
        try testing::expect(fnTy.paramTypes.len == 0);
        try testing::expect(*fnTy.returnType == super::Type::I32);
    }
    { // Call expression should inherit the function's return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::I32);


            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;
        let case super::Type::Fn(fnTy) = valType
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypesLen == 1);
        try testing::expect(fnTy.paramTypes.len == 1);
        try testing::expect(*fnTy.paramTypes[0] == super::Type::I8);
        try testing::expect(*fnTy.returnType == super::Type::Void);

        let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
            else throw testing::TestError::Failed;
        try testing::expect(fnDecl.sig.params.len == 1);

        let paramNode = fnDecl.sig.params.list[0];
        let paramNode = fnDecl.sig.params[0];
        try expectType(&a, paramNode, super::Type::I8);
    }
    { // Call should resolve to void, matching the function's return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);
        let fnSym = super::symbolFor(&a, fnNode)

            else throw testing::TestError::Failed;
        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;
        let case super::Type::Fn(fnTy) = valType
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypesLen == 2);
        try testing::expect(fnTy.paramTypes.len == 2);
        try testing::expect(*fnTy.paramTypes[0] == super::Type::I8);
        try testing::expect(*fnTy.paramTypes[1] == super::Type::I32);
        try testing::expect(*fnTy.returnType == super::Type::Void);

        let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
            else throw testing::TestError::Failed;
        try testing::expect(fnDecl.sig.params.len == 2);

        let firstParam = fnDecl.sig.params.list[0];
        let secondParam = fnDecl.sig.params.list[1];
        let firstParam = fnDecl.sig.params[0];
        let secondParam = fnDecl.sig.params[1];
        try expectType(&a, firstParam, super::Type::I8);
        try expectType(&a, secondParam, super::Type::I32);
    }
    { // Call expression should again mirror the function return type.
        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);

        let case super::SymbolData::Value { type: valType, .. } = sym.data
            else throw testing::TestError::Failed;

        let case super::Type::Fn(fnTy) = valType
            else throw testing::TestError::Failed;
        try testing::expect(fnTy.paramTypesLen == 1);
        try testing::expect(fnTy.paramTypes.len == 1);
        try testing::expect(*fnTy.paramTypes[0] == super::Type::Bool);
        try testing::expect(*fnTy.returnType == super::Type::Bool);
    }
}


    // Verify the type symbol was created with labeled=false.
    let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
    let case super::NominalType::Record(recordType) = *nominalTy
        else throw testing::TestError::Failed;
    try testing::expect(not recordType.labeled);
    try testing::expect(recordType.fieldsLen == 2);
    try testing::expect(recordType.fields.len == 2);
    try testing::expect(recordType.fields[0].name == nil);
    try testing::expect(recordType.fields[1].name == nil);
}

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


    let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
    let case super::NominalType::Record(recordType) = *nominalTy
        else throw testing::TestError::Failed;
    try testing::expect(recordType.labeled);
    try testing::expect(recordType.fieldsLen == 2);
    try testing::expect(recordType.fields.len == 2);
    try testing::expect(recordType.fields[0].name != nil);
    try testing::expect(recordType.fields[1].name != nil);
}

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

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

    let ty = try getTypeInScopeOf(&a, result.root, "Status");
    let case super::NominalType::Union(unionType) = *ty
        else throw testing::TestError::Failed;
    try testing::expect(unionType.variantsLen == 2);
    try testing::expect(unionType.variants.len == 2);
    try testing::expect(mem::eq(unionType.variants[0].name, "Ok"));
    try testing::expect(mem::eq(unionType.variants[1].name, "Error"));
    if getUnionVariantPayload(ty, "Ok") != super::Type::Void {
        throw testing::TestError::Failed;
    }

    let program = "union Opt { Some(i32), None } fn f() { let opt = Opt::Some(42); match &opt { case Opt::Some(x) => { *x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let fnBlock = try getFnBody(&a, result.root, "f");
    let matchNode = fnBlock.statements.list[1];
    let matchNode = fnBlock.statements[1];
    let case ast::NodeValue::Match(sw) = matchNode.value
        else throw testing::TestError::Failed;
    let caseNode = sw.prongs.list[0];
    let caseNode = sw.prongs[0];

    let scope = super::scopeFor(&a, caseNode)
        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;

    let program = "union Opt { Some(i32), None } fn f() { let mut opt = Opt::Some(42); match &mut opt { case Opt::Some(x) => { *x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);

    let fnBlock = try getFnBody(&a, result.root, "f");
    let matchNode = fnBlock.statements.list[1];
    let matchNode = fnBlock.statements[1];
    let case ast::NodeValue::Match(sw) = matchNode.value
        else throw testing::TestError::Failed;
    let caseNode = sw.prongs.list[0];
    let caseNode = sw.prongs[0];

    let scope = super::scopeFor(&a, caseNode)
        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;

514	514		let case ast::NodeValue::Block(block) = modAst.value else {
515	515		return;
516	516		};
517	517		let modPath = module::moduleQualifiedPath(entry);
518	518
519		-	for i in 0..block.statements.len {
520		-	let stmt = block.statements.list[i];
	519	+	for stmt in block.statements {
521	520		if let case ast::NodeValue::FnDecl(decl) = stmt.value {
522	521		if let fnName = getTestFnName(&decl) {
523	522		if *testCount < tests.len {
524	523		tests[*testCount] = TestDesc { modPath, fnName };
525	524		*testCount += 1;

548	547		funcPath[j - 1] = desc.modPath[j];
549	548		}
550	549		funcPath[desc.modPath.len - 1] = desc.fnName;
551	550		let funcArg = synthScopeAccess(arena, &funcPath[..desc.modPath.len]);
552	551
553		-	let mut args = ast::nodeList(arena, 3);
554		-	ast::nodeListPush(&mut args, modArg);
555		-	ast::nodeListPush(&mut args, nameArg);
556		-	ast::nodeListPush(&mut args, funcArg);
	552	+	let a = ast::nodeAllocator(arena);
	553	+	let mut args = ast::nodeSlice(arena, 3);
	554	+	args.append(modArg, a);
	555	+	args.append(nameArg, a);
	556	+	args.append(funcArg, a);
557	557
558	558		return ast::synthNode(arena, ast::NodeValue::Call(ast::Call { callee, args }));
559	559		}
560	560
561	561		/// Inject a test runner into the entry package's root module.

604	604		}
605	605
606	606		/// Synthesize the test entry point.
607	607		fn synthTestMainFn(arena: mut ast::NodeArena, tests: [TestDesc]) -> *ast::Node {
608	608		// Build array literal: `[testing::test(...), ...]`.
609		-	let mut elements = ast::nodeList(arena, tests.len);
	609	+	let a = ast::nodeAllocator(arena);
	610	+	let mut elements = ast::nodeSlice(arena, tests.len as u32);
610	611		for i in 0..tests.len {
611		-	ast::nodeListPush(&mut elements, synthTestCall(arena, &tests[i]));
	612	+	elements.append(synthTestCall(arena, &tests[i]), a);
612	613		}
613	614		let arrayLit = ast::synthNode(arena, ast::NodeValue::ArrayLit(elements));
614	615
615	616		// Build: `&[...]`.
616	617		let testsRef = ast::synthNode(arena, ast::NodeValue::AddressOf(ast::AddressOf {
617	618		target: arrayLit, mutable: false,
618	619		}));
619	620
620	621		// Build: `testing::runAllTests(&[...])`.
621	622		let runFn = synthScopeAccess(arena, &["testing", "runAllTests"]);
622		-	let mut callArgs = ast::nodeList(arena, 1);
623		-	ast::nodeListPush(&mut callArgs, testsRef);
	623	+	let mut callArgs = ast::nodeSlice(arena, 1);
	624	+	callArgs.append(testsRef, a);
624	625		let callExpr = ast::synthNode(arena, ast::NodeValue::Call(ast::Call {
625	626		callee: runFn, args: callArgs,
626	627		}));
627	628
628	629		// Build: `return testing::runAllTests(&[...]);`
629	630		let retStmt = ast::synthNode(arena, ast::NodeValue::Return { value: callExpr });
630		-	let mut bodyStmts = ast::nodeList(arena, 1);
631		-	ast::nodeListPush(&mut bodyStmts, retStmt);
	631	+	let mut bodyStmts = ast::nodeSlice(arena, 1);
	632	+	bodyStmts.append(retStmt, a);
632	633		let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block { statements: bodyStmts }));
633	634
634	635		// Build: `fn #testMain() -> i32`
635	636		let fnName = ast::synthNode(arena, ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, "#testMain")));
636	637		let returnType = ast::synthNode(arena, ast::NodeValue::TypeSig(ast::TypeSig::Integer {
637	638		width: 4, sign: ast::Signedness::Signed,
638	639		}));
639	640		let fnSig = ast::FnSig {
640		-	params: ast::nodeList(arena, 0),
	641	+	params: ast::nodeSlice(arena, 0),
641	642		returnType,
642		-	throwList: ast::nodeList(arena, 0),
	643	+	throwList: ast::nodeSlice(arena, 0),
643	644		};
644	645
645	646		// `@default` attribute.
646	647		let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));
647		-	let mut attrList = ast::nodeList(arena, 1);
648		-	ast::nodeListPush(&mut attrList, attrNode);
	648	+	let mut attrList = ast::nodeSlice(arena, 1);
	649	+	attrList.append(attrNode, a);
649	650		let fnAttrs = ast::Attributes { list: attrList };
650	651
651	652		return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
652	653		name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
653	654		}));

661	662		) {
662	663		let case ast::NodeValue::Block(block) = blockNode.value else {
663	664		panic "injectIntoBlock: expected Block node";
664	665		};
665	666		let mut stmts = block.statements;
666		-	ast::nodeListGrow(&mut stmts, arena, 1);
667		-	ast::nodeListPush(&mut stmts, decl);
	667	+	stmts.append(decl, ast::nodeAllocator(arena));
668	668
669	669		blockNode.value = ast::NodeValue::Block(ast::Block { statements: stmts });
670	670		}
671	671
672	672		/// Write code buffer to file as raw bytes.

771	771		throw Error::Other;
772	772		};
773	773		if not resolver::success(&diags) {
774	774		resolver::printer::printDiagnostics(&diags, &res);
775	775		io::print("radiance: failed: ");
776		-	io::printU32(diags.errors.listLen);
	776	+	io::printU32(diags.errors.len);
777	777		io::printLn(" errors");
778	778		throw Error::Other;
779	779		}
780	780		return res;
781	781		}

135	135		return getReg(s, ssa);
136	136		}
137	137
138	138		/// Look up symbol address in data map.
139	139		fn lookupDataSym(s: Selector, name: [u8]) -> u32 throws (SelectorError) {
140		-	for i in 0..s.dataSyms.len {
141		-	let sym = s.dataSyms[i];
142		-
	140	+	for sym in s.dataSyms {
143	141		if mem::eq(sym.name, name) {
144	142		return sym.addr;
145	143		}
146	144		}
147	145		throw SelectorError::Internal;

233	231		/// Returns the total size needed for all static reserves, respecting alignment.
234	232		fn computeReserveSize(func: *il::Fn) -> i32 {
235	233		let mut offset: i32 = 0;
236	234		for b in 0..func.blocks.len {
237	235		let block = &func.blocks[b];
238		-	for i in 0..block.instrs.len {
239		-	match block.instrs.list[i] {
	236	+	for instr in block.instrs {
	237	+	match instr {
240	238		case il::Instr::Reserve { size, alignment, .. } => {
241	239		if let case il::Val::Imm(sz) = size {
242	240		offset = mem::alignUpI32(offset, alignment as i32);
243	241		offset += (sz as i32);
244	242		}

323	321		// Record debug location before emitting machine instructions.
324	322		if hasLocs {
325	323		emit::recordSrcLoc(s.e, block.locs[i]);
326	324		}
327	325		s.pendingSpill = nil;
328		-	selectInstr(s, blockIdx, block.instrs.list[i], frame, func);
	326	+	selectInstr(s, blockIdx, block.instrs[i], frame, func);
329	327
330	328		// Flush the pending spill store, if any.
331	329		if let p = s.pendingSpill {
332	330		if let slot = regalloc::spill::spillSlot(&s.ralloc.spill, p.ssa) {
333	331		emit::emitSd(s.e, p.rd, super::FP, spillOffset(s, slot));

102	102		let ptr = try alloc(arena, size * count, alignment);
103	103
104	104		return @sliceOf(ptr, count);
105	105		}
106	106
107		-	/// Grow a slice to accommodate more elements.
108		-	///
109		-	/// Allocates new storage with double the current capacity, copies existing
110		-	/// elements, and returns the new slice. Old storage remains allocated.
111		-	pub fn growSlice(arena: mut Arena, old: mut [opaque], len: u32, size: u32, alignment: u32) -> *mut [opaque] throws (AllocError) {
112		-	let mut newCap = old.len * 2;
113		-	if newCap == 0 {
114		-	newCap = 1;
115		-	}
116		-	let new = try allocSlice(arena, size, alignment, newCap);
117		-
118		-	// Copy existing elements (byte-wise).
119		-	let oldBytes = @sliceOf(old.ptr as u8, len size);
120		-	let newBytes = @sliceOf(new.ptr as mut u8, len size);
121		-	for i in 0..len * size {
122		-	newBytes[i] = oldBytes[i];
123		-	}
124		-	return new;
125		-	}
126		-
127	107		/// Generic allocator interface.
128	108		///
129	109		/// Bundles an allocation function with an opaque context pointer so that
130	110		/// any allocation strategy (arena, free-list, mmap, pool) can be used
131	111		/// through a uniform interface. The `func` field is called with the context

18	18		arena: alloc::Arena,
19	19		/// Next node ID to assign. Incremented on each node allocation.
20	20		nextId: u32,
21	21		}
22	22
23		-	/// List of node pointers that tracks its length.
24		-	pub record NodeList {
25		-	/// Slice of node pointers.
26		-	list: mut [Node],
27		-	/// Number of elements currently in the list.
28		-	len: u32,
29		-	}
30		-
31	23		/// Initialize a node arena backed by the given byte slice.
32	24		pub fn nodeArena(data: *mut [u8]) -> NodeArena {
33	25		return NodeArena {
34	26		arena: alloc::new(data),
35	27		nextId: 0,
36	28		};
37	29		}
38	30
39		-	/// Create a new node list in the arena with the specified capacity.
40		-	pub fn nodeList(arena: *mut NodeArena, capacity: u32) -> NodeList {
	31	+	/// Create an empty `mut [Node]` slice with the given capacity.
	32	+	pub fn nodeSlice(arena: mut NodeArena, capacity: u32) -> mut [*Node] {
41	33		if capacity == 0 {
42		-	// Return an empty list without allocating.
43		-	return NodeList { list: undefined, len: 0 };
	34	+	return &mut [];
44	35		}
45	36		let ptr = try! alloc::allocSlice(&mut arena.arena, @sizeOf(Node), @alignOf(Node), capacity);
46		-	let list = ptr as mut [Node];
47	37
48		-	return NodeList { list, len: 0 };
	38	+	return @sliceOf(ptr.ptr as mut Node, 0, capacity);
49	39		}
50	40
51		-	/// Push a node to the end of the list.
52		-	pub fn nodeListPush(self: mut NodeList, node: Node) -> u32 {
53		-	if self.len >= self.list.len {
54		-	panic "nodeListPush: out of space";
55		-	}
56		-	self.list[self.len] = node;
57		-	self.len += 1;
58		-
59		-	return self.len;
60		-	}
61		-
62		-	/// Grow a node list's backing storage by `extra` slots.
63		-	///
64		-	/// Allocates a new backing array of size `self.len + extra`, copies existing
65		-	/// node pointers, and updates `self.list`. Existing node data is not copied.
66		-	pub fn nodeListGrow(self: mut NodeList, arena: mut NodeArena, extra: u32) {
67		-	if self.list.len - self.len >= extra {
68		-	return;
69		-	}
70		-	let newCap = self.len + extra;
71		-	let ptr = try! alloc::allocSlice(&mut arena.arena, @sizeOf(Node), @alignOf(Node), newCap);
72		-	let newList = ptr as mut [Node];
73		-
74		-	for i in 0..self.len {
75		-	newList[i] = self.list[i];
76		-	}
77		-	self.list = newList;
	41	+	/// Return an allocator backed by the node arena.
	42	+	// TODO: Why do we need this?
	43	+	pub fn nodeAllocator(arena: *mut NodeArena) -> alloc::Allocator {
	44	+	return alloc::arenaAllocator(&mut arena.arena);
78	45		}
79	46
80	47		/// Attribute bit set applied to declarations or fields.
81	48		pub union Attribute {
82	49		/// Public visibility attribute.

91	58		Intrinsic = 0b10000,
92	59		}
93	60
94	61		/// Ordered collection of attribute nodes applied to a declaration.
95	62		pub record Attributes {
96		-	list: NodeList,
97		-	}
98		-
99		-	/// Append an attribute node to the list.
100		-	pub fn attributesPush(self: mut Attributes, attr: Node) -> u32 {
101		-	return nodeListPush(&mut self.list, attr);
102		-	}
103		-
104		-	/// Return the number of attributes stored in the list.
105		-	pub fn attributesLen(self: *Attributes) -> u32 {
106		-	return self.list.len;
107		-	}
108		-
109		-	/// Fetch the attribute node at the specified index.
110		-	pub fn attributesGet(self: Attributes, index: u32) -> Node {
111		-	assert index < self.list.len, "attributesGet: invalid index";
112		-	return self.list.list[index];
	63	+	list: mut [Node],
113	64		}
114	65
115	66		/// Check if an attributes list contains an attribute.
116	67		pub fn attributesContains(self: *Attributes, attr: Attribute) -> bool {
117		-	for i in 0..self.list.len {
118		-	let node = attributesGet(self, i);
	68	+	for node in self.list {
119	69		if let case NodeValue::Attribute(a) = node.value; a == attr {
120	70		return true;
121	71		}
122	72		}
123	73		return false;

276	226		/// Nominal type, points to identifier node.
277	227		Nominal(*Node),
278	228		/// Inline record type for union variant payloads.
279	229		Record {
280	230		/// Field declaration nodes.
281		-	fields: NodeList,
	231	+	fields: mut [Node],
282	232		/// Whether this record has labeled fields.
283	233		labeled: bool,
284	234		},
285	235		/// Anonymous function type.
286	236		Fn(FnSig),

294	244		}
295	245
296	246		/// Function signature.
297	247		pub record FnSig {
298	248		/// Parameter type nodes in declaration order.
299		-	params: NodeList,
	249	+	params: mut [Node],
300	250		/// Optional return type node.
301	251		returnType: ?*Node,
302	252		/// Throwable type nodes declared in the signature.
303		-	throwList: NodeList,
	253	+	throwList: mut [Node],
304	254		}
305	255
306	256		/// Address-of expression metadata.
307	257		pub record AddressOf {
308	258		/// Target expression being referenced.

312	262		}
313	263
314	264		/// Compound statement block with optional dedicated scope.
315	265		pub record Block {
316	266		/// Statements that belong to this block.
317		-	statements: NodeList,
	267	+	statements: mut [Node],
318	268		}
319	269
320	270		/// Function call expression.
321	271		pub record Call {
322	272		/// Callee expression.
323	273		callee: *Node,
324	274		/// Argument expressions in source order.
325		-	args: NodeList,
	275	+	args: mut [Node],
326	276		}
327	277
328	278		/// Single argument to a function or record literal, optionally labeled.
329	279		pub record Arg {
330	280		/// Optional label applied to the argument.

364	314		/// Try expression metadata.
365	315		pub record Try {
366	316		/// Expression evaluated with implicit error propagation.
367	317		expr: *Node,
368	318		/// Catch clauses. Empty for propagation (`try`), `try!`, or `try?`.
369		-	catches: NodeList,
	319	+	catches: mut [Node],
370	320		/// Whether the try should panic instead of returning an error.
371	321		shouldPanic: bool,
372	322		/// Whether the try should return an optional instead of propagating error.
373	323		returnsOptional: bool,
374	324		}

426	376		}
427	377
428	378		/// Prong arm.
429	379		pub union ProngArm {
430	380		/// Case arm with pattern list.
431		-	Case(NodeList),
	381	+	Case(mut [Node]),
432	382		/// Binding arm with single identifier or placeholder.
433	383		Binding(*Node),
434	384		/// Else arm.
435	385		Else,
436	386		}

468	418		/// `match` statement metadata.
469	419		pub record Match {
470	420		/// Expression whose value controls the match.
471	421		subject: *Node,
472	422		/// Prong nodes evaluated in order.
473		-	prongs: NodeList,
	423	+	prongs: mut [Node],
474	424		}
475	425
476	426		/// `match` prong metadata.
477	427		pub record MatchProng {
478	428		/// Prong arm.

533	483		pub record RecordLit {
534	484		/// Type name associated with the literal.
535	485		/// If `nil`, it's an anonymous record literal.
536	486		typeName: ?*Node,
537	487		/// Field initializer nodes.
538		-	fields: NodeList,
	488	+	fields: mut [Node],
539	489		/// When true, remaining fields are discarded (`{ x, .. }`).
540	490		ignoreRest: bool,
541	491		}
542	492
543	493		/// Record declaration.
544	494		pub record RecordDecl {
545	495		/// Identifier naming the record.
546	496		name: *Node,
547	497		/// Field declaration nodes.
548		-	fields: NodeList,
	498	+	fields: mut [Node],
549	499		/// Optional attribute list applied to the record.
550	500		attrs: ?Attributes,
551	501		/// Trait derivations attached to the record.
552		-	derives: NodeList,
	502	+	derives: mut [Node],
553	503		/// Whether this record has labeled fields.
554	504		labeled: bool,
555	505		}
556	506
557	507		/// Union declarations.
558	508		pub record UnionDecl {
559	509		/// Identifier naming the union.
560	510		name: *Node,
561	511		/// Variant nodes making up the union.
562		-	variants: NodeList,
	512	+	variants: mut [Node],
563	513		/// Optional attribute list applied to the union.
564	514		attrs: ?Attributes,
565	515		/// Trait derivations attached to the union.
566		-	derives: NodeList,
	516	+	derives: mut [Node],
567	517		}
568	518
569	519		/// Union variant declaration.
570	520		pub record UnionDeclVariant {
571	521		/// Identifier naming the variant.

677	627		/// Numeric literal such as `42` or `0xFF`.
678	628		Number(IntLiteral),
679	629		/// Range expression such as `0..10` or `..`.
680	630		Range(Range),
681	631		/// Array literal expression.
682		-	ArrayLit(NodeList),
	632	+	ArrayLit(mut [Node]),
683	633		/// Array repeat literal expression.
684	634		ArrayRepeatLit(ArrayRepeatLit),
685	635		/// Array subscript expression.
686	636		Subscript {
687	637		/// Array or slice.

696	646		/// Builtin function call (e.g. `@sizeOf(T)`).
697	647		BuiltinCall {
698	648		/// Builtin function kind.
699	649		kind: Builtin,
700	650		/// Argument list.
701		-	args: NodeList,
	651	+	args: mut [Node],
702	652		},
703	653		/// Block expression or statement body.
704	654		Block(Block),
705	655		/// Call expression, eg. `f(x)`.
706	656		Call(Call),

818	768		/// Trait declaration.
819	769		TraitDecl {
820	770		/// Trait name identifier.
821	771		name: *Node,
822	772		/// Supertrait name nodes.
823		-	supertraits: NodeList,
	773	+	supertraits: mut [Node],
824	774		/// Method signature nodes ([`TraitMethodSig`]).
825		-	methods: NodeList,
	775	+	methods: mut [Node],
826	776		/// Optional attributes.
827	777		attrs: ?Attributes,
828	778		},
829	779		/// Method signature inside a trait declaration.
830	780		TraitMethodSig {

840	790		/// Trait name identifier.
841	791		traitName: *Node,
842	792		/// Target type identifier.
843	793		targetType: *Node,
844	794		/// Method definition nodes ([`InstanceMethodDecl`]).
845		-	methods: NodeList,
	795	+	methods: mut [Node],
846	796		},
847	797		/// Method definition inside an instance block.
848	798		InstanceMethodDecl {
849	799		/// Method name identifier.
850	800		name: *Node,

894	844		fnBody: *Node
895	845		}
896	846
897	847		/// Synthesize a module with a function in it with the given name and statements.
898	848		pub fn synthFnModule(
899		-	arena: mut NodeArena, name: [u8], bodyStmts: NodeList
	849	+	arena: mut NodeArena, name: [u8], bodyStmts: mut [Node]
900	850		) -> SynthFnMod {
	851	+	let a = nodeAllocator(arena);
901	852		let fnName = synthNode(arena, NodeValue::Ident(name));
902		-	let params = nodeList(arena, 0);
903		-	let throwList = nodeList(arena, 0);
	853	+	let params: mut [Node] = &mut [];
	854	+	let throwList: mut [Node] = &mut [];
904	855		let fnSig = FnSig { params, returnType: nil, throwList };
905	856		let fnBody = synthNode(arena, NodeValue::Block(Block { statements: bodyStmts }));
906	857		let fnDecl = synthNode(arena, NodeValue::FnDecl(FnDecl {
907	858		name: fnName, sig: fnSig, body: fnBody, attrs: nil,
908	859		}));
909		-	let mut rootStmts = nodeList(arena, 1);
910		-	nodeListPush(&mut rootStmts, fnDecl);
	860	+	let mut rootStmts: mut [Node] = &mut [];
	861	+	rootStmts.append(fnDecl, a);
911	862		let modBody = synthNode(arena, NodeValue::Block(Block { statements: rootStmts }));
912	863
913	864		return SynthFnMod { modBody, fnBody };
914	865		}

85	85		else sexpr::list(a, "ptr", &[toExpr(a, valueType)]),
86	86		case super::TypeSig::Optional { valueType } =>
87	87		return sexpr::list(a, "?", &[toExpr(a, valueType)]),
88	88		case super::TypeSig::Nominal(name) => return toExpr(a, name),
89	89		case super::TypeSig::Record { fields, .. } =>
90		-	return sexpr::list(a, "record", nodeListToExprs(a, &fields)),
	90	+	return sexpr::list(a, "record", nodeListToExprs(a, &fields[..])),
91	91		case super::TypeSig::Fn(sig) => {
92	92		let mut ret = sexpr::sym("void");
93	93		if let rt = sig.returnType {
94	94		ret = toExpr(a, rt);
95	95		}
96		-	return sexpr::list(a, "fn", &[sexpr::list(a, "params", nodeListToExprs(a, &sig.params)), ret]);
	96	+	return sexpr::list(a, "fn", &[sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..])), ret]);
97	97		}
98	98		case super::TypeSig::TraitObject { traitName, mutable } =>
99	99		return sexpr::list(a, "obj", &[sexpr::sym("mut"), toExpr(a, traitName)]) if mutable
100	100		else sexpr::list(a, "obj", &[toExpr(a, traitName)]),
101	101		}
102	102		}
103	103
104		-	/// Convert a node list to a slice of expressions.
105		-	fn nodeListToExprs(a: mut alloc::Arena, nodes: super::NodeList) -> *[sexpr::Expr] {
	104	+	/// Convert a node slice to a slice of expressions.
	105	+	fn nodeListToExprs(a: mut alloc::Arena, nodes: [super::Node]) -> [sexpr::Expr] {
106	106		if nodes.len == 0 {
107	107		return &[];
108	108		}
109		-	let buf = try! sexpr::allocExprs(a, nodes.len);
	109	+	let buf = try! sexpr::allocExprs(a, nodes.len as u32);
110	110		for i in 0..nodes.len {
111		-	buf[i] = toExpr(a, nodes.list[i]);
	111	+	buf[i] = toExpr(a, nodes[i]);
112	112		}
113	113		return buf;
114	114		}
115	115
116	116		/// Convert an optional node to an expression, or return placeholder.

136	136		}
137	137		return sexpr::Expr::Null;
138	138		}
139	139
140	140		/// Convert a list of match prongs to expressions.
141		-	fn prongListToExprs(a: mut alloc::Arena, nodes: super::NodeList) -> *[sexpr::Expr] {
	141	+	fn prongListToExprs(a: mut alloc::Arena, nodes: [super::Node]) -> [sexpr::Expr] {
142	142		if nodes.len == 0 {
143	143		return &[];
144	144		}
145		-	let buf = try! sexpr::allocExprs(a, nodes.len);
	145	+	let buf = try! sexpr::allocExprs(a, nodes.len as u32);
146	146		for i in 0..nodes.len {
147		-	let prong = nodes.list[i];
	147	+	let prong = nodes[i];
148	148		match prong.value {
149	149		case super::NodeValue::MatchProng(p) => {
150	150		buf[i] = prongToExpr(a, p);
151	151		}
152	152		else => {

160	160		/// Convert a match prong to an S-expression.
161	161		fn prongToExpr(a: *mut alloc::Arena, p: super::MatchProng) -> sexpr::Expr {
162	162		match p.arm {
163	163		case super::ProngArm::Case(patterns) => {
164	164		return sexpr::block(a, "case", &[
165		-	sexpr::list(a, "patterns", nodeListToExprs(a, &patterns)),
	165	+	sexpr::list(a, "patterns", nodeListToExprs(a, &patterns[..])),
166	166		guardExpr(a, p.guard)
167	167		], &[toExpr(a, p.body)]);
168	168		}
169	169		case super::ProngArm::Else => {
170	170		return sexpr::block(a, "else", &[guardExpr(a, p.guard)], &[toExpr(a, p.body)]);

187	187		) -> sexpr::Expr {
188	188		return sexpr::list(a, ":", &[toExprOpt(a, field), toExpr(a, type), toExprOrNull(a, value)]);
189	189		}
190	190
191	191		/// Convert a list of record fields to expressions.
192		-	fn fieldListToExprs(a: mut alloc::Arena, nodes: super::NodeList) -> *[sexpr::Expr] {
	192	+	fn fieldListToExprs(a: mut alloc::Arena, nodes: [super::Node]) -> [sexpr::Expr] {
193	193		if nodes.len == 0 {
194	194		return &[];
195	195		}
196		-	let buf = try! sexpr::allocExprs(a, nodes.len);
	196	+	let buf = try! sexpr::allocExprs(a, nodes.len as u32);
197	197		for i in 0..nodes.len {
198		-	let node = nodes.list[i];
	198	+	let node = nodes[i];
199	199		match node.value {
200	200		case super::NodeValue::RecordField { field, type, value } => {
201	201		buf[i] = fieldToExpr(a, field, type, value);
202	202		}
203	203		else => {

212	212		fn variantToExpr(a: mut alloc::Arena, name: super::Node, type: ?*super::Node) -> sexpr::Expr {
213	213		return sexpr::list(a, "variant", &[toExpr(a, name), toExprOrNull(a, type)]);
214	214		}
215	215
216	216		/// Convert a list of union variants to expressions.
217		-	fn variantListToExprs(a: mut alloc::Arena, nodes: super::NodeList) -> *[sexpr::Expr] {
	217	+	fn variantListToExprs(a: mut alloc::Arena, nodes: [super::Node]) -> [sexpr::Expr] {
218	218		if nodes.len == 0 {
219	219		return &[];
220	220		}
221		-	let buf = try! sexpr::allocExprs(a, nodes.len);
	221	+	let buf = try! sexpr::allocExprs(a, nodes.len as u32);
222	222		for i in 0..nodes.len {
223		-	let node = nodes.list[i];
	223	+	let node = nodes[i];
224	224		match node.value {
225	225		case super::NodeValue::UnionDeclVariant(v) => {
226	226		buf[i] = variantToExpr(a, v.name, v.type);
227	227		}
228	228		else => {

257	257		case super::NodeValue::BinOp(b) =>
258	258		return sexpr::list(a, binOpName(b.op), &[toExpr(a, b.left), toExpr(a, b.right)]),
259	259		case super::NodeValue::UnOp(u) =>
260	260		return sexpr::list(a, unOpName(u.op), &[toExpr(a, u.value)]),
261	261		case super::NodeValue::Call(c) => {
262		-	let buf = try! sexpr::allocExprs(a, c.args.len + 1);
	262	+	let buf = try! sexpr::allocExprs(a, c.args.len as u32 + 1);
263	263		buf[0] = toExpr(a, c.callee);
264		-	for i in 0..c.args.len { buf[i + 1] = toExpr(a, c.args.list[i]); }
	264	+	for i in 0..c.args.len { buf[i + 1] = toExpr(a, c.args[i]); }
265	265		return sexpr::Expr::List { head: "call", tail: buf, multiline: false };
266	266		}
267	267		case super::NodeValue::BuiltinCall { kind, args } =>
268		-	return sexpr::list(a, builtinName(kind), nodeListToExprs(a, &args)),
	268	+	return sexpr::list(a, builtinName(kind), nodeListToExprs(a, &args[..])),
269	269		case super::NodeValue::Subscript { container, index } =>
270	270		return sexpr::list(a, "[]", &[toExpr(a, container), toExpr(a, index)]),
271	271		case super::NodeValue::FieldAccess(acc) =>
272	272		return sexpr::list(a, ".", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),
273	273		case super::NodeValue::ScopeAccess(acc) =>

278	278		case super::NodeValue::Deref(target) =>
279	279		return sexpr::list(a, "deref", &[toExpr(a, target)]),
280	280		case super::NodeValue::As(cast) =>
281	281		return sexpr::list(a, "as", &[toExpr(a, cast.value), toExpr(a, cast.type)]),
282	282		case super::NodeValue::ArrayLit(elems) =>
283		-	return sexpr::list(a, "array", nodeListToExprs(a, &elems)),
	283	+	return sexpr::list(a, "array", nodeListToExprs(a, &elems[..])),
284	284		case super::NodeValue::ArrayRepeatLit(rep) =>
285	285		return sexpr::list(a, "array-repeat", &[toExpr(a, rep.item), toExpr(a, rep.count)]),
286	286		case super::NodeValue::RecordLit(lit) => {
287		-	let mut total: u32 = lit.fields.len;
	287	+	let mut total: u32 = lit.fields.len as u32;
288	288		if let _ = lit.typeName {
289	289		total += 1;
290	290		}
291	291		let buf = try! sexpr::allocExprs(a, total);
292	292		let mut idx: u32 = 0;
293	293		if let tn = lit.typeName {
294	294		buf[idx] = toExpr(a, tn); idx = idx + 1;
295	295		}
296	296		for i in 0..lit.fields.len {
297		-	buf[idx + i] = toExpr(a, lit.fields.list[i]);
	297	+	buf[idx + i] = toExpr(a, lit.fields[i]);
298	298		}
299	299		return sexpr::Expr::List { head: "record-lit", tail: buf, multiline: lit.fields.len > 2 };
300	300		}
301	301		case super::NodeValue::RecordLitField(f) =>
302	302		return sexpr::list(a, "field", &[toExprOpt(a, f.label), toExpr(a, f.value)]),

314	314		}
315	315		case super::NodeValue::Try(t) => {
316	316		let mut head = "try";
317	317		if t.shouldPanic { head = "try!"; }
318	318		if t.catches.len > 0 {
319		-	let catches = nodeListToExprs(a, &t.catches);
	319	+	let catches = nodeListToExprs(a, &t.catches[..]);
320	320		return sexpr::list(a, head, &[toExpr(a, t.expr), sexpr::block(a, "catches", &[], catches)]);
321	321		}
322	322		return sexpr::list(a, head, &[toExpr(a, t.expr)]);
323	323		}
324	324		case super::NodeValue::CatchClause(clause) => {

336	336		children[len] = toExpr(a, clause.body);
337	337		len += 1;
338	338		return sexpr::list(a, head, &children[..len]);
339	339		}
340	340		case super::NodeValue::Block(blk) => {
341		-	let children = nodeListToExprs(a, &blk.statements);
	341	+	let children = nodeListToExprs(a, &blk.statements[..]);
342	342		return sexpr::block(a, "block", &[], children);
343	343		}
344	344		case super::NodeValue::Let(decl) => {
345	345		let mut head = "let";
346	346		if decl.mutable { head = "let-mut"; }

405	405		toExpr(a, f.iterable)
406	406		], &[toExpr(a, f.body), toExprOrNull(a, f.elseBranch)]),
407	407		case super::NodeValue::Loop { body } =>
408	408		return sexpr::block(a, "loop", &[], &[toExpr(a, body)]),
409	409		case super::NodeValue::Match(m) => {
410		-	let children = prongListToExprs(a, &m.prongs);
	410	+	let children = prongListToExprs(a, &m.prongs[..]);
411	411		return sexpr::block(a, "match", &[toExpr(a, m.subject)], children);
412	412		}
413	413		case super::NodeValue::MatchProng(p) => {
414	414		return prongToExpr(a, p);
415	415		}
416	416		case super::NodeValue::FnDecl(f) => {
417		-	let params = sexpr::list(a, "params", nodeListToExprs(a, &f.sig.params));
	417	+	let params = sexpr::list(a, "params", nodeListToExprs(a, &f.sig.params[..]));
418	418		let ret = toExprOrNull(a, f.sig.returnType);
419	419		if let body = f.body {
420	420		return sexpr::block(a, "fn", &[toExpr(a, f.name), params, ret], &[toExpr(a, body)]);
421	421		}
422	422		return sexpr::list(a, "fn", &[toExpr(a, f.name), params, ret]);
423	423		}
424	424		case super::NodeValue::Mod(m) => return sexpr::list(a, "mod", &[toExpr(a, m.name)]),
425	425		case super::NodeValue::Use(u_) => return sexpr::list(a, "use", &[toExpr(a, u_.path)]),
426	426		case super::NodeValue::RecordDecl(r) => {
427		-	let children = fieldListToExprs(a, &r.fields);
	427	+	let children = fieldListToExprs(a, &r.fields[..]);
428	428		return sexpr::block(a, "record", &[toExpr(a, r.name)], children);
429	429		}
430	430		case super::NodeValue::RecordField { field, type, value } => {
431	431		return fieldToExpr(a, field, type, value);
432	432		}
433	433		case super::NodeValue::UnionDecl(u_) => {
434		-	let children = variantListToExprs(a, &u_.variants);
	434	+	let children = variantListToExprs(a, &u_.variants[..]);
435	435		return sexpr::block(a, "union", &[toExpr(a, u_.name)], children);
436	436		}
437	437		case super::NodeValue::UnionDeclVariant(v) => {
438	438		return variantToExpr(a, v.name, v.type);
439	439		}
440	440		case super::NodeValue::ExprStmt(e) => return toExpr(a, e),
441	441		case super::NodeValue::TraitDecl { name, supertraits, methods, .. } => {
442		-	let children = nodeListToExprs(a, &methods);
443		-	let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, &supertraits));
	442	+	let children = nodeListToExprs(a, &methods[..]);
	443	+	let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, &supertraits[..]));
444	444		return sexpr::block(a, "trait", &[toExpr(a, name), supers], children);
445	445		}
446	446		case super::NodeValue::TraitMethodSig { name, receiver, sig } => {
447		-	let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params));
	447	+	let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
448	448		let ret = toExprOrNull(a, sig.returnType);
449	449		return sexpr::list(a, "methodSig", &[toExpr(a, receiver), toExpr(a, name), params, ret]);
450	450		}
451	451		case super::NodeValue::InstanceDecl { traitName, targetType, methods } => {
452		-	let children = nodeListToExprs(a, &methods);
	452	+	let children = nodeListToExprs(a, &methods[..]);
453	453		return sexpr::block(a, "instance", &[toExpr(a, traitName), toExpr(a, targetType)], children);
454	454		}
455	455		case super::NodeValue::InstanceMethodDecl { name, receiverName, receiverType, sig, body } => {
456		-	let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params));
	456	+	let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
457	457		let ret = toExprOrNull(a, sig.returnType);
458	458		return sexpr::block(a, "method", &[toExpr(a, receiverType), toExpr(a, receiverName), toExpr(a, name), params, ret], &[toExpr(a, body)]);
459	459		}
460	460		else => return sexpr::sym("?"),
461	461		}

464	464		/// Dump the tree rooted at `root`, using the provided arena for allocation.
465	465		pub fn printTree(root: super::Node, arena: mut alloc::Arena) {
466	466		match root.value {
467	467		case super::NodeValue::Block(blk) => {
468	468		for i in 0..blk.statements.len {
469		-	sexpr::print(toExpr(arena, blk.statements.list[i]), 0);
	469	+	sexpr::print(toExpr(arena, blk.statements[i]), 0);
470	470		if i < blk.statements.len - 1 { io::print("\n\n"); }
471	471		}
472	472		io::print("\n");
473	473		}
474	474		else => {

145	145		}
146	146		}
147	147
148	148		// Process each instruction.
149	149		for i in 0..block.instrs.len {
150		-	let instr = block.instrs.list[i];
	150	+	let instr = block.instrs[i];
151	151		let mut ctx = InstrCtx {
152	152		current: &mut current,
153	153		usedRegs: &mut usedRegs,
154	154		func,
155	155		live,