pub union Builtin {

    /// Size of type in bytes (`@sizeOf`).

    SizeOf,

    /// Alignment requirement of type (`@alignOf`).

    AlignOf,

    SliceOf,

}

/// Source extent for a node measured in bytes.

pub record Span {

/// Slice data pointer offset.

const SLICE_PTR_OFFSET: i32 = 0;

/// Offset of slice length in slice data structure.

const SLICE_LEN_OFFSET: i32 = 8;

// Trait Object Layout

//

// A trait object is a fat pointer consisting of a data pointer and a

// v-table pointer. `{ data: *T, vtable: *VTable }`.

        isUndefined: result.isUndefined,

        values: result.values,

    });

}

fn dataSliceHeader(b: *mut DataValueBuilder, dataSym: *[u8], len: u32) {

    dataBuilderPush(b, il::DataValue {

        item: il::DataItem::Sym(dataSym),

        count: 1

    });

            val: len as i64

        },

        count: 1

    });

    dataBuilderPush(b, il::DataValue {

    });

}

/// Lower a compile-time `&[...]` expression to a concrete slice header.

fn lowerConstAddressSliceInto(

    // Get data address.

    let ptrReg = nextReg(self);

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

    return try buildSliceValue(

    );

}

/// Generate a unique data name for inline literals, eg. `fnName/N`

fn nextDataName(self: *mut FnLowerer) -> *[u8] throws (LowerError) {

    let lenReg = nextReg(self);

    emitLoadW32At(self, lenReg, sliceReg, SLICE_LEN_OFFSET);

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

}

/// Emit a load instruction for a scalar value at `src` plus `offset`.

/// For reading values that may be aggregates, use `emitRead` instead.

fn emitLoad(self: *mut FnLowerer, src: il::Reg, offset: i32, typ: resolver::Type) -> il::Val {

    let dst = nextReg(self);

    let ilTyp = ilType(self.low, typ);

    };

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

        return il::Val::Imm(0);

    }

    if let case resolver::Type::Slice { item, mutable } = *inner {

    }

    let valOffset = resolver::getOptionalValOffset(*inner) as i32;

    return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);

}

        successType, &self.fnType.throwList[..self.fnType.throwListLen]

    );

    return try buildTagged(self, layout, tag, payload, payloadType, 8, RESULT_VAL_OFFSET);

}

fn buildSliceValue(

    self: *mut FnLowerer,

    elemTy: *resolver::Type,

    mutable: bool,

    ptrVal: il::Val,

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

    let sliceType = resolver::Type::Slice { item: elemTy, mutable };

    let dst = try emitReserve(self, sliceType);

    let ptrTy = resolver::Type::Pointer { target: elemTy, mutable };

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

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

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

}

/// Build a trait object fat pointer from a data pointer and a v-table.

            b: startVal,

        });

        sliceLen = il::Val::Reg(lenReg);

    }

    return try buildSliceValue(

    );

}

/// Lower an address-of (`&x`) expression.

fn lowerAddressOf(self: *mut FnLowerer, node: *ast::Node, addr: ast::AddressOf) -> il::Val throws (LowerError) {

    };

    let case resolver::Type::Slice { item, mutable } = sliceTy else {

        throw LowerError::UnexpectedType(&sliceTy);

    };

    if elements.len == 0 { // Empty slices don't need to be stored as data.

    }

    if resolver::isConstExpr(self.low.resolver, arrayNode) {

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

        return try lowerConstSliceLiteral(self, item, mutable, elements, elemLayout);

    } else {

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

    }

    let lenVal = il::Val::Imm(elements.len as i64);

}

/// Lower the common element pointer computation for subscript operations.

/// Handles both arrays and slices by resolving the container type, extracting

/// the data pointer (for slices), and emitting an [`il::Instr::Elem`] to compute

            return try constValueToVal(self, constVal, node);

        }

    }

}

fn lowerSliceOf(self: *mut FnLowerer, node: *ast::Node, args: ast::NodeList) -> il::Val throws (LowerError) {

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

}

/// Lower a `try` expression.

