//! Test slice .append() method with inline allocator.

/// Simple bump allocator for testing.

record Arena {

    data: *mut [u8],

    offset: u32,

}

fn newArena(data: *mut [u8]) -> Arena {

    return Arena { data, offset: 0 };

}

fn arenaAlloc(arena: *mut Arena, size: u32, al: u32) -> *mut opaque {

    let aligned = (arena.offset + al - 1) / al * al;

    let newOffset = aligned + size;

    assert newOffset <= arena.data.len as u32;

    let base: *mut u8 = &mut arena.data[aligned];

    arena.offset = newOffset;

    return base as *mut opaque;

}

/// Allocator record matching the compiler's expected layout.

record Allocator {

    func: fn(*mut opaque, u32, u32) -> *mut opaque,

    ctx: *mut opaque,

}

fn arenaAllocFn(ctx: *mut opaque, size: u32, al: u32) -> *mut opaque {

    let arena = ctx as *mut Arena;

    return arenaAlloc(arena, size, al);

}

fn arenaAllocator(arena: *mut Arena) -> Allocator {

    return Allocator {

        func: arenaAllocFn,

        ctx: arena as *mut opaque,

    };

}

static BUF: [u8; 4096] = undefined;

@default fn main() -> i32 {

    let mut arena = newArena(&mut BUF[..]);

    let a = arenaAllocator(&mut arena);

    // Allocate initial capacity of 4.

    let ptr = arenaAlloc(&mut arena, @sizeOf(i32) * 4, @alignOf(i32));

    let mut nums = @sliceOf(ptr as *mut i32, 0, 4);

    // Append within capacity.

    nums.append(10, a);

    nums.append(20, a);

    nums.append(30, a);

    if nums.len != 3 {

        return 1;

    }

    if nums.cap != 4 {

        return 2;

    }

    if nums[0] != 10 {

        return 3;

    }

    if nums[1] != 20 {

        return 4;

    }

    if nums[2] != 30 {

        return 5;

    }

    // Append to fill capacity.

    nums.append(40, a);

    if nums.len != 4 {

        return 6;

    }

    if nums.cap != 4 {

        return 7;

    }

    // Append past capacity -- triggers growth.

    nums.append(50, a);

    if nums.len != 5 {

        return 8;

    }

    // Cap should have grown (cap * 2 | 1 = 4 * 2 | 1 = 9).

    if nums.cap != 9 {

        return 9;

    }

    if nums[4] != 50 {

        return 10;

    }

    // Verify old elements survived the copy.

    if nums[0] != 10 {

        return 11;

    }

    if nums[3] != 40 {

        return 12;

    }

    // Append from empty (cap == 0 triggers growth with cap = 1).

    let mut empty = @sliceOf(ptr as *mut i32, 0, 0);

    empty.append(99, a);

    if empty.len != 1 {

        return 13;

    }

    if empty.cap != 1 {

        return 14;

    }

    if empty[0] != 99 {

        return 15;

    }

    // Sum all elements in nums.

    let mut sum: i32 = 0;

    for n in nums {

        sum += n;

    }

    if sum != 150 {

        return 16;

    }

    // Test append with u8 elements (stride = 1).

    let bytePtr = arenaAlloc(&mut arena, 2, 1);

    let mut bytes = @sliceOf(bytePtr as *mut u8, 0, 2);

    bytes.append(0xAB, a);

    bytes.append(0xCD, a);

    if bytes.len != 2 {

        return 17;

    }

    if bytes[0] != 0xAB {

        return 18;

    }

    if bytes[1] != 0xCD {

        return 19;

    }

    // Trigger growth on u8 slice.

    bytes.append(0xEF, a);

    if bytes.len != 3 {

        return 20;

    }

    if bytes.cap != 5 {

        return 21;

    }

    if bytes[2] != 0xEF {

        return 22;

    }

    // Verify old u8 elements survived.

    if bytes[0] != 0xAB {

        return 23;

    }

    return 0;

}

//! Test slice .delete() method.

