/// Get the range metadata for a slice borrow or range assignment.

            let info = sliceRangeInfo(subjectTy)

                else throw emitError(self, container, ErrorKind::ExpectedIndexable);

            if not info.mutable {

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

            if let capacity = info.capacity {

                try validateArraySliceBounds(self, range, capacity, node);

            }

            let item = info.itemType;

            setSliceRangeInfo(self, node, info);

/// Construct complete range metadata for an array or slice type.

/// Callers check array place access and select the resulting borrow access.

fn sliceRangeInfo(ty: Type) -> ?SliceRangeInfo {

    match ty {

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

            return SliceRangeInfo { itemType: item, mutable, capacity: nil },

        case Type::Array(array) =>

            return SliceRangeInfo { itemType: array.item, mutable: true, capacity: array.length },

        else => return nil,

    }

}

            let mut info = sliceRangeInfo(subjectTy)

                else throw emitError(self, container, ErrorKind::ExpectedIndexable);

            if ast::isExclusiveAddress(addr) and not info.mutable {

                throw emitError(self, addr.target, ErrorKind::ImmutableBinding);

            if let capacity = info.capacity {

                try validateArraySliceBounds(self, range, capacity, node);

            }

            set info.mutable = addr.kind == ast::AddressKind::Mutable;

            let sliceTy = Type::Slice { class, item: info.itemType, mutable: info.mutable };

            setSliceRangeInfo(self, node, info);

/// Slice operations retain initialized element, capacity, and access metadata.

@test unsafe fn testSliceRangeMetadata() throws (testing::TestError) {

    let mut arena = testArena();

    let storage: 'test = &mut arena in {

        let mut res = testResolver(storage);

        let result = try resolveProgramStr(&mut res,

            "fn f() { let mut xs: [u32; 4] = [1, 2, 3, 4]; set xs[1..3] = 7; let view = &mut xs[1..3]; set view[..] = 3; let shared = &view[..]; }"

        );

        try expectNoErrors(&result);

        let body = try getFnBody(&res, result.root, "f");

        for index in [1 as u32, 3] {

            let stmt = body.statements[index];

            let case ast::NodeValue::Assign(_) = stmt.value else throw testing::TestError::Failed;

            let info = super::sliceRangeInfoFor(&res, stmt) else throw testing::TestError::Failed;

            assert *info.itemType == super::Type::U32;

            assert info.mutable;

            let capacity: ?u32 = 4 if index == 1 else nil;

            assert info.capacity == capacity;

        }

        for index in [2 as u32, 4] {

            let stmt = body.statements[index];

            let case ast::NodeValue::Let(binding) = stmt.value else throw testing::TestError::Failed;

            let case ast::NodeValue::AddressOf(_) = binding.value.value else throw testing::TestError::Failed;

            let info = super::sliceRangeInfoFor(&res, binding.value) else throw testing::TestError::Failed;

            assert *info.itemType == super::Type::U32;

            assert info.mutable == (index == 2);

            let capacity: ?u32 = 4 if index == 2 else nil;

            assert info.capacity == capacity;

        }

    }

}

/// Slice assignment and borrowing enforce static bounds and source access.

@test unsafe fn testSliceRangeErrors() throws (testing::TestError) {

    for program in [

        "fn f() { let mut xs: [u32; 2] = [1, 2]; set xs[..3] = 0; }",

        "fn f() { let mut xs: [u32; 2] = [1, 2]; set xs[2..1] = 0; }",

        "fn f() { let mut xs: [u32; 2] = [1, 2]; let view = &mut xs[..3]; }",

    ] {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

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

            let err = try expectError(&result);

            assert err.kind == super::ErrorKind::SliceRangeOutOfBounds, program;

        }

    }

    for program in [

        "fn f() { let mut value: u32 = 1; set value[..] = 0; }",

        "fn f() { let mut value: u32 = 1; let view = &value[..]; }",

    ] {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

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

            let err = try expectError(&result);

            assert err.kind == super::ErrorKind::ExpectedIndexable, program;

        }

    }

    for program in [

        "fn f() { let xs: [u32; 2] = [1, 2]; let view = &xs[..]; set view[..] = 0; }",

        "fn f() { let xs: [u32; 2] = [1, 2]; let view = &xs[..]; let other = &mut view[..]; }",

    ] {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

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

            let err = try expectError(&result);

            assert err.kind == super::ErrorKind::ImmutableBinding, program;

        }

    }

}

//! returns: 0

/// Slice access retains element types and respects nested borrow regions.

@default fn main() -> u32 {

    let mut values: [u32; 4] = [1, 2, 3, 4];

    set values[1..3] = 7;

    let view: 'outer = &mut values[..] in {

        set view[1..3] = 9;

        let inner: 'inner = &mut view[1..3] in {

            set inner[..] = 5;

            set inner[1..1] = 99;

            assert inner.len == 2;

        }

        let shared: 'read = &view[..] in {

            assert shared[0] == 1;

            assert shared[1] == 5;

            assert shared[2] == 5;

            assert shared[3] == 4;

        }

    }

    assert values == [1, 5, 5, 4];

    let empty: [u32; 0] = [];

    let view: 'empty = &empty[..] in {

        assert view.len == 0;

    }

    return 0;

}