capturedLetConstInLoop2.types

=== tests/cases/compiler/capturedLetConstInLoop2.ts ===


// ========let
function foo0(x) {
>foo0 : (x: any) => void
>x : any

    for (let x of []) {
>x : any
>[] : undefined[]

        let a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + a });
>(function() { return x + a }) : () => any
>function() { return x + a } : () => any
>x + a : any
>x : any
>a : number

        (() => x + a);
>(() => x + a) : () => any
>() => x + a : () => any
>x + a : any
>x : any
>a : number
    }
}

function foo0_1(x) {
>foo0_1 : (x: any) => void
>x : any

    for (let x in []) {
>x : string
>[] : undefined[]

        let a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + a });
>(function() { return x + a }) : () => string
>function() { return x + a } : () => string
>x + a : string
>x : string
>a : number

        (() => x + a);
>(() => x + a) : () => string
>() => x + a : () => string
>x + a : string
>x : string
>a : number
    }
}

function foo1(x) {
>foo1 : (x: any) => void
>x : any

    for (let x = 0; x < 1; ++x) {
>x : number
>0 : number
>x < 1 : boolean
>x : number
>1 : number
>++x : number
>x : number

        let a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + a });
>(function() { return x + a }) : () => number
>function() { return x + a } : () => number
>x + a : number
>x : number
>a : number

        (() => x + a);
>(() => x + a) : () => number
>() => x + a : () => number
>x + a : number
>x : number
>a : number
    }
}

function foo2(x) {
>foo2 : (x: any) => void
>x : any

    while (1 === 1) {
>1 === 1 : boolean
>1 : number
>1 : number

        let a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + a });
>(function() { return x + a }) : () => any
>function() { return x + a } : () => any
>x + a : any
>x : any
>a : number

        (() => x + a);
>(() => x + a) : () => any
>() => x + a : () => any
>x + a : any
>x : any
>a : number
    }
}

function foo3(x) {
>foo3 : (x: any) => void
>x : any

    do {
        let x;
>x : any

        let a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + a });
>(function() { return x + a }) : () => any
>function() { return x + a } : () => any
>x + a : any
>x : any
>a : number

        (() => x + a);
>(() => x + a) : () => any
>() => x + a : () => any
>x + a : any
>x : any
>a : number

    } while (1 === 1)
>1 === 1 : boolean
>1 : number
>1 : number
}

function foo4(x) {
>foo4 : (x: any) => void
>x : any

    for (let y = 0; y < 1; ++y) {
>y : number
>0 : number
>y < 1 : boolean
>y : number
>1 : number
>++y : number
>y : number

        let a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        let x = 1;
>x : number
>1 : number

        (function() { return x + a });
>(function() { return x + a }) : () => number
>function() { return x + a } : () => number
>x + a : number
>x : number
>a : number

        (() => x + a);
>(() => x + a) : () => number
>() => x + a : () => number
>x + a : number
>x : number
>a : number
    }
}

function foo5(x) {
>foo5 : (x: any) => void
>x : any

    for (let x = 0, y = 1; x < 1; ++x) {
>x : number
>0 : number
>y : number
>1 : number
>x < 1 : boolean
>x : number
>1 : number
>++x : number
>x : number

        let a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + y + a });
>(function() { return x + y + a }) : () => number
>function() { return x + y + a } : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number

        (() => x + y + a);
>(() => x + y + a) : () => number
>() => x + y + a : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number
    }
}


function foo6(x) {
>foo6 : (x: any) => void
>x : any

    while (1 === 1) {
>1 === 1 : boolean
>1 : number
>1 : number

        let x, y;
>x : any
>y : any

        let a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + y + a });
>(function() { return x + y + a }) : () => any
>function() { return x + y + a } : () => any
>x + y + a : any
>x + y : any
>x : any
>y : any
>a : number

        (() => x + y + a);
>(() => x + y + a) : () => any
>() => x + y + a : () => any
>x + y + a : any
>x + y : any
>x : any
>y : any
>a : number
    }
}

function foo7(x) {
>foo7 : (x: any) => void
>x : any

    do {
        let x, y;
>x : any
>y : any

        let a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + y + a });
>(function() { return x + y + a }) : () => any
>function() { return x + y + a } : () => any
>x + y + a : any
>x + y : any
>x : any
>y : any
>a : number

        (() => x + y + a);
>(() => x + y + a) : () => any
>() => x + y + a : () => any
>x + y + a : any
>x + y : any
>x : any
>y : any
>a : number

    } while (1 === 1)
>1 === 1 : boolean
>1 : number
>1 : number
}


function foo8(x) {
>foo8 : (x: any) => void
>x : any

    for (let y = 0; y < 1; ++y) {
>y : number
>0 : number
>y < 1 : boolean
>y : number
>1 : number
>++y : number
>y : number

        let x = 1;
>x : number
>1 : number

        let a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + y + a });
>(function() { return x + y + a }) : () => number
>function() { return x + y + a } : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number

        (() => x + y + a);
