Preserve method comments in JS->ES6 conversion. Fixes #16622

Author: RyanCavanaugh

src/services/refactors/convertFunctionToEs6Class.ts

@@ -164,12 +164,15 @@ namespace ts.refactor {
                 }
 
                 switch (assignmentBinaryExpression.right.kind) {
-                    case SyntaxKind.FunctionExpression:
+                    case SyntaxKind.FunctionExpression: {
                         const functionExpression = assignmentBinaryExpression.right as FunctionExpression;
-                        return createMethod(/*decorators*/ undefined, modifiers, /*asteriskToken*/ undefined, memberDeclaration.name, /*questionToken*/ undefined,
+                        const method = createMethod(/*decorators*/ undefined, modifiers, /*asteriskToken*/ undefined, memberDeclaration.name, /*questionToken*/ undefined,
                             /*typeParameters*/ undefined, functionExpression.parameters, /*type*/ undefined, functionExpression.body);
+                        copyComments(assignmentBinaryExpression, method);
+                        return method;
+                    }
 
-                    case SyntaxKind.ArrowFunction:
+                    case SyntaxKind.ArrowFunction: {
                         const arrowFunction = assignmentBinaryExpression.right as ArrowFunction;
                         const arrowFunctionBody = arrowFunction.body;
                         let bodyBlock: Block;
@@ -183,20 +186,40 @@ namespace ts.refactor {
                             const expression = arrowFunctionBody as Expression;
                             bodyBlock = createBlock([createReturn(expression)]);
                         }
-                        return createMethod(/*decorators*/ undefined, modifiers, /*asteriskToken*/ undefined, memberDeclaration.name, /*questionToken*/ undefined,
+                        const method = createMethod(/*decorators*/ undefined, modifiers, /*asteriskToken*/ undefined, memberDeclaration.name, /*questionToken*/ undefined,
                             /*typeParameters*/ undefined, arrowFunction.parameters, /*type*/ undefined, bodyBlock);
+                        copyComments(assignmentBinaryExpression, method);
+                        return method;
+                    }
 
-                    default:
+                    default: {
                         // Don't try to declare members in JavaScript files
                         if (isSourceFileJavaScript(sourceFile)) {
                             return;
                         }
                         return createProperty(/*decorators*/ undefined, modifiers, memberDeclaration.name, /*questionToken*/ undefined,
                             /*type*/ undefined, assignmentBinaryExpression.right);
+                    }
                 }
             }
         }
 
+        function copyComments(sourceNode: Node, targetNode: Node) {
+            forEachLeadingCommentRange(sourceFile.text, sourceNode.pos, (pos, end, kind, htnl) => {
+                if (kind === SyntaxKind.MultiLineCommentTrivia) {
+                    // Remove leading /*
+                    pos += 2;
+                    // Remove trailing */
+                    end -= 2;
+                }
+                else {
+                    // Remove leading //
+                    pos += 2;
+                }
+                addSyntheticLeadingComment(targetNode, kind, sourceFile.text.slice(pos, end), htnl);
+            });
+        }
+
         function createClassFromVariableDeclaration(node: VariableDeclaration): ClassDeclaration {
             const initializer = node.initializer as FunctionExpression;
             if (!initializer || initializer.kind !== SyntaxKind.FunctionExpression) {
@@ -212,17 +235,22 @@ namespace ts.refactor {
                 memberElements.unshift(createConstructor(/*decorators*/ undefined, /*modifiers*/ undefined, initializer.parameters, initializer.body));
             }
 
-            return createClassDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, node.name,
+            const cls = createClassDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, node.name,
                 /*typeParameters*/ undefined, /*heritageClauses*/ undefined, memberElements);
+            // Don't call copyComments here because we'll already leave them in place
+            return cls;
         }
 
         function createClassFromFunctionDeclaration(node: FunctionDeclaration): ClassDeclaration {
             const memberElements = createClassElementsFromSymbol(ctorSymbol);
             if (node.body) {
                 memberElements.unshift(createConstructor(/*decorators*/ undefined, /*modifiers*/ undefined, node.parameters, node.body));
             }
-            return createClassDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, node.name,
+
+            const cls = createClassDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, node.name,
                 /*typeParameters*/ undefined, /*heritageClauses*/ undefined, memberElements);
+            // Don't call copyComments here because we'll already leave them in place
+            return cls;
         }
     }
 }

tests/cases/fourslash/convertFunctionToEs6ClassJsDoc.ts

@@ -0,0 +1,29 @@
+/// <reference path='fourslash.ts' />
+
+// @allowNonTsExtensions: true
+// @Filename: test123.js
+//// function fn() {
+////     this.x = 100;
+//// }
+//// 
+//// /**
+////   * This is a cool function!
+//// */
+//// /*1*/fn.prototype.bar = function (x, y, z) {
+////     this.x = y;
+//// };
+
+verify.fileAfterApplyingRefactorAtMarker('1',
+`class fn {
+    constructor() {
+        this.x = 100;
+    }
+    /**
+      * This is a cool function!
+    */
+    bar(x, y, z) {
+        this.x = y;
+    }
+}
+
+`, 'Convert to ES2015 class', 'convert');