fix(40042): add modifiers in correct position for decorated methods

Author: a-tarasyuk

src/services/codefixes/convertToAsyncFunction.ts

@@ -73,7 +73,13 @@ namespace ts.codefix {
         }
 
         // add the async keyword
-        changes.insertLastModifierBefore(sourceFile, SyntaxKind.AsyncKeyword, functionToConvert);
+        if (functionToConvert.modifiers) {
+            changes.insertModifierAt(sourceFile, functionToConvert.modifiers.end, SyntaxKind.AsyncKeyword, { prefix: " " });
+        }
+        else {
+            const pos = functionToConvert.decorators ? skipTrivia(sourceFile.text, functionToConvert.decorators.end) : functionToConvert.getStart(sourceFile);
+            changes.insertModifierAt(sourceFile, pos, SyntaxKind.AsyncKeyword, { suffix: " " });
+        }
 
         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()
+    [#|m|]() {
+        return fetch('a').then(x => x);
+    }
+}
+`);
+
+        _testConvertToAsyncFunction("convertToAsyncFunction_decoratedMethodWithSingleLineComment", `
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    // comment
+    [#|m|]() {
+        return fetch('a').then(x => x);
+    }
+}
+`);
+
+        _testConvertToAsyncFunction("convertToAsyncFunction_decoratedMethodWithMultipleLineComment", `
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    /**
+     * comment
+     */
+    [#|m|]() {
+        return fetch('a').then(x => x);
+    }
+}
+`);
+
+        _testConvertToAsyncFunction("convertToAsyncFunction_decoratedMethodWithModifier", `
+function decorator() {
+    return (target: any, key: any, descriptor: PropertyDescriptor) => descriptor;
+}
+class Foo {
+    @decorator()
+    public [#|m|]() {
+        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()
+    /*[#|*/m/*|]*/() {
+        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 m() {
+        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 /*[#|*/m/*|]*/() {
+        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 m() {
+        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
+     */
+    /*[#|*/m/*|]*/() {
+        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 m() {
+        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
+    /*[#|*/m/*|]*/() {
+        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 m() {
+        const x = await fetch('a');
+        return x;
+    }
+}