Improve type checking and inference for Generators and Async Generators

src/compiler/builderState.ts

@@ -427,8 +427,8 @@ namespace ts.BuilderState {
                 const references = state.referencedMap.get(path);
                 if (references) {
                     const iterator = references.keys();
-                    for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {
-                        queue.push(value as Path);
+                    for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
+                        queue.push(iterResult.value as Path);
                     }
                 }
             }

src/compiler/commandLineParser.ts

@@ -40,6 +40,7 @@ namespace ts {
         ["es2017.string", "lib.es2017.string.d.ts"],
         ["es2017.intl", "lib.es2017.intl.d.ts"],
         ["es2017.typedarrays", "lib.es2017.typedarrays.d.ts"],
+        ["es2018.asyncgenerator", "lib.es2018.asyncgenerator.d.ts"],
         ["es2018.asynciterable", "lib.es2018.asynciterable.d.ts"],
         ["es2018.intl", "lib.es2018.intl.d.ts"],
         ["es2018.promise", "lib.es2018.promise.d.ts"],
@@ -1882,7 +1883,9 @@ namespace ts {
                 case "object":
                     return {};
                 default:
-                    return option.type.keys().next().value;
+                    const iterResult = option.type.keys().next();
+                    if (!iterResult.done) return iterResult.value;
+                    return Debug.fail("Expected 'option.type' to have entries.");
             }
         }
 

src/compiler/core.ts

@@ -24,7 +24,6 @@ namespace ts {
         " __sortedArrayBrand": any;
     }
 
