});

        }

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

    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.

        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.