let calleeSym = resolver::nodeData(self.resolver, call.callee).sym

                else throw LowerError::MissingSymbol(call.callee);

            match calleeSym.data {

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

                    try lowerConstUnionVariantInto(self, node, calleeSym, ty, call.args, dataPrefix, b),

                    try lowerConstRecordCtorInto(self, call.args, recInfo, dataPrefix, b);

                }

                else => throw LowerError::MissingConst(node),

            }

        }

    recLit: ast::RecordLit,

    ty: resolver::Type,

    dataPrefix: *[u8],

    b: *mut DataValueBuilder

) throws (LowerError) {

            try lowerConstRecordCtorInto(self, recLit.fields, recInfo, dataPrefix, b);

        }

            let typeName = recLit.typeName else {

                throw LowerError::ExpectedVariant;

            };

            let sym = resolver::nodeData(self.resolver, typeName).sym else {

                throw LowerError::MissingSymbol(typeName);

            });

        }

        return;

    }

        throw LowerError::ExpectedRecord;

    };

    let payloadLayout = payloadRec.layout;

    try lowerConstRecordCtorInto(self, payloadArgs, payloadRec, dataPrefix, b);

/// 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 reg = emitValToReg(self, val);

    }

}

/// Lower an optional nil check (`opt == nil` or `opt != nil`).

fn lowerNilCheck(self: *mut FnLowerer, opt: *ast::Node, isEq: bool) -> il::Val throws (LowerError) {

    let optTy = resolver::typeFor(self.low.resolver, opt) else {

// Record and Aggregate Type Helpers //

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

/// Extract the nominal record info from a resolver type.

fn recordInfoFromType(typ: resolver::Type) -> ?resolver::RecordType {

    return recInfo;

}

/// Extract the nominal union info from a resolver type.

fn unionInfoFromType(typ: resolver::Type) -> ?resolver::UnionType {

    return unionInfo;

}

/// Return the effective type of a node after any coercion applied by

/// the resolver. `lowerExpr` already materializes the coercion in the

        }

        case resolver::Type::Slice { .. } => return true,

        case resolver::Type::TraitObject { .. } => return true,

        case resolver::Type::Array(_) => return true,

        case resolver::Type::Nil => return true,

            return false;

        }

    }

}

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

/// passed or returned by value in a register.

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

    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::Slice { item, mutable } =>

            return try lowerSliceEq(self, item, mutable, a, b, offset),

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

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

        else => {

            let recInfo = recordInfoFromType(typ) else {

                throw LowerError::ExpectedRecord;

            };

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

/// record literals like `Union::Variant { field: value }`.

fn lowerRecordLit(self: *mut FnLowerer, node: *ast::Node, lit: ast::RecordLit) -> il::Val throws (LowerError) {

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

        throw LowerError::MissingType(node);

    };

            let dst = try emitReserve(self, typ);

            try lowerRecordFields(self, dst, &recInfo, lit.fields, 0);

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

        }

            // TODO: This can be inlined once we have a real register allocator.

            return try lowerUnionRecordLit(self, typ, lit);

        }

    }

}

/// Lower a union variant record literal like `Union::Variant { field: value }`.

fn lowerUnionRecordLit(self: *mut FnLowerer, typ: resolver::Type, lit: ast::RecordLit) -> il::Val throws (LowerError) {

    return tag;

}

/// Check if a type is a union without payloads.

pub fn isVoidUnion(ty: Type) -> bool {

        else return false;

    return unionType.isAllVoid;

}

/// Check if a type should be treated as an address-like value.

    }

}

/// Get the record info from a record type.

pub fn getRecord(ty: Type) -> ?RecordType {

    return recInfo;

}

/// Auto-dereference a type: if it's a pointer, return the target type.

pub fn autoDeref(ty: Type) -> Type {

}

/// Get field info for a record-like type (records, slices) by field index.

