debug: debugEnabled,

    };

    // Initialize and parse all packages.

    let mut sourceArena = alloc::new(&mut MODULE_SOURCES[..]);

    for i in 0..pkgCount {

        for j in 0..moduleCounts[i] {

            let path = modulePaths[i][j];

            try processModule(&mut ctx.packages[i], &mut ctx.graph, path, arena, &mut sourceArena);

        }

    };

    return RootModule { entry: rootEntry, ast: rootAst };

}

/// Dump the module graph.

    let mut arena = alloc::new(&mut MAIN_ARENA[..]);

    module::printer::printGraph(&ctx.graph, &mut arena);

}

/// Dump the parsed AST.

                return 1;

            };

            return 0;

        }

        case Dump::Graph => {

            return 0;

        }

        else => {}

    }

    // Generate test runner if in test mode.

            case ast::NodeValue::FnDecl(decl) => {

                if let f = try lowerFnDecl(low, node, decl) {

                    if isRoot and checkAttr(decl.attrs, ast::Attribute::Default) {

                        defaultFnIdx = low.fns.len;

                    }

                }

            }

            case ast::NodeValue::ConstDecl(decl) => {

                try lowerDataDecl(low, node, decl.value, true);

            }

        };

        if fnType.throwList.len > 0 {

            func.returnType = il::Type::W64;

        }

        func.blocks = try lowerFnBody(&mut fnLow, body);

        let method = resolver::findTraitMethod(traitInfo, mName)

            else panic "lowerInstanceDecl: method not found in trait";

        methodNames[method.index] = qualName;

        values[i] = il::DataValue {

            item: il::DataItem::Fn(methodNames[i]),

            count: 1,

        };

    }

        name: vName,

        size: traitInfo.methods.len as u32 * resolver::PTR_SIZE,

        alignment: resolver::PTR_SIZE,

        readOnly: true,

        isUndefined: false,

    let qualName = qualifyName(self, nil, sym.name);

    let mut b = dataBuilder(self.allocator);

    try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);

    let result = dataBuilderFinish(&b);

        name: qualName,

        size: layout.size,

        alignment: layout.alignment,

        readOnly,

        isUndefined: result.isUndefined,

    }

}

/// Add a data item to the lowerer's data list.

// XXX: Inline this.

    self.data.append(data, self.allocator);

}

/// Add a function to the lowerer's function list.

// XXX: Inline this.

    self.fns.append(f, self.allocator);

}

/// Find an existing string data entry with matching content.

// TODO: Optimize with hash table or remove?

    readOnly: bool,

    values: *[il::DataValue],

    dataPrefix: *[u8]

) -> *[u8] throws (LowerError) {

    let name = nextDeclDataName(self, dataPrefix, self.data.len);

    return name;

}

/// Find or create read-only string data and return its symbol name.

    if readOnly {

        if let found = findConstData(self.low, values, alignment) {

            dataName = found;

        } else {

            dataName = try nextDataName(self);

        }

    } else {

        dataName = try nextDataName(self);

    }

    // Get data address.

    let ptrReg = nextReg(self);

    emit(self, il::Instr::Copy { dst: ptrReg, val: il::Val::DataSym(dataName) });

}

/// 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 [] });

}

/// Emit an unconditional jump to `target` with a single argument.

fn emitJmpWithArg(self: *mut FnLowerer, target: BlockId, arg: il::Val) throws (LowerError) {

    let args = try allocVal(self, arg);

    emit(self, il::Instr::Jmp { target: target.n, args });

}

/// Emit an unconditional jump to `target` and switch to it.

fn switchAndJumpTo(self: *mut FnLowerer, target: BlockId) throws (LowerError) {

    try emitJmp(self, target);

        thenTarget: thenBlock.n,

        thenArgs: &mut [],

        elseTarget: elseBlock.n,

        elseArgs: &mut [],

    });

}

/// Emit a compare-and-branch instruction with the given comparison op.

fn emitBrCmp(

    self: *mut FnLowerer,

    emit(self, il::Instr::Br {

        op, typ, a, b,

        thenTarget: thenBlock.n, thenArgs: &mut [],

        elseTarget: elseBlock.n, elseArgs: &mut [],

    });

}

/// Emit a guard that traps with `ebreak` when a comparison is false.

