set payload = tvalPayloadAddr(self, base, valOffset),

    };

    return newVar(self, name, ilType(self.low, bindType), mutable, payload);

}

fn bindMatchVariable(

    self: *mut FnLowerer,

    subject: *MatchSubject,

    binding: *ast::Node,

    mutable: bool

        };

        try bindFieldVariable(self, elem, base, fieldInfo, subject.by, failBlock);

    }

}

fn bindRecordPatternFields(self: *mut FnLowerer, subject: *MatchSubject, pattern: *ast::Node, lit: ast::RecordLit, failBlock: BlockId) throws (LowerError) {

    // No fields to bind (e.g., `{ .. }`).

    if lit.fields.len == 0 {

        return;

    }

}

/// Lower a `let-else` statement.

fn lowerLetElse(self: *mut FnLowerer, letElse: ast::LetElse) throws (LowerError) {

    let subject = try lowerMatchSubject(self, letElse.pattern.scrutinee);

    if letElse.pattern.guard == nil {

    }

    let elseBlock = try createBlock(self, "else");

    try switchToAndSeal(self, elseBlock);

    try switchToAndSeal(self, mergeBlock);

}

/// Lower a `while let` loop as a match-driven loop.

fn lowerWhileLet(self: *mut FnLowerer, w: ast::WhileLet) throws (LowerError) {

}

/// Check if a resolver type lowers to an aggregate in memory.

fn isAggregateType(typ: resolver::Type) -> bool {

    match typ {

        case resolver::Type::Slice { .. },

        case resolver::Type::Optional(resolver::Type::Pointer { .. }) => {

            // Optional pointers are scalar due to NPO.

            return false;

        }

        case resolver::Type::Optional(_) => {

            // All other optionals, including optional slices, are aggregates.

            return true;

        }

        else => return false,

    }

}

/// Check if a resolver type is a small aggregate that can be

/// Build a `nil` value for an optional type.

///

/// For optional pointers (`?*T`), returns an immediate `0` (null pointer).

/// For other optionals, builds a tagged aggregate with tag set to `0` (absent).

fn buildNilOptional(self: *mut FnLowerer, optType: resolver::Type) -> il::Val throws (LowerError) {

    }

}

/// Build a result value for throwing functions.

fn buildResult(

    self: *mut FnLowerer,

    ptrVal: il::Val,

    lenVal: il::Val,

    capVal: il::Val

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

    let sliceType = resolver::Type::Slice {

    };

    let dst = try emitReserve(self, sliceType);

    let ptrTy = resolver::Type::Pointer {

    };

    try emitStore(self, dst, SLICE_PTR_OFFSET, ptrTy, ptrVal);

    try emitStore(self, dst, SLICE_LEN_OFFSET, resolver::Type::U32, lenVal);

    try emitStore(self, dst, SLICE_CAP_OFFSET, resolver::Type::U32, capVal);

    a: il::Reg,

    b: il::Reg,

    offset: i32

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

    let ptrTy = resolver::Type::Pointer {

    };

    let ptrEq = try emitEqAtOffset(self, a, b, offset + SLICE_PTR_OFFSET, ptrTy);

    let lenEq = try emitEqAtOffset(self, a, b, offset + SLICE_LEN_OFFSET, resolver::Type::U32);

    return emitTypedBinOp(self, il::BinOp::And, il::Type::W32, ptrEq, lenEq);

    a: il::Reg,

    b: il::Reg,

    offset: i32

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

    match typ {

        case resolver::Type::Optional(inner) => {

            return try lowerOptionalEq(self, *inner, a, b, offset);

        }

        case resolver::Type::Array(arr) =>

            return try lowerArrayEq(self, arr, a, b, offset),

        case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) =>

            return try lowerRecordEq(self, recInfo, a, b, offset),

        case resolver::Type::Nominal(resolver::NominalType::Union(unionInfo)) =>

            else => throw LowerError::UnexpectedNodeValue(arrayNode),

        }

        let result = dataBuilderFinish(&b);

        let alignment = resolver::getTypeLayout(*item).alignment;

        return try lowerConstDataAsSlice(

        );

    }

    let data = try lowerExpr(self, arrayNode);

    let count = il::Val::Imm(length as i64);

    return try buildSliceValue(self, item, mutable, data, count, count);

        case resolver::Type::Slice { item, .. } => {

            set elemType = *item;

            let sliceLen = loadSliceLen(self, baseReg);

            // Runtime safety check: index must be strictly less than slice length.

            try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, indexVal, sliceLen);

            set dataReg = loadSlicePtr(self, baseReg);

        }

        case resolver::Type::Array(arrInfo) => {

            set elemType = *arrInfo.item;

            // Runtime safety check: index must be strictly less than array length.

/// String literals are stored as global data and the result is a slice

/// pointing to the data with the appropriate length.

fn lowerStringLit(self: *mut FnLowerer, node: *ast::Node, s: *[u8]) -> il::Val throws (LowerError) {

    // Get the slice type from the node.

    let sliceTy = try typeOf(self, node);

    // Build the string data value.

    let ptr = try! alloc::alloc(

        self.low.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue)

    ) as *mut il::DataValue;

    set *ptr = il::DataValue { item: il::DataItem::Str(s), count: 1 };

}

/// Lower a builtin call expression.

fn lowerBuiltinCall(self: *mut FnLowerer, node: *ast::Node, kind: ast::Builtin, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {

    match kind {

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 = try typeOf(self, node);

    let ptrVal = try lowerExpr(self, args[0]);

    let lenVal = try lowerExpr(self, args[1]);

    let mut capVal = lenVal;

    if args.len == 3 {

        set capVal = try lowerExpr(self, args[2]);

             resolver::Type::U32 => return il::Type::W32,

        case resolver::Type::I64,

             resolver::Type::U64,

             resolver::Type::Pointer { .. },

             resolver::Type::Slice { .. },

             resolver::Type::Array(_),

             resolver::Type::Optional(_),

        case resolver::Type::Nominal(_) => {

            if resolver::isVoidUnion(typ) {

                return il::Type::W8;

            }

            return il::Type::W64;