add fixAwaitInSyncFunction code fix

Author: srolel

Diff for: src/compiler/diagnosticMessages.json

@@ -3843,6 +3843,10 @@
         "category": "Message",
         "code": 90028
     },
+    "Convert to async": {
+        "category": "Message",
+        "code": 90028
+    },
     "Convert function to an ES2015 class": {
         "category": "Message",
         "code": 95001

Diff for: src/services/codefixes/fixAwaitInSyncFunction.ts

@@ -0,0 +1,52 @@
+/* @internal */
+namespace ts.codefix {
+    const fixId = "fixAwaitInSyncFunction";
+    const errorCodes = [
+        Diagnostics.await_expression_is_only_allowed_within_an_async_function.code,
+        Diagnostics.A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator.code,
+    ];
+    registerCodeFix({
+        errorCodes,
+        getCodeActions(context) {
+            const { sourceFile, span } = context;
+            const node = getNode(sourceFile, span.start);
+            if (!node) return undefined;
+            const changes = textChanges.ChangeTracker.with(context, t => doChange(t, sourceFile, node));
+            return [{ description: getLocaleSpecificMessage(Diagnostics.Convert_to_async), changes, fixId }];
+        },
+        fixIds: [fixId],
+        getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) =>
+            doChange(changes, context.sourceFile, getNode(diag.file, diag.start!))),
+    });
+
+    function getNode(sourceFile: SourceFile, pos: number): FunctionLikeDeclaration {
+        const token = getTokenAtPosition(sourceFile, pos, /*includeJsDocComment*/ false);
+        const containingFunction = getContainingFunction(token);
+        if (!isFunctionLikeDeclaration(containingFunction) ||
+            isConstructorDeclaration(containingFunction) ||
+            isGetAccessorDeclaration(containingFunction) ||
+            isSetAccessorDeclaration(containingFunction)) return;
+        return containingFunction;
+    }
+
+    function doChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, decl: FunctionLikeDeclaration) {
+        const asyncToken = createToken(SyntaxKind.AsyncKeyword);
+        const modifiers = decl.modifiers ? decl.modifiers.concat(asyncToken) : createNodeArray([asyncToken]);
+        let changed;
+        switch (decl.kind) {
+            case SyntaxKind.MethodDeclaration:
+                changed = createMethod(decl.decorators, modifiers, decl.asteriskToken, decl.name, decl.questionToken, decl.typeParameters, decl.parameters, decl.type, decl.body);
+                break;
+            case SyntaxKind.FunctionExpression:
+                changed = createFunctionExpression(modifiers, decl.asteriskToken, decl.name, decl.typeParameters, decl.parameters, decl.type, decl.body);
+                break;
+            case SyntaxKind.FunctionDeclaration:
+                changed = createFunctionDeclaration(decl.decorators, modifiers, decl.asteriskToken, decl.name, decl.typeParameters, decl.parameters, decl.type, decl.body);
+                break;
+            case SyntaxKind.ArrowFunction:
+                changed = createArrowFunction(modifiers, decl.typeParameters, decl.parameters, decl.type, decl.equalsGreaterThanToken, decl.body);
+                break;
+        }
+        changes.replaceNode(sourceFile, decl, changed);
+    }
+}

Diff for: src/services/codefixes/fixes.ts

@@ -11,6 +11,7 @@
 /// <reference path="fixForgottenThisPropertyAccess.ts" />
 /// <reference path='fixUnusedIdentifier.ts' />
 /// <reference path='fixJSDocTypes.ts' />
+/// <reference path='fixAwaitInSyncFunction.ts' />
 /// <reference path='importFixes.ts' />
 /// <reference path='disableJsDiagnostics.ts' />
 /// <reference path='helpers.ts' />

Diff for: tests/cases/fourslash/codeFixAwaitInSyncFunction1.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+////function f() {
+////    await Promise.resolve();
+////}
+
+verify.codeFix({
+    description: "Convert to async",
+    index: 0,
+    newFileContent:
+`async function f() {\r
+    await Promise.resolve();\r
+}`,
+});

Diff for: tests/cases/fourslash/codeFixAwaitInSyncFunction2.ts

@@ -0,0 +1,16 @@
+/// <reference path='fourslash.ts' />
+
+////const f = function() {
+////    await Promise.resolve();
+////    await Promise.resolve();
+////}
+
+verify.codeFix({
+    description: "Convert to async",
+    index: 0,
+    newFileContent:
+`const f = async function() {\r
+    await Promise.resolve();\r
+    await Promise.resolve();\r
+}`,
+});

Diff for: tests/cases/fourslash/codeFixAwaitInSyncFunction3.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+////const f = {
+////    get a() {
+////        return await Promise.resolve();
+////    },
+////    get a() {
+////        await Promise.resolve();
+////    },
+////}
+
+verify.not.codeFixAvailable();

Diff for: tests/cases/fourslash/codeFixAwaitInSyncFunction4.ts

@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+
+////class Foo {
+////    constructor {
+////        await Promise.resolve();
+////    }
+////}
+
+verify.not.codeFixAvailable();

Diff for: tests/cases/fourslash/codeFixAwaitInSyncFunction5.ts

@@ -0,0 +1,17 @@
+/// <reference path='fourslash.ts' />
+
+////class Foo {
+////    bar() {
+////        await Promise.resolve();
+////    }
+////}
+
+verify.codeFix({
+    description: "Convert to async",
+    index: 0,
+    newFileContent:
+`class Foo {
+    async bar() {\r
+        await Promise.resolve();\r
+    }}`,
+});

Diff for: tests/cases/fourslash/codeFixAwaitInSyncFunction6.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+////const f = (promise) => {
+////    await promise;
+////}
+
+verify.codeFix({
+    description: "Convert to async",
+    index: 0,
+    newFileContent:
+`const f = async (promise) => {\r
+    await promise;\r
+}`,
+});

Diff for: tests/cases/fourslash/codeFixAwaitInSyncFunction7.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+////function f() {
+////    for await (const x of g()) {
+////        console.log(x);
+////    }
+////}
+
+verify.codeFix({
+    description: "Convert to async",
+    index: 0,
+    newFileContent:
+`function f() => {\r
+    for await (const x of g()) {\r
+        console.log(x);\r
+    }\r
+}`,
+});

Diff for: tests/cases/fourslash/codeFixAwaitInSyncFunction_all.ts

@@ -0,0 +1,20 @@
+/// <reference path='fourslash.ts' />
+
+////function f() {
+////    await Promise.resolve();
+////}
+////
+////const g = () => {
+////    await f();
+////}
+
+verify.codeFixAll({
+    fixId: "fixAwaitInSyncFunction",
+    newFileContent:
+`async function f() {\r
+    await Promise.resolve();\r
+}
+const g = async () => {\r
+    await f();\r
+}`,
+});