@default fn main() -> i32 {

    let mut arr: [i32; 5] = [10, 20, 30, 40, 50];

    let mut s = &mut arr[..];

    // Delete middle element (index 2: value 30).

    s.delete(2);

    if s.len != 4 {

        return 1;

    }

    if s[0] != 10 {

        return 2;

    }

    if s[1] != 20 {

        return 3;

    }

    if s[2] != 40 {

        return 4;

    }

    if s[3] != 50 {

        return 5;

    }

    // Delete first element (index 0: value 10).

    s.delete(0);

    if s.len != 3 {

        return 6;

    }

    if s[0] != 20 {

        return 7;

    }

    if s[1] != 40 {

        return 8;

    }

    if s[2] != 50 {

        return 9;

    }

    // Delete last element (index 2: value 50).

    s.delete(2);

    if s.len != 2 {

        return 10;

    }

    if s[0] != 20 {

        return 11;

    }

    if s[1] != 40 {

        return 12;

    }

    // Cap should be unchanged.

    if s.cap != 5 {

        return 13;

    }

    return 0;

}

/// Emit a byte-copy loop: `for i in 0..size { dst[i] = src[i]; }`.

///

/// Used when `blit` cannot be used because the copy size is dynamic.

/// Terminates the current block and leaves the builder positioned

/// after the loop.

fn emitByteCopyLoop(

    self: *mut FnLowerer,

    dst: il::Reg,

    src: il::Reg,

    size: il::Val,

    label: *[u8]

) throws (LowerError) {

    let iReg = nextReg(self);

    let header = try createBlockWithParam(

        self, label, il::Param { value: iReg, type: il::Type::W32 }

    );

    let body = try createBlock(self, label);

    let done = try createBlock(self, label);

    // Jump to header with initial counter is zero.

    try emitJmpWithArg(self, header, il::Val::Imm(0));

    // Don't seal header yet -- the body will add another predecessor.

    switchToBlock(self, header);

    try emitBrCmp(self, il::CmpOp::Ult, il::Type::W32, il::Val::Reg(iReg), size, body, done);

    // Body: load byte from source, store to destination, increment counter.

    try switchToAndSeal(self, body);

    let srcElem = emitElem(self, 1, src, il::Val::Reg(iReg));

    let byteReg = nextReg(self);

    emit(self, il::Instr::Load { typ: il::Type::W8, dst: byteReg, src: srcElem, offset: 0 });

    let dstElem = emitElem(self, 1, dst, il::Val::Reg(iReg));

    emit(self, il::Instr::Store { typ: il::Type::W8, src: il::Val::Reg(byteReg), dst: dstElem, offset: 0 });

    let nextI = emitTypedBinOp(self, il::BinOp::Add, il::Type::W32, il::Val::Reg(iReg), il::Val::Imm(1));

    // Jump back to header -- this adds body as a predecessor.

    try emitJmpWithArg(self, header, nextI);

    // Now all predecessors of header are known, seal it.

    try sealBlock(self, header);

    try switchToAndSeal(self, done);

}

/// Lower `slice.append(val, allocator)`.

///

/// Emits inline grow-if-needed logic:

///

///     load len, cap from slice header

///     if len < cap: jmp @store

///     else:         jmp @grow

///

///     @grow:

///       newCap = max(cap * 2, 1)

///       call allocator.func(allocator.ctx, newCap * stride, alignment)

///       copy old data to new pointer

///       update slice ptr and cap

///       jmp @store

///

///     @store:

///       store element at ptr + len * stride

///       increment len

///