>(() => x + y + a) : () => number
>() => x + y + a : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number
    }
}
///=======const
function foo0_c(x) {
>foo0_c : (x: any) => void
>x : any

    for (const x of []) {
>x : any
>[] : undefined[]

        const a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + a });
>(function() { return x + a }) : () => any
>function() { return x + a } : () => any
>x + a : any
>x : any
>a : number

        (() => x + a);
>(() => x + a) : () => any
>() => x + a : () => any
>x + a : any
>x : any
>a : number
    }
}

function foo0_1_c(x) {
>foo0_1_c : (x: any) => void
>x : any

    for (const x in []) {
>x : string
>[] : undefined[]

        const a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + a });
>(function() { return x + a }) : () => string
>function() { return x + a } : () => string
>x + a : string
>x : string
>a : number

        (() => x + a);
>(() => x + a) : () => string
>() => x + a : () => string
>x + a : string
>x : string
>a : number
    }
}

function foo1_c(x) {
>foo1_c : (x: any) => void
>x : any

    for (const x = 0; x < 1;) {
>x : number
>0 : number
>x < 1 : boolean
>x : number
>1 : number

        const a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + a });
>(function() { return x + a }) : () => number
>function() { return x + a } : () => number
>x + a : number
>x : number
>a : number

        (() => x + a);
>(() => x + a) : () => number
>() => x + a : () => number
>x + a : number
>x : number
>a : number
    }
}

function foo2_c(x) {
>foo2_c : (x: any) => void
>x : any

    while (1 === 1) {
>1 === 1 : boolean
>1 : number
>1 : number

        const a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + a });
>(function() { return x + a }) : () => any
>function() { return x + a } : () => any
>x + a : any
>x : any
>a : number

        (() => x + a);
>(() => x + a) : () => any
>() => x + a : () => any
>x + a : any
>x : any
>a : number
    }
}

function foo3_c(x) {
>foo3_c : (x: any) => void
>x : any

    do {
        const x = 1;
>x : number
>1 : number

        const a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + a });
>(function() { return x + a }) : () => number
>function() { return x + a } : () => number
>x + a : number
>x : number
>a : number

        (() => x + a);
>(() => x + a) : () => number
>() => x + a : () => number
>x + a : number
>x : number
>a : number

    } while (1 === 1)
>1 === 1 : boolean
>1 : number
>1 : number
}

function foo4_c(x) {
>foo4_c : (x: any) => void
>x : any

    for (const y = 0; y < 1;) {
>y : number
>0 : number
>y < 1 : boolean
>y : number
>1 : number

        const a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        const x = 1;
>x : number
>1 : number

        (function() { return x + a });
>(function() { return x + a }) : () => number
>function() { return x + a } : () => number
>x + a : number
>x : number
>a : number

        (() => x + a);
>(() => x + a) : () => number
>() => x + a : () => number
>x + a : number
>x : number
>a : number
    }
}

function foo5_c(x) {
>foo5_c : (x: any) => void
>x : any

    for (const x = 0, y = 1; x < 1;) {
>x : number
>0 : number
>y : number
>1 : number
>x < 1 : boolean
>x : number
>1 : number

        const a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + y + a });
>(function() { return x + y + a }) : () => number
>function() { return x + y + a } : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number

        (() => x + y + a);
>(() => x + y + a) : () => number
>() => x + y + a : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number
    }
}


function foo6_c(x) {
>foo6_c : (x: any) => void
>x : any

    while (1 === 1) {
>1 === 1 : boolean
>1 : number
>1 : number

        const x = 1, y =1 ;
>x : number
>1 : number
>y : number
>1 : number

        const a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + y + a });
>(function() { return x + y + a }) : () => number
>function() { return x + y + a } : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number

        (() => x + y + a);
>(() => x + y + a) : () => number
>() => x + y + a : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number
    }
}

function foo7_c(x) {
>foo7_c : (x: any) => void
>x : any

    do {
        const x = 1, y = 1;
>x : number
>1 : number
>y : number
>1 : number

        const a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + y + a });
>(function() { return x + y + a }) : () => number
>function() { return x + y + a } : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number

        (() => x + y + a);
>(() => x + y + a) : () => number
>() => x + y + a : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number

    } while (1 === 1)
>1 === 1 : boolean
>1 : number
>1 : number
}


function foo8_c(x) {
>foo8_c : (x: any) => void
>x : any

    for (const y = 0; y < 1;) {
>y : number
>0 : number
>y < 1 : boolean
>y : number
>1 : number

        const x = 1;
>x : number
>1 : number

        const a = arguments.length;
>a : number
>arguments.length : number
>arguments : IArguments
>length : number

        (function() { return x + y + a });
>(function() { return x + y + a }) : () => number
>function() { return x + y + a } : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number

        (() => x + y + a);
>(() => x + y + a) : () => number
>() => x + y + a : () => number
>x + y + a : number
>x + y : number
>x : number
>y : number
>a : number
    }
}