pub fn getRecordField(ty: Type, index: u32) -> ?RecordField {

    match ty {

            if index >= recInfo.fields.len {

                return nil;

            }

            return recInfo.fields[index];

        }

            // Constructor calls (union variants, unlabeled records) are constant

            // if all payload args are themselves constant.

            if let sym = symbolFor(self, call.callee) {

                match sym.data {

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

                            return false;

                        }

                    },

                    else => return false,

                }

    let sym = symbolFor(self, node) else {

        // The function declaration failed to type check, therefore

        // no symbol was associated with it.

        return;

    };

        panic "resolveFnDeclBody: unexpected symbol data for function";

    };

    let retTy = *fnType.returnType;

    let isExtern = ast::hasAttribute(sym.attrs, ast::Attribute::Extern);

    let isIntrinsic = ast::hasAttribute(sym.attrs, ast::Attribute::Intrinsic);

    if isIntrinsic and not isExtern {

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

        // for this method (eg. unknown method name). Skip gracefully.

        let sym = symbolFor(self, methodNode)

            else continue;

            else panic "resolveInstanceMethodBodies: expected value symbol";

        // Enter function scope.

        enterFn(self, methodNode, fnType);

        // Bind the receiver parameter.

    let subjectTy = try infer(self, sw.subject);

    let subject = unwrapMatchSubject(subjectTy);

    if let case Type::Optional(inner) = subject.effectiveTy {

        try resolveMatchOptional(self, node, sw, inner);

    } else {

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

    }

    // Mark last non-guarded prong as exhaustive.

{

    let parentTy = try infer(self, access.parent);

    let subjectTy = autoDeref(parentTy);

    match subjectTy {

        }

        case Type::Array(arrayInfo) => {

            let fieldNode = access.child;

            let fieldName = try nodeName(self, fieldNode);

        else panic "getUnionVariantPayload: not a union";

    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.

                }

            }

            return payloadType;

        }

    }

    let callStmt = try getBlockStmt(blockNode, 1);

    { // Verify the function symbol captures an empty parameter list and void return.

        let sym = super::symbolFor(&a, fnNode)

            else throw testing::TestError::Failed;

            else throw testing::TestError::Failed;

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

        let fnSym = super::symbolFor(&a, fnNode)

            else throw testing::TestError::Failed;

            else throw testing::TestError::Failed;

        try expectType(&a, callExpr, *fnTy.returnType);

    }

}

    let callStmt = try getBlockStmt(blockNode, 1);

    { // Function returns i32 with no parameters.

        let sym = super::symbolFor(&a, fnNode)

            else throw testing::TestError::Failed;

            else throw testing::TestError::Failed;

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

        let fnSym = super::symbolFor(&a, fnNode)

            else throw testing::TestError::Failed;

            else throw testing::TestError::Failed;

        try expectType(&a, callExpr, *fnTy.returnType);

    }

}

    let callStmt = try getBlockStmt(blockNode, 2);

    { // Single parameter propagates nominal type onto the symbol and parameter node.

        let sym = super::symbolFor(&a, fnNode)

            else throw testing::TestError::Failed;

            else throw testing::TestError::Failed;

        try testing::expect(fnTy.paramTypes.len == 1);

        try testing::expect(*fnTy.paramTypes[0] == super::Type::I8);

        try testing::expect(*fnTy.returnType == super::Type::Void);

    }

    { // 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;

            else throw testing::TestError::Failed;

        try expectType(&a, callExpr, *fnTy.returnType);

    }

}

    let callStmt = try getBlockStmt(blockNode, 3);

    { // Ensure multi-parameter signatures record both argument types.

        let sym = super::symbolFor(&a, fnNode)

            else throw testing::TestError::Failed;

            else throw testing::TestError::Failed;

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

    }

    { // Call expression should again mirror the function return type.

        let callExpr = try expectExprStmtType(&a, callStmt, super::Type::Void);

        let fnSym = super::symbolFor(&a, fnNode)

            else throw testing::TestError::Failed;

            else throw testing::TestError::Failed;

        try expectType(&a, callExpr, *fnTy.returnType);

    }

}

    let fnNode = try getBlockStmt(blockNode, 0);

    { // Function symbol should be visible for recursive calls within its own body.

        let sym = super::symbolFor(&a, fnNode)

            else throw testing::TestError::Failed;

            else throw testing::TestError::Failed;

        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 array constant has the correct type with length 3.

    let arrStmt = try getBlockStmt(result.root, 1);

    let sym = super::symbolFor(&a, arrStmt)

        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;

    try testing::expect(arrType.length == 3);

}

/// Test that a record field can use a constant as its array length.