fn lowerTry(self: *mut FnLowerer, node: *ast::Node, t: ast::Try) -> il::Val throws (LowerError) {

    let case ast::NodeValue::Call(callExpr) = t.expr.value else {

fn w64 $sliceFull(w64 %0, w64 %1) {

  @entry0

    reserve %2 16 8;

    store w64 %1 %2 0;

    store w32 4 %2 8;

    blit %0 %2 16;

    ret %0;

}

    add w64 %4 %1 %3;

    sub w32 %5 4 %2;

    reserve %6 16 8;

    store w64 %4 %6 0;

    store w32 %5 %6 8;

    blit %0 %6 16;

    ret %0;

}

fn w64 $sliceOpenStart(w64 %0, w64 %1, w32 %2) {

  @entry0

    reserve %3 16 8;

    store w64 %1 %3 0;

    store w32 %2 %3 8;

    blit %0 %3 16;

    ret %0;

}

}

data $WORDS align 8 {

    sym $WORDS$0;

    w32 5;

    sym $WORDS$1;

    w32 6;

    sym $WORDS$0;

    w32 5;

}

fn w32 $totalLen() {

  @entry0

    copy %0 $WORDS;

}

data $KEYWORDS align 8 {

    sym $KEYWORDS$0;

    w32 2;

    w8 0;

    undef * 7;

    sym $KEYWORDS$1;

    w32 3;

    w8 1;

    undef * 7;

    sym $KEYWORDS$2;

    w32 2;

    w8 2;

    undef * 7;

}

fn w32 $getFirstTag() {

}

data $GROUPS$2 align 8 {

    sym $GROUPS$0;

    w32 2;

    sym $GROUPS$1;

    w32 2;

}

data $GROUPS$3 align 1 {

    str "efg";

}

data $GROUPS$4 align 8 {

    sym $GROUPS$3;

    w32 3;

}

data $GROUPS align 8 {

    sym $GROUPS$2;

    w32 2;

    sym $GROUPS$4;

    w32 1;

}

fn w32 $totalLen() {

  @entry0

    copy %0 $GROUPS;

}

data $HELLO align 8 {

    sym $HELLO$0;

    w32 5;

}

fn w32 $getLen() {

  @entry0

    copy %0 $HELLO$0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 5 %1 8;

    load w32 %2 %1 8;

    ret %2;

}

}

data $HELLO1 align 8 {

    sym $HELLO1$0;

    w32 5;

}

data $HELLO2 align 8 {

    sym $HELLO1$0;

    w32 5;

}

data $MSGS$3 align 1 {

    str "world";

}

data $MSGS align 8 {

    sym $HELLO1$0;

    w32 5;

    sym $MSGS$3;

    w32 5;

}

fn w32 $totalLen() {

  @entry0

    copy %0 $HELLO1$0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 5 %1 8;

    load w32 %2 %1 8;

    copy %3 $HELLO1$0;

    reserve %4 16 8;

    store w64 %3 %4 0;

    store w32 5 %4 8;

    load w32 %5 %4 8;

    add w32 %6 %2 %5;

    copy %7 $MSGS;

    load w32 %8 %7 8;

    add w32 %9 %6 %8;

    store w32 3 %0 8;

    reserve %1 24 8;

    reserve %2 16 8;

    store w64 %0 %2 0;

    store w32 3 %2 8;

    blit %1 %2 16;

    store w32 77 %1 16;

    load w32 %3 %1 8;

    ret %3;

}

  @entry0

    copy %0 $byteSlice0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 3 %1 8;

    load w32 %2 %1 8;

    ret %2;

}

  @entry0

    copy %0 $dedupSlice0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 3 %1 8;

    copy %2 $dedupSlice0;

    reserve %3 16 8;

    store w64 %2 %3 0;

    store w32 3 %3 8;

    load w32 %4 %1 8;

    load w32 %5 %3 8;

    add w32 %6 %4 %5;

    ret %6;

}

