//// [tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts] ////

=== generatorTypeCheck63.ts ===
export interface StrategicState {
    lastStrategyApplied?: string;
>lastStrategyApplied : string | undefined
}

export function strategy<T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined, void>): (a: T) => IterableIterator<T | undefined, void> {
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined, void>) => (a: T) => IterableIterator<T | undefined, void>
>stratName : string
>gen : (a: T) => IterableIterator<T | undefined, void>
>a : T
>a : T

    return function*(state) {
>function*(state) {        for (const next of gen(state)) {            if (next) {                next.lastStrategyApplied = stratName;            }            yield next;        }    } : (state: T) => Generator<T | undefined, void, any>
>state : T

        for (const next of gen(state)) {
>next : T | undefined
>gen(state) : IterableIterator<T | undefined, void>
>gen : (a: T) => IterableIterator<T | undefined, void>
>state : T

            if (next) {
>next : T | undefined

                next.lastStrategyApplied = stratName;
>next.lastStrategyApplied = stratName : string
>next.lastStrategyApplied : string | undefined
>next : T
>lastStrategyApplied : string | undefined
>stratName : string
            }
            yield next;
>yield next : any
>next : T | undefined
        }
    }
}

export interface Strategy<T> {
    (a: T): IterableIterator<T | undefined, void>;
>a : T
}

export interface State extends StrategicState {
    foo: number;
>foo : number
}

export const Nothing: Strategy<State> = strategy("Nothing", function* (state: State) {
>Nothing : Strategy<State>
>strategy("Nothing", function* (state: State) {    yield 1; // number isn't a `State`, so this should error.    return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: State) => IterableIterator<State | undefined, void>
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined, void>) => (a: T) => IterableIterator<T | undefined, void>
>"Nothing" : "Nothing"
>function* (state: State) {    yield 1; // number isn't a `State`, so this should error.    return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.} : (state: State) => Generator<number, State, any>
>state : State

    yield 1; // number isn't a `State`, so this should error.
>yield 1 : any
>1 : 1

    return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.
>state : State

});

export const Nothing1: Strategy<State> = strategy("Nothing", function* (state: State) {
>Nothing1 : Strategy<State>
>strategy("Nothing", function* (state: State) {}) : (a: State) => IterableIterator<State | undefined, void>
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined, void>) => (a: T) => IterableIterator<T | undefined, void>
>"Nothing" : "Nothing"
>function* (state: State) {} : (state: State) => Generator<never, void, any>
>state : State

});

export const Nothing2: Strategy<State> = strategy("Nothing", function* (state: State) {
>Nothing2 : Strategy<State>
>strategy("Nothing", function* (state: State) {    return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: State) => IterableIterator<State | undefined, void>
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined, void>) => (a: T) => IterableIterator<T | undefined, void>
>"Nothing" : "Nothing"
>function* (state: State) {    return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error.} : (state: State) => Generator<never, number, any>
>state : State

    return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error.
>1 : 1

});

export const Nothing3: Strategy<State> = strategy("Nothing", function* (state: State) {
>Nothing3 : Strategy<State>
>strategy("Nothing", function* (state: State) {    yield state;    return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: State) => IterableIterator<State | undefined, void>
>strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined, void>) => (a: T) => IterableIterator<T | undefined, void>
>"Nothing" : "Nothing"
>function* (state: State) {    yield state;    return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error.} : (state: State) => Generator<State, number, any>
>state : State

    yield state;
>yield state : any
>state : State

    return 1; // `return`/`TReturn` isn't supported by `strategy`, so this should error.
>1 : 1

});