fn emitTrapUnlessCmp(

    self: *mut FnLowerer,

            }

        }

    }

    // Fallback: evaluate condition and emit boolean branch.

    let condVal = try lowerExpr(self, cond);

    try emitBr(self, condReg, thenBlock, elseBlock);

}

/// Emit a 32-bit store instruction at the given offset.

            // Null pointer optimization: branch on the data pointer being null.

            let nilReg = try optionalNilReg(self, subject.val, subject.type);

            try emitBrCmp(self, il::CmpOp::Eq, il::Type::W64, il::Val::Reg(nilReg), il::Val::Imm(0), matchBlock, fallthrough);

        }

        case MatchSubjectKind::OptionalAggregate => {

            if isNil { // Optional aggregate: `nil` means tag is zero.

                let tagReg = tvalTagReg(self, base);

                try emitBr(self, tagReg, fallthrough, matchBlock);

            } else {

                if isAggregateType(subject.bindType) {

                    // TODO: Why?

                    throw LowerError::Unsupported;

                }

                let pattVal = try lowerExpr(self, pattern);

                let eq = try lowerOptionalEq(self, subject.bindType, base, pattReg, 0);

                try emitBr(self, eqReg, matchBlock, fallthrough);

            }

        }

        case MatchSubjectKind::Union(unionInfo) => {

            // When matching by reference, always load from the pointer.

            if unionInfo.isAllVoid {

                let mut tagVal = subject.val;

                match subject.by {

                    case resolver::MatchBy::Ref, resolver::MatchBy::MutRef => {

                        tagVal = loadTag(self, base, 0, il::Type::W8);

                    }

                    case resolver::MatchBy::Value => {}

                }

                try emitBrCmp(self, il::CmpOp::Eq, il::Type::W8, tagVal, il::Val::Imm(variantTag as i64), matchBlock, fallthrough);

            } else {

                let tagReg = tvalTagReg(self, base);

                try emitBrCmp(self, il::CmpOp::Eq, il::Type::W8, il::Val::Reg(tagReg), il::Val::Imm(variantTag as i64), matchBlock, fallthrough);

            }

        }

// Control Flow Edge Management //

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

/// Add a predecessor edge from `pred` to `target`.

/// Must be called before the target block is sealed. Duplicates are ignored.

    let blk = getBlockMut(self, target);

    if blk.sealState == Sealed::Yes {

        panic "addPredecessor: adding predecessor to sealed block";

    }

    let preds = &mut blk.preds;

/// Get the register to compare against `0` for optional `nil` checking.

/// For null-ptr-optimized types, loads the data pointer, or returns it

/// directly for scalar pointers. For aggregates, returns the tag register.

