fix(40042): Convert to async function with decorator

src/services/codefixes/convertToAsyncFunction.ts

@@ -67,13 +67,15 @@ namespace ts.codefix {
         const functionToConvertRenamed = renameCollidingVarNames(functionToConvert, checker, synthNamesMap, context.sourceFile);
         const returnStatements = functionToConvertRenamed.body && isBlock(functionToConvertRenamed.body) ? getReturnStatementsWithPromiseHandlers(functionToConvertRenamed.body) : emptyArray;
         const transformer: Transformer = { checker, synthNamesMap, setOfExpressionsToReturn, isInJSFile: isInJavascript };
-
         if (!returnStatements.length) {
             return;
         }
 
-        // add the async keyword
-        changes.insertLastModifierBefore(sourceFile, SyntaxKind.AsyncKeyword, functionToConvert);
+        const pos = functionToConvert.modifiers ? functionToConvert.modifiers.end :
+            functionToConvert.decorators ? skipTrivia(sourceFile.text, functionToConvert.decorators.end) :
+                functionToConvert.getStart(sourceFile);
+        const options = functionToConvert.modifiers ? { prefix: " " } : { suffix: " " };
+        changes.insertModifierAt(sourceFile, pos, SyntaxKind.AsyncKeyword, options);
 
         for (const returnStatement of returnStatements) {
             forEachChild(returnStatement, function visit(node) {

src/services/textChanges.ts

@@ -388,19 +388,12 @@ namespace ts.textChanges {
             this.insertNodeAt(sourceFile, getAdjustedStartPosition(sourceFile, before, options), newNode, this.getOptionsForInsertNodeBefore(before, newNode, blankLineBetween));
         }
 
-        public insertModifierBefore(sourceFile: SourceFile, modifier: SyntaxKind, before: Node): void {
-            const pos = before.getStart(sourceFile);
-            this.insertNodeAt(sourceFile, pos, factory.createToken(modifier), { suffix: " " });
+        public insertModifierAt(sourceFile: SourceFile, pos: number, modifier: SyntaxKind, options: InsertNodeOptions = {}): void {
+            this.insertNodeAt(sourceFile, pos, factory.createToken(modifier), options);
         }
 
-        public insertLastModifierBefore(sourceFile: SourceFile, modifier: SyntaxKind, before: Node): void {
-            if (!before.modifiers) {
-                this.insertModifierBefore(sourceFile, modifier, before);
-                return;
-            }
-
-            const pos = before.modifiers.end;
-            this.insertNodeAt(sourceFile, pos, factory.createToken(modifier), { prefix: " " });
+        public insertModifierBefore(sourceFile: SourceFile, modifier: SyntaxKind, before: Node): void {
+            return this.insertModifierAt(sourceFile, before.getStart(sourceFile), modifier, { suffix: " " });
         }
 
         public insertCommentBeforeLine(sourceFile: SourceFile, lineNumber: number, position: number, commentText: string): void {

src/testRunner/unittests/services/convertToAsyncFunction.ts

@@ -1378,6 +1378,57 @@ function [#|foo|]() {
         return fetch('b').then(() => 'c');
     })
 }
+`);
+        _testConvertToAsyncFunction("convertToAsyncFunction_decoratedMethod", `
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    [#|method|]() {
+        return fetch('a').then(x => x);
+    }
+}
+`);
+
+        _testConvertToAsyncFunction("convertToAsyncFunction_decoratedMethodWithSingleLineComment", `
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    // comment
+    [#|method|]() {
+        return fetch('a').then(x => x);
+    }
+}
+`);
+
+        _testConvertToAsyncFunction("convertToAsyncFunction_decoratedMethodWithMultipleLineComment", `
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    /**
+     * comment
+     */
+    [#|method|]() {
+        return fetch('a').then(x => x);
+    }
+}
+`);
+
+        _testConvertToAsyncFunction("convertToAsyncFunction_decoratedMethodWithModifier", `
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    public [#|method|]() {
+        return fetch('a').then(x => x);
+    }
+}
 `);
 
         _testConvertToAsyncFunctionFailedSuggestion("convertToAsyncFunction_OutermostOnlyFailure", `

tests/baselines/reference/convertToAsyncFunction/convertToAsyncFunction_decoratedMethod.ts

@@ -0,0 +1,24 @@
+// ==ORIGINAL==
+
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    /*[#|*/method/*|]*/() {
+        return fetch('a').then(x => x);
+    }
+}
+
+// ==ASYNC FUNCTION::Convert to async function==
+
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    async method() {
+        const x = await fetch('a');
+        return x;
+    }
+}

tests/baselines/reference/convertToAsyncFunction/convertToAsyncFunction_decoratedMethodWithModifier.ts

@@ -0,0 +1,24 @@
+// ==ORIGINAL==
+
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    public /*[#|*/method/*|]*/() {
+        return fetch('a').then(x => x);
+    }
+}
+
+// ==ASYNC FUNCTION::Convert to async function==
+
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    public async method() {
+        const x = await fetch('a');
+        return x;
+    }
+}

tests/baselines/reference/convertToAsyncFunction/convertToAsyncFunction_decoratedMethodWithMultipleLineComment.ts

@@ -0,0 +1,30 @@
+// ==ORIGINAL==
+
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    /**
+     * comment
+     */
+    /*[#|*/method/*|]*/() {
+        return fetch('a').then(x => x);
+    }
+}
+
+// ==ASYNC FUNCTION::Convert to async function==
+
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    /**
+     * comment
+     */
+    async method() {
+        const x = await fetch('a');
+        return x;
+    }
+}

tests/baselines/reference/convertToAsyncFunction/convertToAsyncFunction_decoratedMethodWithSingleLineComment.ts

@@ -0,0 +1,26 @@
+// ==ORIGINAL==
+
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    // comment
+    /*[#|*/method/*|]*/() {
+        return fetch('a').then(x => x);
+    }
+}
+
+// ==ASYNC FUNCTION::Convert to async function==
+
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    // comment
+    async method() {
+        const x = await fetch('a');
+        return x;
+    }
+}