-
     /** ES6 Map interface, only read methods included. */
     export interface ReadonlyMap<T> {
         get(key: string): T | undefined;
@@ -45,7 +44,7 @@ namespace ts {
 
     /** ES6 Iterator type. */
     export interface Iterator<T> {
-        next(): { value: T, done: false } | { value: never, done: true };
+        next(): { value: T, done: false } | { done: true };
     }
 
     /** Array that is only intended to be pushed to, never read. */
@@ -297,12 +296,13 @@ namespace ts {
             forEach(action: (value: T, key: string) => void): void {
                 const iterator = this.entries();
                 while (true) {
-                    const { value: entry, done } = iterator.next();
-                    if (done) {
+                    const iterResult = iterator.next();
+                    if (iterResult.done) {
                         break;
                     }
 
-                    action(entry[1], entry[0]);
+                    const [key, value] = iterResult.value;
+                    action(value, key);
                 }
             }
         };
@@ -346,11 +346,11 @@ namespace ts {
 
     export function firstDefinedIterator<T, U>(iter: Iterator<T>, callback: (element: T) => U | undefined): U | undefined {
         while (true) {
-            const { value, done } = iter.next();
-            if (done) {
+            const iterResult = iter.next();
+            if (iterResult.done) {
                 return undefined;
             }
-            const result = callback(value);
+            const result = callback(iterResult.value);
             if (result !== undefined) {
                 return result;
             }
@@ -1402,8 +1402,8 @@ namespace ts {
     export function arrayFrom<T>(iterator: Iterator<T> | IterableIterator<T>): T[];
     export function arrayFrom(iterator: Iterator<any> | IterableIterator<any>, map?: (t: any) => any): any[] {
         const result: any[] = [];
-        for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {
-            result.push(map ? map(value) : value);
+        for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
+            result.push(map ? map(iterResult.value) : iterResult.value);
         }
         return result;
     }

src/compiler/diagnosticMessages.json

@@ -3915,6 +3915,10 @@
         "category": "Message",
         "code": 6217
     },
+    "Enable strict checking of generator types.": {
+        "category": "Message",
+        "code": 6218
+    },
 
     "Projects to reference": {
         "category": "Message",
@@ -4272,6 +4276,10 @@
         "category": "Error",
         "code": 7051
     },
+    "Generator implicitly has type '{0}' because it does not yield or return any values. Consider supplying a return type.": {
+        "category": "Error",
+        "code": 7052
+    },
 
     "You cannot rename this element.": {
         "category": "Error",

src/compiler/sourcemap.ts

@@ -148,7 +148,8 @@ namespace ts {
             const sourceIndexToNewSourceIndexMap: number[] = [];
             let nameIndexToNewNameIndexMap: number[] | undefined;
             const mappingIterator = decodeMappings(map.mappings);
-            for (let { value: raw, done } = mappingIterator.next(); !done; { value: raw, done } = mappingIterator.next()) {
+            for (let iterResult = mappingIterator.next(); !iterResult.done; iterResult = mappingIterator.next()) {
+                const raw = iterResult.value;
                 if (end && (
                     raw.generatedLine > end.line ||
                     (raw.generatedLine === end.line && raw.generatedCharacter > end.character))) {

src/compiler/types.ts

@@ -4234,13 +4234,21 @@ namespace ts {
         regularType: ResolvedType;  // Regular version of fresh type
     }
 
+    /* @internal */
+    export interface IterationTypes {
+        yieldType?: Type;
+        returnType?: Type;
+        nextType?: Type;
+    }
+
     // Just a place to cache element types of iterables and iterators
     /* @internal */
     export interface IterableOrIteratorType extends ObjectType, UnionType {
-        iteratedTypeOfIterable?: Type;
-        iteratedTypeOfIterator?: Type;
-        iteratedTypeOfAsyncIterable?: Type;
-        iteratedTypeOfAsyncIterator?: Type;
+        iterationTypesOfIterable?: IterationTypes;
+        iterationTypesOfIterator?: IterationTypes;
+        iterationTypesOfAsyncIterable?: IterationTypes;
+        iterationTypesOfAsyncIterator?: IterationTypes;
+        iterationTypesOfIteratorResult?: IterationTypes;
     }
 
     /* @internal */

src/compiler/utilities.ts

@@ -150,8 +150,8 @@ namespace ts {
     export function forEachEntry<T, U>(map: ReadonlyMap<T>, callback: (value: T, key: string) => U | undefined): U | undefined;
     export function forEachEntry<T, U>(map: ReadonlyUnderscoreEscapedMap<T> | ReadonlyMap<T>, callback: (value: T, key: (string & __String)) => U | undefined): U | undefined {
         const iterator = map.entries();
-        for (let { value: pair, done } = iterator.next(); !done; { value: pair, done } = iterator.next()) {
-            const [key, value] = pair;
+        for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
+            const [key, value] = iterResult.value;
             const result = callback(value, key as (string & __String));
             if (result) {
                 return result;
@@ -165,8 +165,8 @@ namespace ts {
     export function forEachKey<T>(map: ReadonlyMap<{}>, callback: (key: string) => T | undefined): T | undefined;
     export function forEachKey<T>(map: ReadonlyUnderscoreEscapedMap<{}> | ReadonlyMap<{}>, callback: (key: string & __String) => T | undefined): T | undefined {
         const iterator = map.keys();
-        for (let { value: key, done } = iterator.next(); !done; { value: key, done } = iterator.next()) {
-            const result = callback(key as string & __String);
+        for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
+            const result = callback(iterResult.value as string & __String);
             if (result) {
                 return result;
             }

src/harness/vfs.ts

@@ -683,7 +683,7 @@ namespace vfs {
 
             if (isDirectory(node)) throw createIOError("EISDIR");
             if (!isFile(node)) throw createIOError("EBADF");
-            node.buffer = Buffer.isBuffer(data) ? data.slice() : ts.sys.bufferFrom!("" + data, encoding || "utf8");
+            node.buffer = Buffer.isBuffer(data) ? data.slice() : ts.sys.bufferFrom!("" + data, encoding || "utf8") as Buffer;
             node.size = node.buffer.byteLength;
             node.mtimeMs = time;
             node.ctimeMs = time;
@@ -1204,7 +1204,7 @@ namespace vfs {
                 }
             },
             readFileSync(path: string): Buffer {
-                return ts.sys.bufferFrom!(host.readFile(path)!, "utf8"); // TODO: GH#18217
+                return ts.sys.bufferFrom!(host.readFile(path)!, "utf8") as Buffer; // TODO: GH#18217
             }
         };
     }

src/lib/es2015.generator.d.ts

@@ -1,4 +1,11 @@
-interface Generator extends Iterator<any> { }
+/// <reference lib="es2015.iterable" />
+
+interface Generator<T = unknown, TReturn = T | void, TNext = unknown> extends IterableIterator<T, TReturn, TNext> {
+    next(value?: TNext): IteratorResult<T, TReturn>;
+    return(value: TReturn): IteratorResult<T, TReturn>;
+    throw(e: unknown): IteratorResult<T, TReturn>;
+    [Symbol.iterator](): Generator<T, TReturn, TNext>;
+}
 
 interface GeneratorFunction {
     /**

src/lib/es2015.iterable.d.ts

@@ -8,23 +8,30 @@ interface SymbolConstructor {
     readonly iterator: symbol;
 }
 
-interface IteratorResult<T> {
-    done: boolean;
-    value: T;
+interface IteratorYieldResult<TYield> {
+    done: false;
+    value: TYield;
 }
 
-interface Iterator<T> {
-    next(value?: any): IteratorResult<T>;
-    return?(value?: any): IteratorResult<T>;
-    throw?(e?: any): IteratorResult<T>;
+interface IteratorReturnResult<TReturn> {
+    done: true;
+    value: TReturn;
+}
+
+type IteratorResult<T, TReturn = T | void> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
+
+interface Iterator<T, TReturn = T | void, TNext = unknown> {
+    next(value?: TNext): IteratorResult<T, TReturn>;
+    return?(value?: TReturn): IteratorResult<T, TReturn>;
+    throw?(e?: unknown): IteratorResult<T, TReturn>;
 }
 
 interface Iterable<T> {
     [Symbol.iterator](): Iterator<T>;
 }
 
-interface IterableIterator<T> extends Iterator<T> {
-    [Symbol.iterator](): IterableIterator<T>;
+interface IterableIterator<T, TReturn = T | void, TNext = unknown> extends Iterator<T, TReturn, TNext> {
+    [Symbol.iterator](): IterableIterator<T, TReturn, TNext>;
 }
 
 interface Array<T> {

src/lib/es2018.asyncgenerator.d.ts

@@ -0,0 +1,58 @@
+/// <reference lib="es2018.asynciterable" />
+
+interface AsyncGenerator<T = unknown, TReturn = T | void, TNext = unknown> extends AsyncIterableIterator<T, TReturn, TNext> {
+    next(value?: TNext): Promise<IteratorResult<T, TReturn>>;
+    return(value: TReturn): Promise<IteratorResult<T, TReturn>>;
+    throw(e: unknown): Promise<IteratorResult<T, TReturn>>;
+    [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
+}
+
+interface AsyncGeneratorFunction {
+    /**
+     * Creates a new AsyncGenerator object.
+     * @param args A list of arguments the function accepts.
+     */
+    new (...args: any[]): AsyncGenerator;
+    /**
+     * Creates a new AsyncGenerator object.
+     * @param args A list of arguments the function accepts.
+     */
+    (...args: any[]): AsyncGenerator;
+    /**
+     * The length of the arguments.
+     */
+    readonly length: number;
+    /**
+     * Returns the name of the function.
+     */
+    readonly name: string;
+    /**
+     * A reference to the prototype.
+     */
+    readonly prototype: AsyncGenerator;
+}
+
+interface AsyncGeneratorFunctionConstructor {
+    /**
+     * Creates a new AsyncGenerator function.
+     * @param args A list of arguments the function accepts.
+     */
+    new (...args: string[]): AsyncGeneratorFunction;
+    /**
+     * Creates a new AsyncGenerator function.
+     * @param args A list of arguments the function accepts.
+     */
+    (...args: string[]): AsyncGeneratorFunction;
+    /**
+     * The length of the arguments.
+     */
+    readonly length: number;
+    /**
+     * Returns the name of the function.
+     */
+    readonly name: string;
+    /**
+     * A reference to the prototype.
+     */
+    readonly prototype: AsyncGeneratorFunction;
+}

src/lib/es2018.asynciterable.d.ts

@@ -9,16 +9,16 @@ interface SymbolConstructor {
     readonly asyncIterator: symbol;
 }
 
-interface AsyncIterator<T> {
-    next(value?: any): Promise<IteratorResult<T>>;
-    return?(value?: any): Promise<IteratorResult<T>>;
-    throw?(e?: any): Promise<IteratorResult<T>>;
+interface AsyncIterator<T, TReturn = T | void, TNext = unknown> {
+    next(value?: TNext): Promise<IteratorResult<T, TReturn>>;
+    return?(value?: TReturn): Promise<IteratorResult<T, TReturn>>;
+    throw?(e?: unknown): Promise<IteratorResult<T, TReturn>>;
 }
 
 interface AsyncIterable<T> {
     [Symbol.asyncIterator](): AsyncIterator<T>;
 }
 
-interface AsyncIterableIterator<T> extends AsyncIterator<T> {
-    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+interface AsyncIterableIterator<T, TReturn = T | void, TNext = unknown> extends AsyncIterator<T, TReturn, TNext> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T, TReturn, TNext>;
 }

src/lib/es2018.d.ts

@@ -1,4 +1,5 @@
 /// <reference lib="es2017" />
+/// <reference lib="es2018.asyncgenerator" />
 /// <reference lib="es2018.asynciterable" />
 /// <reference lib="es2018.promise" />
 /// <reference lib="es2018.regexp" />

src/lib/libs.json

@@ -31,6 +31,7 @@
         "es2017.string",
         "es2017.intl",
         "es2017.typedarrays",
+        "es2018.asyncgenerator",
         "es2018.asynciterable",
         "es2018.regexp",
         "es2018.promise",

src/server/editorServices.ts

@@ -2813,8 +2813,9 @@ namespace ts.server {
             let assignOrphanScriptInfosToInferredProject = false;
             if (openFiles) {
                 while (true) {
-                    const { value: file, done } = openFiles.next();
-                    if (done) break;
+                    const iterResult = openFiles.next();
+                    if (iterResult.done) break;
+                    const file = iterResult.value;
                     const scriptInfo = this.getScriptInfo(file.fileName);
                     Debug.assert(!scriptInfo || !scriptInfo.isScriptOpen(), "Script should not exist and not be open already");
                     // Create script infos so we have the new content for all the open files before we do any updates to projects
@@ -2831,8 +2832,9 @@ namespace ts.server {
 
             if (changedFiles) {
                 while (true) {
-                    const { value: file, done } = changedFiles.next();
-                    if (done) break;
+                    const iterResult = changedFiles.next();
+                    if (iterResult.done) break;
+                    const file = iterResult.value;
                     const scriptInfo = this.getScriptInfo(file.fileName)!;
                     Debug.assert(!!scriptInfo);
                     // Make edits to script infos and marks containing project as dirty
@@ -2868,8 +2870,9 @@ namespace ts.server {
         /* @internal */
         applyChangesToFile(scriptInfo: ScriptInfo, changes: Iterator<TextChange>) {
             while (true) {
-                const { value: change, done } = changes.next();
-                if (done) break;
+                const iterResult = changes.next();
+                if (iterResult.done) break;
+                const change = iterResult.value;
                 scriptInfo.editContent(change.span.start, change.span.start + change.span.length, change.newText);
             }
         }

src/testRunner/parallel/host.ts

@@ -269,8 +269,8 @@ namespace Harness.Parallel.Host {
                     worker.accumulatedOutput += d.toString();
                     console.log(`[Worker ${i}]`, d.toString());
                 };
-                worker.process.stderr.on("data", appendOutput);
-                worker.process.stdout.on("data", appendOutput);
+                worker.process.stderr!.on("data", appendOutput);
+                worker.process.stdout!.on("data", appendOutput);
                 const killChild = (timeout: TaskTimeout) => {
                     worker.process.kill();
                     console.error(`Worker exceeded ${timeout.duration}ms timeout ${worker.currentTasks && worker.currentTasks.length ? `while running test '${worker.currentTasks[0].file}'.` : `during test setup.`}`);