fn optionalNilReg(self: *mut FnLowerer, val: il::Val, typ: resolver::Type) -> il::Reg throws (LowerError) {

    let case resolver::Type::Optional(inner) = typ else return reg;

    if let case resolver::Type::Slice { .. } = *inner {

        let ptrReg = nextReg(self);

        emitLoadW64At(self, ptrReg, reg, SLICE_PTR_OFFSET);

    subjectVal: il::Val,

    bindType: resolver::Type,

    matchBy: resolver::MatchBy,

    valOffset: i32

) -> Var throws (LowerError) {

    let mut payload: il::Val = undefined;

    match matchBy {

        case resolver::MatchBy::Value =>

            payload = tvalPayloadVal(self, base, bindType, valOffset),

    let payloadType = unionInfo.variants[variantOrdinal].valueType;

    let recInfo = resolver::getRecord(payloadType)

        else throw LowerError::ExpectedRecord;

    // Get the payload base pointer which points to the record within the tagged union.

    let valOffset = unionInfo.valOffset as i32;

    let payloadBase = emitPtrOffset(self, base, valOffset);

    // Bind each field.

    for fieldNode in lit.fields {

        if fieldIdx >= recInfo.fields.len {

            throw LowerError::MissingMetadata;

        }

        let fieldInfo = recInfo.fields[fieldIdx];

    }

}

/// Bind a single record field to a pattern variable.

fn bindFieldVariable(

    self: *mut FnLowerer,

    binding: *ast::Node,

    base: il::Reg,

    fieldInfo: resolver::RecordField,

    matchBy: resolver::MatchBy

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

        return; // Not an identifier binding.

    };

    let mut val: il::Val = undefined;

    match matchBy {

                        args: &mut []

                    }, self.allocator);

                }

            }

        }

    }

    emit(self, il::Instr::Switch {

        val: subject.val,

        defaultTarget: blocks[defaultIdx].n,

        defaultArgs: &mut [],

}

/// Reserve stack storage for a value of the given type.

fn emitReserve(self: *mut FnLowerer, typ: resolver::Type) -> il::Reg throws (LowerError) {

    let layout = resolver::getTypeLayout(typ);

}

/// Reserve stack storage with an explicit layout.

    let dst = nextReg(self);

    emit(self, il::Instr::Reserve {

        dst,

        size: il::Val::Imm(layout.size as i64),

    if let case il::Val::Undef = src {

        return;

    }

    if isAggregateType(typ) {

        let dst = emitPtrOffset(self, base, offset);

        let layout = resolver::getTypeLayout(typ);

        emit(self, il::Instr::Blit { dst, src, size: il::Val::Imm(layout.size as i64) });

    } else {

        emit(self, il::Instr::Store {

    inst: *resolver::InstanceEntry

) -> il::Val throws (LowerError) {

    let vName = vtableName(self.low, inst.moduleId, inst.concreteTypeName, traitInfo.name);

    // Reserve space for the trait object on the stack.

        size: resolver::PTR_SIZE * 2,

        alignment: resolver::PTR_SIZE,

    });

    // Store data pointer.

/// Emit a tag comparison for void variant equality/inequality.

fn emitTagCmp(self: *mut FnLowerer, op: ast::BinaryOp, val: il::Val, tagIdx: i64, valType: resolver::Type) -> il::Val

    throws (LowerError)

{

    // For all-void unions, the value *is* the tag, not a pointer.

    let mut tag: il::Val = undefined;

    if resolver::isVoidUnion(valType) {

        tag = il::Val::Reg(reg);

    emit(self, il::Instr::Br {

        op: il::CmpOp::Eq, typ: il::Type::W8, a: tagA, b: tagB,

        thenTarget: nilCheck.n, thenArgs: &mut [],

        elseTarget: mergeBlock.n, elseArgs: falseArgs,

    });

    // Check if both are `nil`.

    try switchToAndSeal(self, nilCheck);

    emit(self, il::Instr::Br {

        op: il::CmpOp::Ne, typ: il::Type::W8, a: tagA, b: il::Val::Imm(0),

        thenTarget: payloadCmp.n, thenArgs: &mut [],

        elseTarget: mergeBlock.n, elseArgs: trueArgs,

    });

    // Both are non-`nil`, compare payloads.

    try switchToAndSeal(self, payloadCmp);

    let payloadEq = try emitEqAtOffset(self, a, b, offset + valOffset, inner);

    try emitJmpWithArg(self, mergeBlock, payloadEq);

    emit(self, il::Instr::Br {

        op: il::CmpOp::Eq, typ: il::Type::W8, a: tagA, b: tagB,

        thenTarget: tagBlock.n, thenArgs: &mut [],

        elseTarget: mergeBlock.n, elseArgs: falseArgs,

    });

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

        defaultArgs: &mut [],

        cases

    });

    // Add predecessor edges for switch targets.

    for i in 0..unionInfo.variants.len {

        if let caseBlock = caseBlocks[i] {

        } else {

        }

    }

    let valOffset = unionInfo.valOffset as i32;

    // Emit payload comparison blocks for non-void variants.

    };

    let fieldInfo = resolver::getRecordField(subjectTy, fieldIdx) else {

        throw LowerError::FieldNotFound;

    };

    let baseVal = try lowerExpr(self, access.parent);

    return FieldRef {

        base: baseReg,

        offset: fieldInfo.offset,

        fieldType: fieldInfo.fieldType,

) -> il::Val throws (LowerError) {

    let info = resolver::sliceRangeInfoFor(self.low.resolver, sliceNode) else {

        throw LowerError::MissingMetadata;

    };

    let baseVal = try lowerExpr(self, container);

    // Extract data pointer and container length.

    let mut dataReg = baseReg;

    let mut containerLen: il::Val = undefined;

    if let cap = info.capacity { // Slice from array.

                return val;

            }

            // Materialize a stack slot using the declaration's resolved

            // layout so `align(N)` on locals is honored.

            let layout = resolver::getLayout(self.low.resolver, addr.target, typ);

            try emitStore(self, slot, 0, typ, val);

            let stackVal = il::Val::Reg(slot);

            self.vars[v.id].addressTaken = true;

            defVar(self, v, stackVal);

        throw LowerError::MissingType(container);

    };

    let subjectTy = resolver::autoDeref(containerTy);

    let indexVal = try lowerExpr(self, index);

    let baseVal = try lowerExpr(self, container);

    let mut dataReg = baseReg;

    let mut elemType: resolver::Type = undefined;

    match subjectTy {

fn lowerDeref(self: *mut FnLowerer, node: *ast::Node, target: *ast::Node) -> il::Val throws (LowerError) {

    let type = resolver::typeFor(self.low.resolver, node) else {

        throw LowerError::MissingType(node);

    };

    let ptrVal = try lowerExpr(self, target);

    return emitRead(self, ptrReg, 0, type);

}

/// Lower a subscript expression.

    // values in loop phis when `&var` or `&mut var` appears inside a loop.

    if not isAggregateType(typ) {

        if let sym = resolver::nodeData(self.low.resolver, node).sym {

            if let case resolver::SymbolData::Value { addressTaken, .. } = sym.data; addressTaken {

                let layout = resolver::getLayout(self.low.resolver, node, typ);

                try emitStore(self, slot, 0, typ, varVal);

                let v = newVar(self, name, ilType, l.mutable, il::Val::Reg(slot));

                self.vars[v.id].addressTaken = true;

                };

                if isAggregateType(leftTy) or getVar(self, v).addressTaken {

                    // Aggregates and address-taken scalars are represented as

                    // pointers to stack memory. Store through the pointer.

                    let val = try useVar(self, v);

                    try emitStore(self, dst, 0, leftTy, rhs);

                } else {

                    // Scalars are tracked directly in SSA. Each assignment

                    // records a new SSA value.

            try emitStore(self, fieldRef.base, fieldRef.offset, fieldRef.fieldType, rhs);

        }

        case ast::NodeValue::Deref(target) => {

            // Assignment through pointer dereference: `*ptr = value`.

            let ptrVal = try lowerExpr(self, target);

            let targetTy = resolver::typeFor(self.low.resolver, a.left) else {

                throw LowerError::MissingType(a.left);

            };

            try emitStore(self, ptrReg, 0, targetTy, rhs);

        }

            try lowerForLoop(self, &iter, f.body);

        }

        case resolver::ForLoopInfo::Collection { elemType, length, bindingName, indexName } => {

            let containerVal = try lowerExpr(self, f.iterable);

            let mut dataReg = containerReg;

            let mut lengthVal: il::Val = undefined;

            if let len = length { // Array (length is known).

                lengthVal = il::Val::Imm(len as i64);

/// When the function has a return buffer parameter, the value is blitted

/// into the buffer and the buffer pointer is returned. Otherwise, the value is

/// returned directly.

fn emitRetVal(self: *mut FnLowerer, val: il::Val) throws (LowerError) {

    if let retReg = self.returnReg {

        let size = retBufSize(self);

        emit(self, il::Instr::Blit { dst: retReg, src, size: il::Val::Imm(size as i64) });

        emit(self, il::Instr::Ret { val: il::Val::Reg(retReg) });

    } else if isSmallAggregate(*self.fnType.returnType) {

        let dst = nextReg(self);

        emit(self, il::Instr::Load { typ: il::Type::W64, dst, src, offset: 0 });

        emit(self, il::Instr::Ret { val: il::Val::Reg(dst) });

    } else {

    try emitRetVal(self, resultVal);

}

/// Ensure a value is in a register (eg. for branch conditions).

    match val {

        case il::Val::Reg(r) => return r,

        case il::Val::Imm(_), il::Val::DataSym(_), il::Val::FnAddr(_) => {

            let dst = nextReg(self);

            emit(self, il::Instr::Copy { dst, val });

        try emitCondBranch(self, cond.condition, thenBlock, elseBlock);

        let mergeBlock = try createBlock(self, "cond#merge");

        try switchToAndSeal(self, thenBlock);

        emit(self, il::Instr::Blit { dst, src: thenVal, size: il::Val::Imm(layout.size as i64) });

        try emitJmp(self, mergeBlock);

        try switchToAndSeal(self, elseBlock);

        emit(self, il::Instr::Blit { dst, src: elseVal, size: il::Val::Imm(layout.size as i64) });

        try emitJmp(self, mergeBlock);

        try switchToAndSeal(self, mergeBlock);

    op: ast::BinaryOp,

    typ: resolver::Type,

    a: il::Val,

    b: il::Val

) -> il::Val throws (LowerError) {

    let result = try lowerAggregateEq(self, typ, regA, regB, 0);

    if op == ast::BinaryOp::Ne {

        return emitTypedBinOp(self, il::BinOp::Eq, il::Type::W32, result, il::Val::Imm(0));

    }

        throw LowerError::MissingType(node);

    };

    if resolver::typesEqual(srcType, dstType) {

        return val;

    }

}

/// Check whether a resolver type is a signed integer type.

fn isSignedType(t: resolver::Type) -> bool {

    match t {

    } = resolver::nodeData(self.low.resolver, t.expr).extra {

        resVal = try lowerTraitMethodCall(self, t.expr, callExpr, traitInfo, methodIndex);

    } else {

        resVal = try lowerCall(self, t.expr, callExpr);

    }

    let tagReg = resultTagReg(self, base); // The result tag.

    let okBlock = try createBlock(self, "ok"); // Block if success.

    let errBlock = try createBlock(self, "err"); // Block if failure.

        // Forward the callee's global error tag and payload directly.

        let callerLayout = resolver::getResultLayout(

            *self.fnType.returnType, self.fnType.throwList

        );

        let calleeErrSize = maxErrSize(calleeInfo.throwList);

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

        emit(self, il::Instr::Blit { dst: dstPayload, src: srcPayload, size: il::Val::Imm(calleeErrSize as i64) });

        let clauseNode = catches[i];

        let case ast::NodeValue::CatchClause(clause) = clauseNode.value

            else panic "lowerMultiCatch: expected CatchClause";

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

        if let typeNode = clause.typeNode {

            let errTy = resolver::typeFor(self.low.resolver, typeNode) else {

                throw LowerError::MissingType(typeNode);

            };

    let mut defaultTarget: BlockId = undefined;

    if let idx = defaultIdx {

        defaultTarget = blocks[idx];

    } else {

        defaultTarget = try createBlock(self, "unreachable");

    }

    emit(self, il::Instr::Switch {

        val: il::Val::Reg(tagReg),

        defaultTarget: defaultTarget.n,

        defaultArgs: &mut [],

    let case ast::NodeValue::FieldAccess(access) = call.callee.value

        else throw LowerError::MissingMetadata;

    // Get the address of the slice header.

    let sliceVal = try lowerExpr(self, access.parent);

    // Lower the value to append and the allocator.

    let elemVal = try lowerExpr(self, call.args[0]);

    let allocVal = try lowerExpr(self, call.args[1]);

    let elemLayout = resolver::getTypeLayout(*elemType);

    let stride = elemLayout.size;

    let alignment = elemLayout.alignment;

    let elemLayout = resolver::getTypeLayout(*elemType);

    let stride = elemLayout.size;

    // Get slice header address.

    let sliceVal = try lowerExpr(self, access.parent);

    // Lower the index argument.

    let indexVal = try lowerExpr(self, call.args[0]);

    // Load len and bounds-check: index must be smaller than length.

    let case ast::NodeValue::FieldAccess(access) = call.callee.value

        else throw LowerError::MissingMetadata;

    // Lower the trait object expression.

    let traitObjVal = try lowerExpr(self, access.parent);

    // Load data pointer from trait object.

    let dataReg = nextReg(self);

    emit(self, il::Instr::Load {

        typ: il::Type::W64,

        if methodFnType.throwList.len > 0 {

            let successType = *methodFnType.returnType;

            let layout = resolver::getResultLayout(

                successType, methodFnType.throwList);

        } else {

            args[0] = il::Val::Reg(try emitReserve(self, retTy));

        }

        let dst = nextReg(self);

        args,

    });

    if let d = dst {

        if isSmallAggregate(retTy) {

                self,

                resolver::Layout {

                    size: resolver::PTR_SIZE,

                    alignment: resolver::PTR_SIZE

                });

    if returnParam {

        if fnInfo.throwList.len > 0 {

            let successType = *fnInfo.returnType;

            let layout = resolver::getResultLayout(successType, fnInfo.throwList);

        } else {

            args[0] = il::Val::Reg(try emitReserve(self, retTy));

        }

        let dst = nextReg(self);

        emit(self, il::Instr::Call {

    // Non-void functions produce a value in a register, while void functions

    // return an undefined value that shouldn't be used.

    if let d = dst {

        if isSmallAggregate(retTy) {

                self,

                resolver::Layout {

                    size: resolver::PTR_SIZE,

                    alignment: resolver::PTR_SIZE

                });

                return try buildNilOptional(self, optType);

            }

            return try wrapInOptional(self, val, optType);

        }

        case resolver::Coercion::NumericCast { from, to } => {

        }

        case resolver::Coercion::ResultWrap => {

            let payloadType = *self.fnType.returnType;

            return try buildResult(self, 0, val, payloadType);

        }

/// Lower an implicit numeric cast coercion.

///

/// Handles widening conversions between integer types. Uses sign-extension

/// for signed source types and zero-extension for unsigned source types.

    let srcLayout = resolver::getTypeLayout(srcType);

    let dstLayout = resolver::getTypeLayout(dstType);

    if srcLayout.size < dstLayout.size {

        // Widening conversion: sign/zero-extend based on source signedness.

            // Aggregate constants live in read-only memory.  Return a

            // mutable copy so that callers that assign through the

            // resulting pointer do not fault.

            if isAggregateType(type) {

                let layout = resolver::getTypeLayout(type);

                emit(self, il::Instr::Blit { dst, src, size: il::Val::Imm(layout.size as i64) });

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

            }

            return emitRead(self, src, 0, type);

                val = try useVar(self, v);

                if self.vars[v.id].addressTaken {

                    let typ = resolver::typeFor(self.low.resolver, node) else {

                        throw LowerError::MissingType(node);

                    };

                    val = emitRead(self, ptr, 0, typ);

                }

            } else {

                val = try lowerGlobalSymbol(self, node);

            }

pub fn init(

    pkg: *mut Package,

    id: u16,

    name: *[u8],

    pool: *mut strings::Pool

    pkg.id = id;

    pkg.name = strings::intern(pool, name);

    pkg.rootModuleId = nil;

    return pkg;

        case ast::NodeValue::Placeholder, ast::NodeValue::Ident(_) => {

            let _ = try bindValueIdent(self, pattern, pattern, ty, mutable, 0, 0);

        }

        else => {

            let actualTy = try checkAssignable(self, pattern, ty);

        }

    }

}

/// Set the expected return type for a new function body.

        else throw emitError(self, node, ErrorKind::ExpectedIdentifier);

    return name;

}

/// Associate a resolved symbol with an AST node.

    if let existingSym = self.nodeData.entries[node.id].sym {

        panic "setNodeSymbol: a symbol is already associated with this node";

    }

    self.nodeData.entries[node.id].sym = symbol;

}

/// Associate a resolved type with an AST node and return it.

    if ty == Type::Unknown {

        // In this case, we simply don't associate a type.

        return ty;

    }

    self.nodeData.entries[node.id].ty = ty;

    }

    return Type::Void;

}

/// Associate a coercion plan with an AST node.

    if coercion == Coercion::Identity {

        return coercion;

    }

    self.nodeData.entries[node.id].coercion = coercion;

    return coercion;

}

/// Associate a constant value with an AST node.

    self.nodeData.entries[node.id].constValue = value;

}

/// Associate a record field index with a record literal field node.

    self.nodeData.entries[node.id].extra = NodeExtra::RecordField { index };

}

/// Associate slice range metadata with a subscript expression.

    self.nodeData.entries[node.id].extra = NodeExtra::SliceRange(info);

}

/// Associate union variant metadata with a pattern or constructor node.

fn setVariantInfo(self: *mut Resolver, node: *ast::Node, ordinal: u32, tag: u32) {

fn setTraitMethodCall(self: *mut Resolver, node: *ast::Node, traitInfo: *TraitType, methodIndex: u32) {

    self.nodeData.entries[node.id].extra = NodeExtra::TraitMethodCall { traitInfo, methodIndex };

}

/// Associate for-loop metadata with a for-loop node.

    self.nodeData.entries[node.id].extra = NodeExtra::ForLoop(info);

}

/// Retrieve the constant value associated with a node, if any.

pub fn constValueEntry(self: *Resolver, node: *ast::Node) -> ?ConstValue {

    }

    return nil;

}

/// Associate match prong metadata with a match prong node.

    self.nodeData.entries[node.id].extra = NodeExtra::MatchProng { catchAll };

}

/// Check if a prong is catch-all.

pub fn isProngCatchAll(self: *Resolver, node: *ast::Node) -> bool {

/// coercion plan if so, or throw an error if not.

fn expectAssignable(self: *mut Resolver, to: Type, from: Type, site: *ast::Node) -> Coercion throws (ResolveError) {

    // Ensure any nested nominal types are resolved before checking assignability.

    try ensureTypeResolved(self, to, site);

    if let coercion = isAssignable(self, to, from, site) {

    }

    throw emitTypeMismatch(self, site, TypeMismatch {

        expected: to,

        actual: from,

    });

    attrs: u32,

    scope: *mut Scope

) -> *mut Symbol throws (ResolveError) {

    let sym = allocSymbol(self, data, name, owner, attrs);

    try addSymbolToScope(self, sym, scope, owner);

    return sym;

}

/// Add a symbol to the given scope.

    mutable: bool,

    alignment: u32,

    attrs: u32

) -> ?*mut Symbol throws (ResolveError) {

    if let case ast::NodeValue::Placeholder = ident.value {

        return nil;

    }

    let name = try nodeName(self, ident);

    let data = SymbolData::Value { mutable, alignment, type, addressTaken: false };

    let sym = try bindIdent(self, name, owner, data, attrs, self.scope);

    // Track number of local bindings for lowering stage.

    // TODO: Support `if let mut`.

    if let fnType = self.currentFn {

        let mut ty = fnType;

    attrs: u32

) -> *mut Symbol throws (ResolveError) {

    let name = try nodeName(self, ident);

    let data = SymbolData::Constant { type, value: val };

    let sym = try bindIdent(self, name, owner, data, attrs, self.scope);

    return sym;

}

/// Bind a module identifier in the given scope.

                let variantName = suffix[0];

                let variantSym = try resolveUnionVariantAccess(

                    self, node, access, unionType, variantName

                );

                // TODO: This shouldn't be here.

                return variantSym;

            }

        }

        else => {} // Fallthrough.

    }

            let sym = findTypeSymbol(self.scope, name)

                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));

            let case SymbolData::Type(ty) = sym.data

                else throw emitError(self, node, ErrorKind::Internal);

            return ty;

        }

        case ast::NodeValue::ScopeAccess(access) => {

            let sym = try resolveAccess(self, node, access, self.scope);

            let case SymbolData::Type(ty) = sym.data

                else throw emitError(self, node, ErrorKind::Internal);

            return ty;

        }

        else => panic "resolveTypeName: unsupported node value",

    }

        case ast::NodeValue::While(loopNode) => return try resolveWhile(self, node, loopNode),

        case ast::NodeValue::WhileLet(loopNode) => return try resolveWhileLet(self, node, loopNode),

        case ast::NodeValue::For(loopNode) => return try resolveFor(self, node, loopNode),

        case ast::NodeValue::Loop { body } => {

            let loopType = try visitLoop(self, body);

        },

        case ast::NodeValue::Break => {

            try ensureInsideLoop(self, node);

            // Mark that the current loop has a reachable break.

            self.loopStack[self.loopDepth - 1].hasBreak = true;

        },

        case ast::NodeValue::Continue => {

            try ensureInsideLoop(self, node);

        },

        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::Panic { message } => {

            try visitOptional(self, message, Type::Slice { // TODO: Have easy access to string type.

                item: allocType(self, Type::U8),

                mutable: false

            });

        },

        case ast::NodeValue::Assert { condition, message } => {

            try visit(self, condition, Type::Bool);

            try visitOptional(self, message, Type::Slice { // TODO: Have easy access to string type.

                item: allocType(self, Type::U8),

                mutable: false

            });

        },

        case ast::NodeValue::BinOp(binop) => return try resolveBinOp(self, node, binop),

        case ast::NodeValue::UnOp(unop) => return try resolveUnOp(self, node, unop),

        case ast::NodeValue::ExprStmt(expr) => {

            // Pass `Void` as expected type to indicate value is discarded.

            let exprTy = try visit(self, expr, Type::Void);

        },

        case ast::NodeValue::TypeSig(sig) => return try inferTypeSig(self, node, sig),

        case ast::NodeValue::Ident(name) => {

            let sym = findAnySymbol(self.scope, name)

                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));

            // TODO: See if we can unify this with `resolvePath`, ie. scope access.

            match sym.data {

                case SymbolData::Value { type, .. } => {

                },

                case SymbolData::Constant { type, value } => {

                    // Propagate constant value.

                    if let val = value {

                    }

                },

                case SymbolData::Type(t) => {

                },

                case SymbolData::Variant { .. } => {

                    return Type::Void;

                },

                case SymbolData::Module { .. } => {

            throw emitError(self, node, ErrorKind::InvalidModulePath);

        },

        case ast::NodeValue::Nil => {

            // Use the hint type if it's an optional, otherwise fall back to `Nil`.

            if let case Type::Optional(_) = hint {

            }

        },

        case ast::NodeValue::Undef => {

        },

        case ast::NodeValue::Bool(value) => {

        }

        case ast::NodeValue::Char(value) => {

        }

        case ast::NodeValue::String(text) => {

            let byteTy = allocType(self, Type::U8);

            let sliceTy = allocType(self, Type::Slice {

                item: byteTy,

                mutable: false,

            });

        },

        case ast::NodeValue::Number(lit) => {

                magnitude: lit.magnitude,

                bits: 32,

                signed: lit.signed,

                negative: lit.negative,

            }));

        },

        case ast::NodeValue::Placeholder => {

        },

        else => {

            throw emitError(self, node, ErrorKind::UnexpectedNode(node));

        }

    }

    }

    return Type::Void;

}