fn lowerSliceAppend(self: *mut FnLowerer, call: ast::Call, elemType: *resolver::Type) throws (LowerError) {

    let case ast::NodeValue::FieldAccess(access) = call.callee.value

        else throw LowerError::MissingMetadata;

    // Get the address of the slice header.

    let sliceVal = try lowerExpr(self, access.parent);

    let sliceReg = try emitValToReg(self, sliceVal);

    // Lower the value to append and the allocator.

    let elemVal = try lowerExpr(self, call.args.list[0]);

    let allocVal = try lowerExpr(self, call.args.list[1]);

    let allocReg = try emitValToReg(self, allocVal);

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

    let stride = elemLayout.size;

    let alignment = elemLayout.alignment;

    // Load current length and capacity.

    let lenVal = loadSliceLen(self, sliceReg);

    let capVal = loadSliceCap(self, sliceReg);

    // Branch: if length is smaller than capacity, go to @store else @grow.

    let storeBlock = try createBlock(self, "append.store");

    let growBlock = try createBlock(self, "append.grow");

    try emitBrCmp(self, il::CmpOp::Ult, il::Type::W32, lenVal, capVal, storeBlock, growBlock);

    try switchToAndSeal(self, growBlock);

    // -- @grow block ----------------------------------------------------------

    // `newCap = max(cap * 2, 1)`.

    // We are only here when at capacity, so we use `or` with `1` to ensure at least capacity `1`.

    let doubledVal = emitTypedBinOp(self, il::BinOp::Shl, il::Type::W32, capVal, il::Val::Imm(1));

    let newCapVal = emitTypedBinOp(self, il::BinOp::Or, il::Type::W32, doubledVal, il::Val::Imm(1));

    // Call allocator: `a.func(a.ctx, newCap * stride, alignment)`.

    let allocFnReg = nextReg(self);

    emitLoadW64At(self, allocFnReg, allocReg, 0);

    let allocCtxReg = nextReg(self);

    emitLoadW64At(self, allocCtxReg, allocReg, 8);

    let byteSize = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, newCapVal, il::Val::Imm(stride as i64));

    let args = try allocVals(self, 3);

    args[0] = il::Val::Reg(allocCtxReg);

    args[1] = byteSize;

    args[2] = il::Val::Imm(alignment as i64);

    let newPtrReg = nextReg(self);

    emit(self, il::Instr::Call {

        retTy: il::Type::W64,

        dst: newPtrReg,

        func: il::Val::Reg(allocFnReg),

        args,

    });

    // Copy old data byte-by-byte.

    let oldPtrReg = loadSlicePtr(self, sliceReg);

    let copyBytes = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, lenVal, il::Val::Imm(stride as i64));

    try emitByteCopyLoop(self, newPtrReg, oldPtrReg, copyBytes, "append");

    // Update slice header.

    emitStoreW64At(self, il::Val::Reg(newPtrReg), sliceReg, SLICE_PTR_OFFSET);

    emitStoreW32At(self, newCapVal, sliceReg, SLICE_CAP_OFFSET);

    try emitJmp(self, storeBlock);

    try switchToAndSeal(self, storeBlock);

    // -- @store block ---------------------------------------------------------

    // Store element at `ptr + len * stride`.

    let ptrReg = loadSlicePtr(self, sliceReg);

    let elemDst = emitElem(self, stride, ptrReg, lenVal);

    try emitStore(self, elemDst, 0, *elemType, elemVal);

    // Increment len.

    let newLen = emitTypedBinOp(self, il::BinOp::Add, il::Type::W32, lenVal, il::Val::Imm(1));

    emitStoreW32At(self, newLen, sliceReg, SLICE_LEN_OFFSET);

}

/// Lower `slice.delete(index)`.

///

/// Bounds-check the index, shift elements after it by one stride

/// via a byte-copy loop, and decrement `len`.

