//! returns: 133

//! Test that slice copy with mismatched lengths traps.

@default fn main() -> i32 {

    let mut dst: [i32; 4] = [0, 0, 0, 0];

    let src: [i32; 2] = [1, 2];

    dst[..] = &src[..];

    return 0;

}

//! returns: 0

@default fn main() -> i32 {

    // Fill entire array.

    let mut a: [i32; 4] = [1, 2, 3, 4];

    a[..] = 0;

    assert a == [0, 0, 0, 0];

    // Fill sub-range of array.

    let mut b: [i32; 4] = [1, 2, 3, 4];

    b[1..3] = 99;

    assert b == [1, 99, 99, 4];

    // Fill mutable slice.

    let mut c: [i32; 4] = [10, 20, 30, 40];

    let cs: *mut [i32] = &mut c[..];

    cs[..] = 7;

    assert c == [7, 7, 7, 7];

    // Fill sub-range of mutable slice.

    let mut d: [i32; 5] = [1, 2, 3, 4, 5];

    let ds: *mut [i32] = &mut d[..];

    ds[1..4] = 0;

    assert d == [1, 0, 0, 0, 5];

    // Copy slice into array.

    let mut e: [i32; 3] = [0, 0, 0];

    let src: [i32; 3] = [10, 20, 30];

    e[..] = &src[..];

    assert e == [10, 20, 30];

    // Copy into sub-range.

    let mut f: [i32; 5] = [1, 2, 3, 4, 5];

    let src2: [i32; 2] = [88, 99];

    f[1..3] = &src2[..];

    assert f == [1, 88, 99, 4, 5];

    // Empty range is a no-op.

    let mut g: [i32; 3] = [1, 2, 3];

    g[1..1] = 99;

    assert g == [1, 2, 3];

    // Copy between sub-ranges.

    let mut i: [i32; 10] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];

    let s: *mut [i32] = &mut i[..];

    s[1..4] = &s[7..10];

    assert i[1] == 80 and i[2] == 90 and i[3] == 100;

    // Fill u8 array.

    let mut h: [u8; 4] = [65, 66, 67, 68];

    h[..] = 0;

    assert h == [0, 0, 0, 0];

    return 0;

}

/// Result of resolving a slice range to a data pointer and element count.

record SliceRangeResult {

    dataReg: il::Reg,

    count: il::Val,

}

            try lowerAssign(self, node, a);

/// Compute data pointer and element count for a range into a container.

/// Used by both slice range expressions (`&a[start..end]`) and slice

/// assignments (`a[start..end] = value`).

fn resolveSliceRangePtr(

    info: resolver::SliceRangeInfo

) -> SliceRangeResult throws (LowerError) {

    // If the start value is known to be zero, the count is just the end

    let mut count = endVal;

    // Only compute range offset and count if the start value is not

        // Compute the count as `end - start`.

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

    return SliceRangeResult { dataReg, count };

}

/// Lower a slice range expression into a slice header value.

