assert(@sizeOf(?*[u16]) == 16);

    assert(@sizeOf(?*mut [u8]) == 16);

//! Test nil check for optional pointers and slices.

//! Ensure that nil checks compare the full pointer width, not just the low byte.

/// Return a pointer whose low byte is zero but is non-null.

/// This tests that nil checks use W64, not W8.

fn makeAlignedPtr() -> *u8 {

    let arr: [u8; 512] = undefined;

    // Find an address within arr whose low byte is 0x00.

    let base: u64 = &arr[0] as u64;

    let offset: u64 = 256 - (base % 256);

    return &arr[offset as u32] as *u8;

}

/// Test: optional pointer nil check must use full 64-bit comparison.

fn testOptionalPtrNilCheck() -> i32 {

    let p = makeAlignedPtr();

    let opt: ?*u8 = p;

    // The pointer is not nil, but its low byte is 0x00.

    // A W8 comparison would wrongly say it's nil.

    if opt == nil {

        return 1;

    }

    if let v = opt {

        // Good: correctly identified as non-nil.

        return 0;

    }

    return 2;

}

/// Test: optional slice nil check must use full 64-bit comparison.

fn testOptionalSliceNilCheck() -> i32 {

    let arr: [u8; 512] = undefined;

    let base: u64 = &arr[0] as u64;

    let offset: u64 = 256 - (base % 256);

    // Create a slice starting at an address whose low byte is 0.

    let s: *[u8] = &arr[offset as u32 ..];

    let opt: ?*[u8] = s;

    if opt == nil {

        return 1;

    }

    if let v = opt {

        return 0;

    }

    return 2;

}

@default fn main() -> i32 {

    let r1 = testOptionalPtrNilCheck();

    if r1 != 0 {

        return r1;

    }

    let r2 = testOptionalSliceNilCheck();

    if r2 != 0 {

        return 10 + r2;

    }

    return 0;

}

//! Test null pointer optimization for optional slices (?*[T]).

//! Optional slices should have the same size as slices (16 bytes),

//! using a null data pointer to represent `nil`.

fn assert(cond: bool) {

    if not cond {

        panic;

    }

}

fn checkSizes() -> u8 {

    // ?*[T] should be the same size as *[T] (16 bytes, not 24).

    if @sizeOf(?*[u8]) != 16 {

        return 1;

    }

    if @alignOf(?*[u8]) != 8 {

        return 2;

    }

    if @sizeOf(?*[u16]) != 16 {

        return 3;

    }

    if @sizeOf(?*mut [u8]) != 16 {

        return 4;

    }

    return 0;

}

fn checkNil() -> u8 {

    let x: ?*[u8] = nil;

    if x != nil {

        return 10;

    }

    return 0;

}

fn checkWrap() -> u8 {

    let arr: [u8; 3] = [1, 2, 3];

    let s = &arr[..];

    let opt: ?*[u8] = s;

    if opt == nil {

        return 20;

    }

    return 0;

}

fn checkIfLet() -> u8 {

    let arr: [u8; 3] = [10, 20, 30];

    let s = &arr[..];

    let opt: ?*[u8] = s;

    if let val = opt {

        if val.len != 3 {

            return 31;

        }

        if val[0] != 10 {

            return 32;

        }

        if val[1] != 20 {

            return 33;

        }

    } else {

        return 34;

    }

    let none: ?*[u8] = nil;

    if let _ = none {

        return 35;

    }

    return 0;

}

fn checkLetElse() -> u8 {

    let arr: [u8; 3] = [10, 20, 30];

    let s = &arr[..];

    let opt: ?*[u8] = s;

    let val = opt else {

        return 40;

    };

    if val.len != 3 {

        return 41;

    }

    return 0;

}

fn returnNil() -> ?*[u8] {

    return nil;

}

fn returnSome() -> ?*[u8] {

    let arr: [u8; 2] = [42, 99];

    return &arr[..];

}

fn checkReturn() -> u8 {

    let a = returnNil();

    if a != nil {

        return 50;

    }

    let b = returnSome();

    if b == nil {

        return 51;

    }

    if let val = b {

        if val[0] != 42 {

            return 52;

        }

    } else {

        return 53;

    }

    return 0;

}