fn lowerSliceDelete(self: *mut FnLowerer, call: ast::Call, elemType: *resolver::Type) throws (LowerError) {

    let case ast::NodeValue::FieldAccess(access) = call.callee.value

        else throw LowerError::MissingMetadata;

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

    let stride = elemLayout.size;

    // Get slice header address.

    let sliceVal = try lowerExpr(self, access.parent);

    let sliceReg = try emitValToReg(self, sliceVal);

    // Lower the index argument.

    let indexVal = try lowerExpr(self, call.args.list[0]);

    // Load len and bounds-check: index must be smaller than length.

    let lenVal = loadSliceLen(self, sliceReg);

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

    // Compute the destination and source for the shift.

    let ptrReg = loadSlicePtr(self, sliceReg);

    let dst = emitElem(self, stride, ptrReg, indexVal);

    // `src = dst + stride`.

    let src = emitPtrOffset(self, dst, stride as i32);

    // Move `(len - index - 1) * stride`.

    let tailLen = emitTypedBinOp(self, il::BinOp::Sub, il::Type::W32, lenVal, indexVal);

    let tailLenMinusOne = emitTypedBinOp(self, il::BinOp::Sub, il::Type::W32, tailLen, il::Val::Imm(1));

    let moveBytes = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, tailLenMinusOne, il::Val::Imm(stride as i64));

    // Shift elements left via byte-copy loop.

    // When deleting the last element, the loop is a no-op.

    try emitByteCopyLoop(self, dst, src, moveBytes, "delete");

    // Decrement length.

    let newLen = emitTypedBinOp(self, il::BinOp::Sub, il::Type::W32, lenVal, il::Val::Imm(1));

    emitStoreW32At(self, newLen, sliceReg, SLICE_LEN_OFFSET);

}

    let nodeData = resolver::nodeData(self.low.resolver, node).extra;

    // Check for slice method dispatch.

    if let case resolver::NodeExtra::SliceAppend { elemType } = nodeData {

        try lowerSliceAppend(self, call, elemType);

        return il::Val::Undef;

    }

    if let case resolver::NodeExtra::SliceDelete { elemType } = nodeData {

        try lowerSliceDelete(self, call, elemType);

        return il::Val::Undef;

    }

    if let case resolver::NodeExtra::TraitMethodCall { traitInfo, methodIndex } = nodeData {

/// Allocator-like record used by .append().

record Alloc {

    func: fn(*mut opaque, u32, u32) -> *mut opaque,

    ctx: *mut opaque,

}

/// Append an i32 to a mutable slice.

fn appendI32(s: *mut [i32], val: i32, a: Alloc) {

    s.append(val, a);

}

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

  @entry0

    load w32 %3 %0 8;

    load w32 %4 %0 12;

    br.ult w32 %3 %4 @append.store1 @append.grow2;

  @append.store1

    load w64 %20 %0 0;

    mul w64 %21 %3 4;

    add w64 %22 %20 %21;

    store w32 %1 %22 0;

    add w32 %23 %3 1;

    store w32 %23 %0 8;

    ret;

  @append.grow2

    shl w32 %5 %4 1;

    or w32 %6 %5 1;

    load w64 %7 %2 0;

    load w64 %8 %2 8;

    mul w32 %9 %6 4;

    call w64 %10 %7(%8, %9, 4);

    load w64 %11 %0 0;

    mul w32 %12 %3 4;

    jmp @append3(0);

  @append3(w32 %13)

    br.ult w32 %13 %12 @append4 @append5;

  @append4

    mul w64 %14 %13 1;

    add w64 %15 %11 %14;

    load w8 %16 %15 0;

    mul w64 %17 %13 1;

    add w64 %18 %10 %17;

    store w8 %16 %18 0;

    add w32 %19 %13 1;

    jmp @append3(%19);

  @append5

    store w64 %10 %0 0;

    store w32 %6 %0 12;

    jmp @append.store1;

}

/// Delete an element from a mutable i32 slice by index.

fn deleteI32(s: *mut [i32], idx: u32) {

    s.delete(idx);

}

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

  @entry0

    load w32 %2 %0 8;

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

  @guard#pass1

    load w64 %3 %0 0;

    mul w64 %4 %1 4;

    add w64 %5 %3 %4;

    add w64 %6 %5 4;

    sub w32 %7 %2 %1;

    sub w32 %8 %7 1;

    mul w32 %9 %8 4;

    jmp @delete3(0);

  @guard#trap2

    ebreak;

    unreachable;

  @delete3(w32 %10)

    br.ult w32 %10 %9 @delete4 @delete5;

  @delete4

    mul w64 %11 %10 1;

    add w64 %12 %6 %11;

    load w8 %13 %12 0;

    mul w64 %14 %10 1;

    add w64 %15 %5 %14;

    store w8 %13 %15 0;

    add w32 %16 %10 1;

    jmp @delete3(%16);

  @delete5

    sub w32 %17 %2 1;

    store w32 %17 %0 8;

    ret;

}

    /// Slice `.append(val, allocator)` method call.

    SliceAppend { elemType: *Type },

    /// Slice `.delete(index)` method call.

    SliceDelete { elemType: *Type },

    // Intercept method calls on slices before inferring the callee.

    if let case ast::NodeValue::FieldAccess(access) = call.callee.value {

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

        let subjectTy = autoDeref(parentTy);

        if let case Type::Slice { item, mutable } = subjectTy {

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

            if methodName == "append" {

                return try resolveSliceAppend(self, node, access.parent, &call.args, item, mutable);

            }

            if methodName == "delete" {

                return try resolveSliceDelete(self, node, access.parent, &call.args, item, mutable);

            }

        }

    }

/// Resolve `slice.append(val, allocator)`.

