TypeScript/tests/baselines/reference/types.asyncGenerators.es2018.1.types

=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts ===
async function * inferReturnType1() {
>inferReturnType1 : () => AsyncGenerator<never, void, unknown>
}
async function * inferReturnType2() {
>inferReturnType2 : () => AsyncGenerator<any, void, unknown>

    yield;
>yield : any
}
async function * inferReturnType3() {
>inferReturnType3 : () => AsyncGenerator<number, void, unknown>

    yield 1;
>yield 1 : any
>1 : 1
}
async function * inferReturnType4() {
>inferReturnType4 : () => AsyncGenerator<number, void, unknown>

    yield Promise.resolve(1);
>yield Promise.resolve(1) : any
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1
}
async function * inferReturnType5() {
>inferReturnType5 : () => AsyncGenerator<number, void, unknown>

    yield 1;
>yield 1 : any
>1 : 1

    yield Promise.resolve(2);
>yield Promise.resolve(2) : any
>Promise.resolve(2) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>2 : 2
}
async function * inferReturnType6() {
>inferReturnType6 : () => AsyncGenerator<number, void, undefined>

    yield* [1, 2];
>yield* [1, 2] : any
>[1, 2] : number[]
>1 : 1
>2 : 2
}
async function * inferReturnType7() {
>inferReturnType7 : () => AsyncGenerator<number, void, undefined>

    yield* [Promise.resolve(1)];
>yield* [Promise.resolve(1)] : any
>[Promise.resolve(1)] : Promise<number>[]
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1
}
async function * inferReturnType8() {
>inferReturnType8 : () => AsyncGenerator<number, void, unknown>

    yield* (async function * () { yield 1; })();
>yield* (async function * () { yield 1; })() : void
>(async function * () { yield 1; })() : AsyncGenerator<number, void, unknown>
>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, unknown>
>async function * () { yield 1; } : () => AsyncGenerator<number, void, unknown>
>yield 1 : any
>1 : 1
}
const assignability1: () => AsyncIterableIterator<number> = async function * () {
>assignability1 : () => AsyncIterableIterator<number>
>async function * () {    yield 1;} : () => AsyncGenerator<number, void, undefined>

    yield 1;
>yield 1 : undefined
>1 : 1

};
const assignability2: () => AsyncIterableIterator<number> = async function * () {
>assignability2 : () => AsyncIterableIterator<number>
>async function * () {    yield Promise.resolve(1);} : () => AsyncGenerator<number, void, undefined>

    yield Promise.resolve(1);
>yield Promise.resolve(1) : undefined
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1

};
const assignability3: () => AsyncIterableIterator<number> = async function * () {
>assignability3 : () => AsyncIterableIterator<number>
>async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, undefined>

    yield* [1, 2];
>yield* [1, 2] : any
>[1, 2] : number[]
>1 : 1
>2 : 2

};
const assignability4: () => AsyncIterableIterator<number> = async function * () {
>assignability4 : () => AsyncIterableIterator<number>
>async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, undefined>

    yield* [Promise.resolve(1)];
>yield* [Promise.resolve(1)] : any
>[Promise.resolve(1)] : Promise<number>[]
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1

};
const assignability5: () => AsyncIterableIterator<number> = async function * () {
>assignability5 : () => AsyncIterableIterator<number>
>async function * () {    yield* (async function * () { yield 1; })();} : () => AsyncGenerator<number, void, undefined>

    yield* (async function * () { yield 1; })();
>yield* (async function * () { yield 1; })() : void
>(async function * () { yield 1; })() : AsyncGenerator<number, void, undefined>
>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, undefined>
>async function * () { yield 1; } : () => AsyncGenerator<number, void, undefined>
>yield 1 : undefined
>1 : 1

};
const assignability6: () => AsyncIterable<number> = async function * () {
>assignability6 : () => AsyncIterable<number>
>async function * () {    yield 1;} : () => AsyncGenerator<number, void, undefined>

    yield 1;
>yield 1 : undefined
>1 : 1

};
const assignability7: () => AsyncIterable<number> = async function * () {
>assignability7 : () => AsyncIterable<number>
>async function * () {    yield Promise.resolve(1);} : () => AsyncGenerator<number, void, undefined>

    yield Promise.resolve(1);
>yield Promise.resolve(1) : undefined
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1

};
const assignability8: () => AsyncIterable<number> = async function * () {
>assignability8 : () => AsyncIterable<number>
>async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, undefined>

    yield* [1, 2];
>yield* [1, 2] : any
>[1, 2] : number[]
>1 : 1
>2 : 2

};
const assignability9: () => AsyncIterable<number> = async function * () {
>assignability9 : () => AsyncIterable<number>
>async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, undefined>

    yield* [Promise.resolve(1)];
>yield* [Promise.resolve(1)] : any
>[Promise.resolve(1)] : Promise<number>[]
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1

};
const assignability10: () => AsyncIterable<number> = async function * () {
>assignability10 : () => AsyncIterable<number>
>async function * () {    yield* (async function * () { yield 1; })();} : () => AsyncGenerator<number, void, undefined>

    yield* (async function * () { yield 1; })();
>yield* (async function * () { yield 1; })() : void
>(async function * () { yield 1; })() : AsyncGenerator<number, void, undefined>
>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, undefined>
>async function * () { yield 1; } : () => AsyncGenerator<number, void, undefined>
>yield 1 : undefined
>1 : 1

};
const assignability11: () => AsyncIterator<number> = async function * () {
>assignability11 : () => AsyncIterator<number>
>async function * () {    yield 1;} : () => AsyncGenerator<number, void, undefined>

    yield 1;
>yield 1 : undefined
>1 : 1

};
const assignability12: () => AsyncIterator<number> = async function * () {
>assignability12 : () => AsyncIterator<number>
>async function * () {    yield Promise.resolve(1);} : () => AsyncGenerator<number, void, undefined>

    yield Promise.resolve(1);
>yield Promise.resolve(1) : undefined
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1

};
const assignability13: () => AsyncIterator<number> = async function * () {
>assignability13 : () => AsyncIterator<number>
>async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, undefined>

    yield* [1, 2];
>yield* [1, 2] : any
>[1, 2] : number[]
>1 : 1
>2 : 2

};
const assignability14: () => AsyncIterator<number> = async function * () {
>assignability14 : () => AsyncIterator<number>
>async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, undefined>

    yield* [Promise.resolve(1)];
>yield* [Promise.resolve(1)] : any
>[Promise.resolve(1)] : Promise<number>[]
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1

};
const assignability15: () => AsyncIterator<number> = async function * () {
>assignability15 : () => AsyncIterator<number>
>async function * () {    yield* (async function * () { yield 1; })();} : () => AsyncGenerator<number, void, undefined>

    yield* (async function * () { yield 1; })();
>yield* (async function * () { yield 1; })() : void
>(async function * () { yield 1; })() : AsyncGenerator<number, void, undefined>
>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, undefined>
>async function * () { yield 1; } : () => AsyncGenerator<number, void, undefined>
>yield 1 : undefined
>1 : 1

};
async function * explicitReturnType1(): AsyncIterableIterator<number> {
>explicitReturnType1 : () => AsyncIterableIterator<number>

    yield 1;
>yield 1 : undefined
>1 : 1
}
async function * explicitReturnType2(): AsyncIterableIterator<number> {
>explicitReturnType2 : () => AsyncIterableIterator<number>

    yield Promise.resolve(1);
>yield Promise.resolve(1) : undefined
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1
}
async function * explicitReturnType3(): AsyncIterableIterator<number> {
>explicitReturnType3 : () => AsyncIterableIterator<number>

    yield* [1, 2];
>yield* [1, 2] : any
>[1, 2] : number[]
>1 : 1
>2 : 2
}
async function * explicitReturnType4(): AsyncIterableIterator<number> {
>explicitReturnType4 : () => AsyncIterableIterator<number>

    yield* [Promise.resolve(1)];
>yield* [Promise.resolve(1)] : any
>[Promise.resolve(1)] : Promise<number>[]
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1
}
async function * explicitReturnType5(): AsyncIterableIterator<number> {
>explicitReturnType5 : () => AsyncIterableIterator<number>

    yield* (async function * () { yield 1; })();
>yield* (async function * () { yield 1; })() : void
>(async function * () { yield 1; })() : AsyncGenerator<number, void, undefined>
>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, undefined>
>async function * () { yield 1; } : () => AsyncGenerator<number, void, undefined>
>yield 1 : undefined
>1 : 1
}
async function * explicitReturnType6(): AsyncIterable<number> {
>explicitReturnType6 : () => AsyncIterable<number>

    yield 1;
>yield 1 : undefined
>1 : 1
}
async function * explicitReturnType7(): AsyncIterable<number> {
>explicitReturnType7 : () => AsyncIterable<number>

    yield Promise.resolve(1);
>yield Promise.resolve(1) : undefined
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1
}
async function * explicitReturnType8(): AsyncIterable<number> {
>explicitReturnType8 : () => AsyncIterable<number>

    yield* [1, 2];
>yield* [1, 2] : any
>[1, 2] : number[]
>1 : 1
>2 : 2
}
async function * explicitReturnType9(): AsyncIterable<number> {
>explicitReturnType9 : () => AsyncIterable<number>

    yield* [Promise.resolve(1)];
>yield* [Promise.resolve(1)] : any
>[Promise.resolve(1)] : Promise<number>[]
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1
}
async function * explicitReturnType10(): AsyncIterable<number> {
>explicitReturnType10 : () => AsyncIterable<number>

    yield* (async function * () { yield 1; })();
>yield* (async function * () { yield 1; })() : void
>(async function * () { yield 1; })() : AsyncGenerator<number, void, undefined>
>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, undefined>
>async function * () { yield 1; } : () => AsyncGenerator<number, void, undefined>
>yield 1 : undefined
>1 : 1
}
async function * explicitReturnType11(): AsyncIterator<number> {
>explicitReturnType11 : () => AsyncIterator<number>

    yield 1;
>yield 1 : undefined
>1 : 1
}
async function * explicitReturnType12(): AsyncIterator<number> {
>explicitReturnType12 : () => AsyncIterator<number>

    yield Promise.resolve(1);
>yield Promise.resolve(1) : undefined
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1
}
async function * explicitReturnType13(): AsyncIterator<number> {
>explicitReturnType13 : () => AsyncIterator<number>

    yield* [1, 2];
>yield* [1, 2] : any
>[1, 2] : number[]
>1 : 1
>2 : 2
}
async function * explicitReturnType14(): AsyncIterator<number> {
>explicitReturnType14 : () => AsyncIterator<number>

    yield* [Promise.resolve(1)];
>yield* [Promise.resolve(1)] : any
>[Promise.resolve(1)] : Promise<number>[]
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1
}
async function * explicitReturnType15(): AsyncIterator<number> {
>explicitReturnType15 : () => AsyncIterator<number>

    yield* (async function * () { yield 1; })();
>yield* (async function * () { yield 1; })() : void
>(async function * () { yield 1; })() : AsyncGenerator<number, void, undefined>
>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, undefined>
>async function * () { yield 1; } : () => AsyncGenerator<number, void, undefined>
>yield 1 : undefined
>1 : 1
}
async function * explicitReturnType16(): {} {
>explicitReturnType16 : () => {}

    yield 1;
>yield 1 : any
>1 : 1
}
async function * awaitedType1() {
>awaitedType1 : () => AsyncGenerator<never, void, unknown>

    const x = await 1;
>x : 1
>await 1 : 1
>1 : 1
}
async function * awaitedType2() {
>awaitedType2 : () => AsyncGenerator<never, void, unknown>

    const x = await Promise.resolve(1);
>x : number
>await Promise.resolve(1) : number
>Promise.resolve(1) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
>1 : 1
}
async function * nextType1(): { next(...args: [] | [number | PromiseLike<number>]): any } {
>nextType1 : () => { next(...args: [] | [number | PromiseLike<number>]): any; }
>next : (...args: [] | [number | PromiseLike<number>]) => any
>args : [] | [number | PromiseLike<number>]

    const x = yield; // `number | PromiseLike<number>` (should not await TNext)
>x : number | PromiseLike<number>
>yield : number | PromiseLike<number>
}