await-promise: check for-await-of

src/rules/awaitPromiseRule.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { isAwaitExpression, isUnionOrIntersectionType } from "tsutils";
+import { isAwaitExpression, isForOfStatement, isTypeReference, isUnionOrIntersectionType } from "tsutils";
 import * as ts from "typescript";
 import * as Lint from "../index";
 
@@ -42,6 +42,7 @@ export class Rule extends Lint.Rules.TypedRule {
     /* tslint:enable:object-literal-sort-keys */
 
     public static FAILURE_STRING = "'await' of non-Promise.";
+    public static FAILURE_FOR_AWAIT_OF = "'for-await-of' of non-AsyncIterable.";
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
         const promiseTypes = new Set(["Promise", ...this.ruleArguments as string[]]);
@@ -54,27 +55,33 @@ function walk(ctx: Lint.WalkContext<Set<string>>, tc: ts.TypeChecker) {
     return ts.forEachChild(ctx.sourceFile, cb);
 
     function cb(node: ts.Node): void {
-        if (isAwaitExpression(node) && !couldBePromise(tc.getTypeAtLocation(node.expression))) {
+        if (isAwaitExpression(node) && !containsType(tc.getTypeAtLocation(node.expression), isPromiseType)) {
             ctx.addFailureAtNode(node, Rule.FAILURE_STRING);
+        } else if (isForOfStatement(node) && node.awaitModifier !== undefined &&
+                   !containsType(tc.getTypeAtLocation(node.expression), isAsyncIterable)) {
+            ctx.addFailureAtNode(node.expression, Rule.FAILURE_FOR_AWAIT_OF);
         }
         return ts.forEachChild(node, cb);
     }
 
-    function couldBePromise(type: ts.Type): boolean {
-        if (Lint.isTypeFlagSet(type, ts.TypeFlags.Any) || isPromiseType(type)) {
-            return true;
-        }
-
-        if (isUnionOrIntersectionType(type)) {
-            return type.types.some(couldBePromise);
-        }
-
-        const bases = type.getBaseTypes();
-        return bases !== undefined && bases.some(couldBePromise);
+    function isPromiseType(name: string) {
+        return promiseTypes.has(name);
     }
+}
 
-    function isPromiseType(type: ts.Type): boolean {
-        const { target } = type as ts.TypeReference;
-        return target !== undefined && target.symbol !== undefined && promiseTypes.has(target.symbol.name);
+function containsType(type: ts.Type, predicate: (name: string) => boolean): boolean {
+    if (Lint.isTypeFlagSet(type, ts.TypeFlags.Any) ||
+        isTypeReference(type) && type.target.symbol !== undefined && predicate(type.target.symbol.name)) {
+        return true;
     }
+    if (isUnionOrIntersectionType(type)) {
+        return type.types.some((t) => containsType(t, predicate));
+    }
+
+    const bases = type.getBaseTypes();
+    return bases !== undefined && bases.some((t) => containsType(t, predicate));
+}
+
+function isAsyncIterable(name: string) {
+    return name === "AsyncIterable" || name === "AsyncIterableIterator";
 }

src/test.ts

@@ -119,14 +119,14 @@ export function runTest(testDirectory: string, rulesDirectory?: string | string[
                 getDefaultLibFileName: () => ts.getDefaultLibFileName(compilerOptions),
                 getDirectories: (dir) => fs.readdirSync(dir),
                 getNewLine: () => "\n",
-                getSourceFile(filenameToGet) {
-                    const target = compilerOptions.target === undefined ? ts.ScriptTarget.ES5 : compilerOptions.target;
-                    if (filenameToGet === ts.getDefaultLibFileName(compilerOptions)) {
-                        const fileContent = fs.readFileSync(ts.getDefaultLibFilePath(compilerOptions), "utf8");
-                        return ts.createSourceFile(filenameToGet, fileContent, target);
-                    } else if (denormalizeWinPath(filenameToGet) === fileCompileName) {
+                getSourceFile(filenameToGet, target) {
+                    if (denormalizeWinPath(filenameToGet) === fileCompileName) {
                         return ts.createSourceFile(filenameToGet, fileTextWithoutMarkup, target, true);
                     }
+                    if (path.basename(filenameToGet) === filenameToGet) {
+                        // resolve path of lib.xxx.d.ts
+                        filenameToGet = path.join(path.dirname(ts.getDefaultLibFilePath(compilerOptions)), filenameToGet);
+                    }
                     const text = fs.readFileSync(filenameToGet, "utf8");
                     return ts.createSourceFile(filenameToGet, text, target, true);
                 },

src/verify/lintError.ts

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-import { Error } from "../error";
-
 export interface PositionInFile {
    line: number;
    col: number;

test/rules/await-promise/for-await-of/test.ts.lint

@@ -0,0 +1,51 @@
+[typescript]: >= 2.3.0
+async function correct(foo: AsyncIterableIterator<string>) {
+    for await (const element of foo) {}
+}
+
+async function correct2() {
+    for await (const element of asyncGenerator()) {}
+}
+
+async function correct(foo: AsyncIterable<string>) {
+    for await (const element of foo) {}
+}
+
+async function correct3(foo: AsyncIterableIterator<string> | AsyncIterableIterator<number>) {
+    for await (const element of foo) {}
+}
+
+async function incorrect(foo: <Array<Promise<string>>) {
+    for await (const element of foo) {}
+                                ~~~ [0]
+}
+
+async function incorrect2(foo: IterableIterator<Promise<string>>) {
+    for await (const element of foo) {}
+                                ~~~ [0]
+}
+
+async function incorrect3() {
+    for await (const element of asyncGenerator) {}
+                                ~~~~~~~~~~~~~~ [0]
+}
+
+async function incorrect4() {
+    for await (const element of generator()) {}
+                                ~~~~~~~~~~~ [0]
+}
+
+async function incorrect5(foo: Iterable<string>) {
+    for await (const element of foo) {}
+                                ~~~ [0]
+}
+
+async function* asyncGenerator() {
+    yield 1;
+}
+
+function* generator() {
+    yield 1;
+}
+
+[0]: 'for-await-of' of non-AsyncIterable.

test/rules/await-promise/for-await-of/tsconfig.json

@@ -0,0 +1,5 @@
+{
+    "compilerOptions": {
+        "target": "esnext"
+    }
+}

test/rules/await-promise/for-await-of/tslint.json

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "await-promise": true
+  }
+}