fn w32 $emptySlice() {

  @entry0

    reserve %0 16 8;

    store w64 0 %0 0;

    store w32 0 %0 8;

    load w32 %1 %0 8;

    ret %1;

}

  @entry0

    copy %0 $multiSlice0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 2 %1 8;

    copy %2 $multiSlice1;

    reserve %3 16 8;

    store w64 %2 %3 0;

    store w32 3 %3 8;

    load w32 %4 %1 8;

    load w32 %5 %3 8;

    add w32 %6 %4 %5;

    ret %6;

}

  @entry0

    copy %0 $localSliceOfRecords0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 2 %1 8;

    load w32 %2 %1 8;

    br.ult w32 0 %2 @guard#pass1 @guard#trap2;

  @guard#pass1

    load w64 %3 %1 0;

    sload w32 %4 %3 0;

  @entry0

    copy %0 $sliceLiteral0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 3 %1 8;

    load w32 %2 %1 8;

    ret %2;

}

  @entry0

    copy %0 $dedupString0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 5 %1 8;

    copy %2 $dedupString0;

    reserve %3 16 8;

    store w64 %2 %3 0;

    store w32 5 %3 8;

    load w32 %4 %1 8;

    load w32 %5 %3 8;

    add w32 %6 %4 %5;

    ret %6;

}

  @entry0

    copy %0 $emptyString0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 0 %1 8;

    load w32 %2 %1 8;

    ret %2;

}

  @entry0

    copy %0 $first0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 3 %1 8;

    load w32 %2 %1 8;

    ret %2;

}

fn w32 $second() {

  @entry0

    copy %0 $second0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 3 %1 8;

    load w32 %2 %1 8;

    ret %2;

}

  @entry0

    copy %0 $multiString0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 5 %1 8;

    copy %2 $multiString1;

    reserve %3 16 8;

    store w64 %2 %3 0;

    store w32 5 %3 8;

    load w32 %4 %1 8;

    load w32 %5 %3 8;

    add w32 %6 %4 %5;

    ret %6;

}

  @entry0

    copy %0 $stringLen0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w32 5 %1 8;

    load w32 %2 %1 8;

    ret %2;

}

fn w64 $nilSlice(w64 %0) {

  @entry0

    reserve %1 16 8;

    store w64 0 %1 0;

    store w32 0 %1 8;

    blit %0 %1 16;

    ret %0;

}

fn w8 $nilCheck(w64 %0) {

/// Returns the length field from a slice header.

fn sliceLen(s: *[i32]) -> u32 {

    return s.len;

}

/// Returns the pointer field from a slice header.

fn slicePtr(s: *[i32]) -> *i32 {

    return s.ptr;

}

/// Builds a slice header from a pointer and length.

fn sliceOf(ptr: *i32, len: u32) -> *[i32] {

    return @sliceOf(ptr, len);

}

  @entry0

    load w32 %1 %0 8;

    ret %1;

}

fn w64 $slicePtr(w64 %0) {

  @entry0

    load w64 %1 %0 0;

    ret %1;

}

fn w64 $sliceOf(w64 %0, w64 %1, w32 %2) {

  @entry0

    reserve %3 16 8;

    store w64 %1 %3 0;

    store w32 %2 %3 8;

    blit %0 %3 16;

    ret %0;

}

    add w64 %7 %4 %6;

    sub w32 %8 %3 %2;

    reserve %9 16 8;

    store w64 %7 %9 0;

    store w32 %8 %9 8;

    blit %0 %9 16;

    ret %0;

}

fn w64 $sliceRangeOpenEnd(w64 %0, w64 %1, w32 %2) {

    add w64 %6 %3 %5;

    sub w32 %7 %4 %2;

    reserve %8 16 8;

    store w64 %6 %8 0;

    store w32 %7 %8 8;

    blit %0 %8 16;

    ret %0;

}

fn w64 $sliceRangeOpenStart(w64 %0, w64 %1, w32 %2) {

    load w64 %3 %1 0;

    load w32 %4 %1 8;

    reserve %5 16 8;

    store w64 %3 %5 0;

    store w32 %2 %5 8;

    blit %0 %5 16;

    ret %0;

}