fn checkMatch() -> u8 {

    let arr: [u8; 2] = [5, 6];

    let s = &arr[..];

    let opt: ?*[u8] = s;

    match opt {

        case nil => {

            return 60;

        }

        else => {}

    }

    let none: ?*[u8] = nil;

    match none {

        case nil => {}

        else => {

            return 61;

        }

    }

    return 0;

}

fn checkEq() -> u8 {

    let a: ?*[u8] = nil;

    let b: ?*[u8] = nil;

    // nil == nil

    if a != b {

        return 70;

    }

    let arr: [u8; 2] = [1, 2];

    let s = &arr[..];

    let c: ?*[u8] = s;

    // some != nil

    if c == a {

        return 71;

    }

    // some == some (same pointer)

    let d: ?*[u8] = s;

    if c != d {

        return 72;

    }

    return 0;

}

@default fn main() -> u8 {

    let r1 = checkSizes();

    if r1 != 0 {

        return r1;

    }

    let r2 = checkNil();

    if r2 != 0 {

        return r2;

    }

    let r3 = checkWrap();

    if r3 != 0 {

        return r3;

    }

    let r4 = checkIfLet();

    if r4 != 0 {

        return r4;

    }

    let r5 = checkLetElse();

    if r5 != 0 {

        return r5;

    }

    let r6 = checkReturn();

    if r6 != 0 {

        return r6;

    }

    let r7 = checkMatch();

    if r7 != 0 {

        return r7;

    }

    let r8 = checkEq();

    if r8 != 0 {

        return r8;

    }

    return 0;

}

    /// Optional with null pointer optimization: `?*T`, `?*[T]`.

    if resolver::isOptionalPointer(type) {

        return MatchSubjectKind::OptionalPtr;

    }

    if resolver::isOptionalAggregate(type) {

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

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

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

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

        return ptrReg;

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

        return reg;

    }

    return tvalTagReg(self, reg);

    // Null-pointer-optimized types compare a 64-bit pointer against zero.

    // Aggregate optionals compare an 8-bit tag byte against zero.

    let mut cmpType = il::Type::W8;

    if resolver::isOptionalPointer(optTy) {

        cmpType = il::Type::W64;

    }

        return emitTypedBinOp(self, il::BinOp::Eq, cmpType, il::Val::Reg(cmpReg), il::Val::Imm(0));

        return emitTypedBinOp(self, il::BinOp::Ne, cmpType, il::Val::Reg(cmpReg), il::Val::Imm(0));

        else => {

            // Optional pointers are scalar (single word). All other

            // optionals, including optional slices with NPO, are aggregates.

            if let case resolver::Type::Optional(inner) = typ {

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

                    return false;

                }

                return true;

            }

            return false;

        }

    // Null-pointer-optimized (NPO) types are used as-is -- valid values are never null.

    if resolver::isNullableType(*inner) {

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

        return try buildSliceValue(self, item, mutable, il::Val::Imm(0), il::Val::Imm(0));

    }

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

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

                // Optional slices use null pointer optimization.

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

            }

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

        }

    eq w64 %1 %0 0;

    ne w64 %1 %0 0;

//! Test null pointer optimization for optional slices.

//! ?*[T] uses the same representation as *[T], with nil = null data pointer.

fn wrapSlice(s: *[u8]) -> ?*[u8] {

    return s;

}

fn nilSlice() -> ?*[u8] {

    return nil;

}

fn nilCheck(s: ?*[u8]) -> bool {

    return s == nil;

}

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

  @entry0

    blit %0 %1 16;

    ret %0;

}

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

  @entry0

    load w64 %1 %0 0;

    eq w64 %2 %1 0;

    ret %2;

}

    eq w64 %1 %0 0;

    ne w64 %1 %0 0;

    // Nullable types use null pointer optimization -- no tag byte needed.

    if isNullableType(inner) {

        return getTypeLayout(inner);

/// Check if a type uses null pointer optimization.

/// This applies to optional pointers `?*T` and optional slices `?*[T]`,

/// where `nil` is represented as a null data pointer with no tag byte.

        return isNullableType(*inner);

        return not isNullableType(*inner);

/// Check if a type can use null to represent `nil`.

/// Pointers and slices have a data pointer that is never null when valid.

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

    match ty {

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

        else => return false,

    }

}