fn resolveSliceAppend(

    self: *mut Resolver,

    node: *ast::Node,

    parent: *ast::Node,

    args: *ast::NodeList,

    elemType: *Type,

    mutable: bool

) -> Type throws (ResolveError) {

    if not mutable {

        throw emitError(self, parent, ErrorKind::ImmutableBinding);

    }

    if args.len != 2 {

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

            expected: 2,

            actual: args.len as u32,

        }));

    }

    // First argument must be assignable to the element type.

    try checkAssignable(self, args.list[0], *elemType);

    // Second argument: the allocator. We accept any type -- the lowerer

    // reads .func and .ctx at fixed offsets (structurally typed).

    try visit(self, args.list[1], Type::Unknown);

    self.nodeData.entries[node.id].extra = NodeExtra::SliceAppend { elemType };

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

}

/// Resolve `slice.delete(index)`.

fn resolveSliceDelete(

    self: *mut Resolver,

    node: *ast::Node,

    parent: *ast::Node,

    args: *ast::NodeList,

    elemType: *Type,

    mutable: bool

) -> Type throws (ResolveError) {

    if not mutable {

        throw emitError(self, parent, ErrorKind::ImmutableBinding);

    }

    if args.len != 1 {

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

            expected: 1,

            actual: args.len as u32,

        }));

    }

    try checkAssignable(self, args.list[0], Type::U32);

    self.nodeData.entries[node.id].extra = NodeExtra::SliceDelete { elemType };

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

}

/// Test `.append()` on immutable slice produces an error.

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

    let mut a = testResolver();

    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *[i32], a: A) { s.append(1, a); }";

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

    let err = try expectError(&result);

    let case super::ErrorKind::ImmutableBinding = err.kind

        else throw testing::TestError::Failed;

}

/// Test `.append()` with wrong argument count produces an error.

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

    // Too few arguments.

    {

        let mut a = testResolver();

        let program = "fn f(s: *mut [i32]) { s.append(1); }";

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

        let err = try expectError(&result);

        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind

            else throw testing::TestError::Failed;

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

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

    }

    // Too many arguments.

    {

        let mut a = testResolver();

        let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a, 0); }";

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

        let err = try expectError(&result);

        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind

            else throw testing::TestError::Failed;

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

        try testing::expect(m.actual == 3);

    }

}

/// Test `.append()` with correct arguments succeeds.

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

    let mut a = testResolver();

    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a); }";

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

    try expectNoErrors(&result);

}

/// Test `.append()` with wrong element type produces an error.

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

    let mut a = testResolver();

    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(true, a); }";

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

    let err = try expectError(&result);

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

        else throw testing::TestError::Failed;

}

/// Test `.delete()` on immutable slice produces an error.

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

    let mut a = testResolver();

    let program = "fn f(s: *[i32]) { s.delete(0); }";

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

    let err = try expectError(&result);

    let case super::ErrorKind::ImmutableBinding = err.kind

        else throw testing::TestError::Failed;

}

/// Test `.delete()` with wrong argument count produces an error.

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

    // No arguments.

    {

        let mut a = testResolver();

        let program = "fn f(s: *mut [i32]) { s.delete(); }";

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

        let err = try expectError(&result);

        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind

            else throw testing::TestError::Failed;

        try testing::expect(m.expected == 1);

        try testing::expect(m.actual == 0);

    }

    // Too many arguments.

    {

        let mut a = testResolver();

        let program = "fn f(s: *mut [i32]) { s.delete(0, 1); }";

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

        let err = try expectError(&result);

        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind

            else throw testing::TestError::Failed;

        try testing::expect(m.expected == 1);

        try testing::expect(m.actual == 2);

    }

}

/// Test `.delete()` with correct arguments succeeds.

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

    let mut a = testResolver();

    let program = "fn f(s: *mut [i32]) { s.delete(0); }";

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

    try expectNoErrors(&result);

}

/// Test `.delete()` with wrong argument type produces an error.

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

    let mut a = testResolver();

    let program = "fn f(s: *mut [i32]) { s.delete(true); }";

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

    let err = try expectError(&result);

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

        else throw testing::TestError::Failed;

}

    // Intern built-in slice methods.

    strings::intern(pool, "append");

    strings::intern(pool, "delete");