fn lowerSliceRange(

    self: *mut FnLowerer,

    container: *ast::Node,

    range: ast::Range,

    sliceNode: *ast::Node

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

    let info = resolver::sliceRangeInfoFor(self.low.resolver, sliceNode) else {

        throw LowerError::MissingMetadata;

    };

    let r = try resolveSliceRangePtr(self, container, range, info);

        self, info.itemType, info.mutable, il::Val::Reg(r.dataReg), r.count, r.count

fn lowerAssign(self: *mut FnLowerer, node: *ast::Node, a: ast::Assign) throws (LowerError) {

    // Slice assignment: `slice[range] = value`.

    if let info = resolver::sliceRangeInfoFor(self.low.resolver, node) {

        let case ast::NodeValue::Subscript { container, index } = a.left.value

            else panic "lowerAssign: slice assign without subscript";

        let case ast::NodeValue::Range(range) = index.value

            else panic "lowerAssign: slice assign without range";

        try lowerSliceAssign(self, a.right, container, range, info);

        return;

    }

/// Lower `slice[range] = value`.

fn lowerSliceAssign(

    self: *mut FnLowerer,

    rhs: *ast::Node,

    container: *ast::Node,

    range: ast::Range,

    info: resolver::SliceRangeInfo

) throws (LowerError) {

    let r = try resolveSliceRangePtr(self, container, range, info);

    let elemSize = resolver::getTypeLayout(*info.itemType).size;

    let rhsTy = resolver::typeFor(self.low.resolver, rhs) else {

        throw LowerError::MissingType(rhs);

    };

    if let case resolver::Type::Slice { .. } = rhsTy {

        // Copy from source slice.

        let srcReg = emitValToReg(self, try lowerExpr(self, rhs));

        let srcData = loadSlicePtr(self, srcReg);

        let srcLen = loadSliceLen(self, srcReg);

        // Trap if source and destination lengths differ.

        try emitTrapUnlessCmp(self, il::CmpOp::Eq, il::Type::W32, r.count, srcLen);

        let bytes = emitTypedBinOp(

            self, il::BinOp::Mul, il::Type::W32, r.count, il::Val::Imm(elemSize as i64)

        );

        try emitByteCopyLoop(self, r.dataReg, srcData, bytes, "copy");

    } else {

        // Fill with scalar value.

        let fillVal = try lowerExpr(self, rhs);

        try emitFillLoop(self, r.dataReg, fillVal, r.count, *info.itemType, elemSize);

    }

}

/// Emit a typed fill loop: `for i in 0..count { dst[i * stride] = value; }`.

fn emitFillLoop(

    self: *mut FnLowerer,

    dst: il::Reg,

    value: il::Val,

    count: il::Val,

    elemType: resolver::Type,

    elemSize: u32

) throws (LowerError) {

    let iReg = nextReg(self);

    let header = try createBlockWithParam(

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

    );

    let body = try createBlock(self, "fill");

    let done = try createBlock(self, "fill");

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

    switchToBlock(self, header);

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

    try switchToAndSeal(self, body);

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

    try emitStore(self, dstElem, 0, elemType, value);

    let nextI = emitTypedBinOp(

        self, il::BinOp::Add, il::Type::W32, il::Val::Reg(iReg), il::Val::Imm(1)

    );

    try emitJmpWithArg(self, header, nextI);

    try sealBlock(self, header);

    try switchToAndSeal(self, done);

}

    // Slice assignment: `slice[range] = value`.

    if let case ast::NodeValue::Subscript { container, index } = assign.left.value {

        if let case ast::NodeValue::Range(range) = index.value {

            try infer(self, index);

            let containerTy = try infer(self, container);

            if not try canBorrowMutFrom(self, container) {

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

            }

            let subjectTy = autoDeref(containerTy);

            try checkSliceRangeIndices(self, range);

            let mut item: *Type = undefined;

            let mut capacity: ?u32 = nil;

            match subjectTy {

                case Type::Array(a) => {

                    try validateArraySliceBounds(self, range, a.length, node);

                    item = a.item;

                    capacity = a.length;

                }

                case Type::Slice { item: i, mutable } => {

                    if not mutable { throw emitError(self, container, ErrorKind::ImmutableBinding); }

                    item = i;

                }

                else => throw emitError(self, container, ErrorKind::ExpectedIndexable),

            }

            // RHS is either a fill value or a source slice.

            let rhsTy = try infer(self, assign.right);

            if let case Type::Slice { item: srcItem, .. } = rhsTy {

                if *srcItem != *item {

                    throw emitTypeMismatch(self, assign.right, TypeMismatch { expected: *item, actual: *srcItem });

                }

            } else {

                try checkAssignable(self, assign.right, *item);

            }

            setSliceRangeInfo(self, node, SliceRangeInfo { itemType: item, mutable: true, capacity });

            setNodeType(self, assign.left, *item);

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

        }

    }