/// Collect attribute flags applied to a declaration.

    let list = attrs else return 0;

    let attrNodes = list.list;

    let mut mask: u32 = 0;

    for node in attrNodes {

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

    };

    exitScope(self);

}

/// Analyze a `let` declaration and bind its identifier.

fn resolveLet(self: *mut Resolver, node: *ast::Node, decl: ast::Let) -> Type

    throws (ResolveError)

    // Alignment must be zero or a power of two.

    if alignment != 0 and (alignment & (alignment - 1)) != 0 {

        throw emitError(self, decl.value, ErrorKind::InvalidAlignmentValue(alignment));

    }

    let _ = try bindValueIdent(self, decl.ident, node, bindingTy, decl.mutable, alignment, 0);

    return Type::Void;

}

/// Determine whether a node represents a compile-time constant expression.

    // Validate it fits within u32 range.

    if not validateConstIntRange(value, Type::U32) {

        throw emitError(self, node, ErrorKind::NumericLiteralOverflow);

    }

    assert not int.negative;

    return int.magnitude as u32;

}

/// Check that constructor arguments match record fields.

    typeNode: *ast::Node,

    valueNode: *ast::Node,

    attrList: ?ast::Attributes,

    isConst: bool

) -> Type throws (ResolveError) {

    let bindingTy = try infer(self, typeNode);

    let valueTy = try checkAssignable(self, valueNode, bindingTy);

    if isConst {

        let constVal = constValueEntry(self, valueNode);

        if not isConstExpr(self, valueNode) {

            throw emitError(self, valueNode, ErrorKind::ConstExprRequired);

        }

        try bindValueIdent(self, ident, node, bindingTy, true, 0, attrs);

    }

    return Type::Void;

}

