/// Store complete iteration metadata and return the loop binding type.

fn resolveForInfo 'arena (

    self: &mut Resolver 'arena, node: *ast::Node, forStmt: ast::For, iterableTy: Type

) -> Type throws (ResolveError) {

            return *item;

            return *valType;

            return *arrayInfo.item;

}

/// Analyze a `for` loop, binding iteration variables.

unsafe fn resolveFor 'arena (self: &mut Resolver 'arena, node: *ast::Node, forStmt: ast::For) -> Type

    throws (ResolveError)

{

    let iterableTy = try infer(self, forStmt.iterable);

    let itemTy = try resolveForInfo(self, node, forStmt, iterableTy);

/// Loop bindings and lowering metadata retain the same item type and names.

@test unsafe fn testForLoopMetadata() 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(s: &[u8], start: u64, end: u64) { let xs: [u16; 2] = [1, 2]; for value, idx in xs {} for byte in s {} for _, idx in start..end {} }"

        );

        try expectNoErrors(&result);

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

        for index in [1 as u32, 2, 3] {

            let node = body.statements[index];

            let case ast::NodeValue::For(loopNode) = node.value else throw testing::TestError::Failed;

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

            let bindingType = super::typeFor(&res, loopNode.binding) else throw testing::TestError::Failed;

            match info {

                case super::ForLoopInfo::Collection { elemType, length, bindingName, indexName } => {

                    assert bindingType == *elemType;

                    let name = bindingName else throw testing::TestError::Failed;

                    if index == 1 {

                        assert *elemType == super::Type::U16;

                        let count = length else throw testing::TestError::Failed;

                        assert count == 2;

                        assert mem::eq(name, "value");

                        let name = indexName else throw testing::TestError::Failed;

                        assert mem::eq(name, "idx");

                    } else {

                        assert index == 2;

                        assert *elemType == super::Type::U8;

                        assert length == nil;

                        assert mem::eq(name, "byte");

                        assert indexName == nil;

                    }

                }

                case super::ForLoopInfo::Range { valType, range, bindingName, indexName } => {

                    assert index == 3;

                    assert bindingType == *valType;

                    assert *valType == super::Type::U64;

                    assert bindingName == nil;

                    let name = indexName else throw testing::TestError::Failed;

                    assert mem::eq(name, "idx");

                    let case ast::NodeValue::Range(source) = loopNode.iterable.value else throw testing::TestError::Failed;

                    assert range == source;

                }

            }

            if let binding = loopNode.index {

                let ty = super::typeFor(&res, binding) else throw testing::TestError::Failed;

                assert ty == super::Type::U32;

            }

        }

    }

}

/// Invalid iterables and unsafe slice iteration retain their diagnostics.

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

    for program in [

        "fn f() { for x in true {} }",

        "fn f(end: u32) { for x in ..end {} }",

        "fn f(start: u32, end: u32) { let range = start..end; for x in range {} }",

    ] {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

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

            try expectErrorKind(&result, super::ErrorKind::ExpectedIterable);

        }

    }

    let mut arena = testArena();

    let storage: 'test = &mut arena in {

        let mut res = testResolver(storage);

        let result = try resolveProgramStr(&mut res, "fn f(s: *unsafe [u32]) { for x in s {} }");

        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);

    }

    try expectAnalyzeOk("unsafe fn f(s: *unsafe [u32]) { for x in s {} }");

}

//! returns: 0

/// Iterate arrays, regional slices, and ranges through each loop exit path.

@default fn main() -> u32 {

    let values: [u32; 4] = [2, 4, 6, 8];

    let mut sum: u32 = 0;

    for value, index in values {

        assert value == (index + 1) * 2;

        set sum += value;

    }

    assert sum == 20;

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

        set sum = 0;

        for value, index in view {

            if index == 0 { continue; }

            if index == 3 { break; }

            set sum += value;

        }

        assert sum == 10;

        for _ in &view[2..2] {

            assert false;

        }

        assert sum == 10;

    }

    let start: i32 = -2;

    let end: i32 = 3;

    let mut signed: i32 = 0;

    for value, index in start..end {

        assert value == start + index as i32;

        set signed += value;

    }

    assert signed == 0;

    let high: u64 = 4294967296;

    let mut count: u32 = 0;

    for value, index in high..(high + 3) {

        assert value == high + index as u64;

        set count += 1;

    }

    assert count == 3;

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

    for _ in empty { assert false; }

    for _ in high..high { assert false; }

    assert count == 3;

    return 0;

}