// `base[start..end]` range-slicing: builds a []T value {ptr+start,
// end-start}. Bases can be many-item pointers, slices, or arrays.
// Also covers `==`/`!=` on slices (length check + memcmp).

const { assert } = import("test");

extern fn strlen(s: *const[] u8) u64;

// Full span of a literal's bytes via its pointer.
tfn sliceFull() {
    var lit: []u8 = "hello";
    var s: []u8 = lit.ptr[0..5];
    assert(s.len as u32, 5);
    assert(s[0], 104);  // 'h'
    assert(s[4], 111);  // 'o'
}

// Sub-range with non-zero start.
tfn sliceSubrange() {
    var lit: []u8 = "hello";
    var s: []u8 = lit.ptr[1..4];   // "ell"
    assert(s.len as u32, 3);
    assert(s[0], 101);  // 'e'
    assert(s[2], 108);  // 'l'
}

// End bound from a runtime expression (strlen).
tfn sliceRuntimeEnd() {
    var lit: []u8 = "world!";
    var n: u64 = strlen(lit.ptr);
    var s: []u8 = lit.ptr[0..n];
    assert(s.len as u32, 6);
    assert(s[5], 33);   // '!'
}

// Empty slice (start == end).
tfn sliceEmpty() {
    var lit: []u8 = "abc";
    var s: []u8 = lit.ptr[2..2];
    assert(s.len as u32, 0);
}

// Slicing through a pointer binding (not just an inline member access).
tfn sliceViaPointerVar() {
    var lit: []u8 = "abcdef";
    var p: *const[] u8 = lit.ptr;
    var s: []u8 = p[2..5];   // "cde"
    assert(s.len as u32, 3);
    assert(s[0], 99);   // 'c'
}

// Slice base: reslicing a slice directly, no .ptr hop.
tfn sliceOfSlice() {
    const s: str = "hello world";
    const hello: []u8 = s[0..5];
    const world: []u8 = s[6..11];
    assert(hello.len as u32, 5);
    assert(world.len as u32, 5);
    assert(hello[0], 104);  // 'h'
    assert(world[0], 119);  // 'w'
}

// Array base: slicing decays the array to its elements in place.
tfn sliceOfArray() {
    var arr: [6]u16 = [1, 2, 3, 4, 5, 6];
    const mid: []u16 = arr[2..5];
    assert(mid.len as u32, 3);
    assert(mid[0] as u32, 3);
    assert(mid[2] as u32, 5);
}

// `==` compares length first, then bytes.
tfn sliceEquality() {
    const s: str = "hello world";
    const hello: []u8 = s[0..5];
    assert((hello == "hello") as u8, 1);
    assert((hello == "world") as u8, 0);
    assert((hello != "world") as u8, 1);
    assert((hello == "hell") as u8, 0);   // length mismatch
}

// Empty slices are equal to each other and nothing else.
tfn sliceEqualityEmpty() {
    const s: str = "abc";
    const e1: []u8 = s[1..1];
    const e2: []u8 = s[2..2];
    assert((e1 == e2) as u8, 1);
    assert((e1 == s) as u8, 0);
}

// Wider element types compare by element size, not count.
tfn sliceEqualityWide() {
    var a: [3]u32 = [7, 8, 9];
    var b: [4]u32 = [0, 7, 8, 9];
    assert((a[0..3] == b[1..4]) as u8, 1);
    assert((a[0..3] == b[0..3]) as u8, 0);
}