/// Analyze a function declaration signature and bind the function name.

fn resolveFnDecl(self: *mut Resolver, node: *ast::Node, decl: ast::FnDecl) -> Type

    throws (ResolveError)

{

    let mut retTy = Type::Void;

    if let retNode = decl.sig.returnType {

        retTy = try infer(self, retNode);

    }

    let a = alloc::arenaAllocator(&mut self.arena);

/// Bind a type name.

fn bindTypeName(self: *mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *mut Symbol

    throws (ResolveError)

{

    try ensureDefaultAttrNotAllowed(self, node, attrMask);

    // Create a placeholder nominal type that will be replaced in

    // the next phase.

    let nominalTy = allocNominalType(self, NominalType::Placeholder(node));

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

fn bindTraitName(self: *mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *mut Symbol

    throws (ResolveError)

{

    try ensureDefaultAttrNotAllowed(self, node, attrMask);

    let traitName = try nodeName(self, name);

    let traitType = allocTraitType(self, traitName);

    let data = SymbolData::Trait(traitType);

    let sym = try bindIdent(self, traitName, node, data, attrMask, self.scope);

    return sym;

}

/// Find a trait method by name.

    // Resolve supertrait bounds and copy their methods into this trait.

    for superNode in supertraits {

        let superSym = try resolveNamePath(self, superNode);

        let case SymbolData::Trait(superTrait) = superSym.data

            else throw emitError(self, superNode, ErrorKind::Internal);