fn w64 $sliceRangeFull(w64 %0, w64 %1) {

    load w64 %2 %1 0;

    load w32 %3 %1 8;

    reserve %4 16 8;

    store w64 %2 %4 0;

    store w32 %3 %4 8;

    blit %0 %4 16;

    ret %0;

}

fn w64 $sliceArray(w64 %0, w64 %1) {

    add w64 %3 %1 %2;

    sub w32 %4 3 1;

    reserve %5 16 8;

    store w64 %3 %5 0;

    store w32 %4 %5 8;

    blit %0 %5 16;

    ret %0;

}

    reserve %2 4 4;

    store w32 %1 %2 0;

    reserve %3 16 8;

    store w64 %2 %3 0;

    store w32 1 %3 8;

    blit %0 %3 16;

    ret %0;

}

fn w64 $sliceWithVars(w64 %0, w32 %1, w32 %2) {

    store w32 %1 %3 0;

    store w32 %2 %3 4;

    reserve %4 16 8;

    store w64 %3 %4 0;

    store w32 2 %4 8;

    blit %0 %4 16;

    ret %0;

}

fn w64 $sliceWithMixed(w64 %0, w32 %1) {

    store w32 42 %2 4;

    store w32 %1 %2 8;

    reserve %3 16 8;

    store w64 %2 %3 0;

    store w32 3 %3 8;

    blit %0 %3 16;

    ret %0;

}

    reserve %2 1 1;

    store w8 %1 %2 0;

    reserve %3 16 8;

    store w64 %2 %3 0;

    store w32 1 %3 8;

    blit %0 %3 16;

    ret %0;

}

fn w64 $sliceWithVars(w64 %0, w8 %1, w8 %2) {

    store w8 %1 %3 0;

    store w8 %2 %3 1;

    reserve %4 16 8;

    store w64 %3 %4 0;

    store w32 2 %4 8;

    blit %0 %4 16;

    ret %0;

}

/// Identifier for the synthetic `len` field.

pub const LEN_FIELD: *[u8] = "len";

/// Identifier for the synthetic `ptr` field.

pub const PTR_FIELD: *[u8] = "ptr";

/// Maximum `u16` value.

const U16_MAX: u16 = 0xFFFF;

/// Maximum `u8` value.

const U8_MAX: u16 = 0xFF;

                case 1 => return RecordField {

                    name: LEN_FIELD,

                    fieldType: Type::U32,

                    offset: PTR_SIZE as i32,

                },

                else => return nil,

            }

        }

        else => return nil,

    }

    self: *mut Resolver,

    node: *ast::Node,

    kind: ast::Builtin,

    args: *ast::NodeList

) -> Type throws (ResolveError) {

    if kind == ast::Builtin::SliceOf {

            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 case Type::Pointer { target, mutable } = ptrType else {

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

        };

        let _ = try checkAssignable(self, args.list[1], Type::U32);

    }

    if args.len != 1 {

        throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {

            expected: 1,

            actual: args.len as u32,

            }

            if mem::eq(fieldName, LEN_FIELD) {

                try setRecordFieldIndex(self, fieldNode, 1);

                return try setNodeType(self, node, Type::U32);

            }

            throw emitError(self, node, ErrorKind::SliceFieldUnknown(fieldName));

        }

        case Type::TraitObject { traitInfo, .. } => {

            let fieldName = try nodeName(self, access.child);

            let method = findTraitMethod(traitInfo, fieldName)

        try testing::expect(mismatch.actual == 1);

    }

    // Too many arguments.

    {

        let mut a = testResolver();

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

        let err = try expectError(&result);

        let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind

            else throw testing::TestError::Failed;

        try testing::expect(mismatch.expected == 2);

    }

}

/// Test @sliceOf with wrong argument types produces errors.

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

        let case super::ErrorKind::TypeMismatch(_) = err.kind

            else throw testing::TestError::Failed;

    }

}

/// Test `match &opt` produces immutable pointer bindings.

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

    let mut a = testResolver();

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