Emit detached comments for function body

sheetalkamat · sheetalkamat · commit ebd00bd1bcf9 · 2014-08-19T12:06:52.000-07:00
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -203,7 +203,7 @@ module ts {
             });
         }
 
-        function emitNewLineBeforeLeadingComments(node: Node, leadingComments: Comment[], writer: EmitTextWriter) {
+        function emitNewLineBeforeLeadingComments(node: TextRange, leadingComments: Comment[], writer: EmitTextWriter) {
             // If the leading comments start on different line than the start of node, write new line
             if (leadingComments && leadingComments.length && node.pos !== leadingComments[0].pos &&
                 currentSourceFile.getLineAndCharacterFromPosition(node.pos).line !== currentSourceFile.getLineAndCharacterFromPosition(leadingComments[0].pos).line) {
@@ -325,9 +325,9 @@ module ts {
             /** Emit Trailing comments of the node */
             var emitTrailingComments = compilerOptions.removeComments ? (node: Node) => { } : emitTrailingDeclarationComments;
 
-            var detachedCommentsEndPos: number;
+            var detachedCommentsInfo: { nodePos: number; detachedCommentEndPos: number }[];
             /** Emit detached comments of the node */
-            var emitDetachedComments = compilerOptions.removeComments ? (node: Node) => { } : emitDetachedCommentsAtPosition;
+            var emitDetachedComments = compilerOptions.removeComments ? (node: TextRange) => { } : emitDetachedCommentsAtPosition;
 
             var writeComment = writeCommentRange;
 
@@ -1354,6 +1354,8 @@ module ts {
                 scopeEmitStart(node);
                 increaseIndent();
 
+                emitDetachedComments(node.body.kind === SyntaxKind.FunctionBlock ? (<Block>node.body).statements : node.body);
+
                 var startIndex = 0;
                 if (node.body.kind === SyntaxKind.FunctionBlock) {
                     startIndex = emitDirectivePrologues((<Block>node.body).statements, /*startWithNewLine*/ true);
@@ -1380,9 +1382,11 @@ module ts {
                     }
                     else {
                         writeLine();
+                        emitLeadingComments(node.body);
                         write("return ");
                         emit(node.body);
                         write(";");
+                        emitTrailingComments(node.body);
                     }
                     decreaseIndent();
                     writeLine();
@@ -2070,14 +2074,19 @@ module ts {
                 // Emit the leading comments only if the parent's pos doesnt match because parent should take care of emitting these comments
                 if (node.parent.kind === SyntaxKind.SourceFile || node.pos !== node.parent.pos) {
                     var leadingComments: Comment[];
-                    if (detachedCommentsEndPos === undefined) {
+                    if (detachedCommentsInfo === undefined || detachedCommentsInfo[detachedCommentsInfo.length - 1].nodePos !== node.pos) {
                         // get the leading comments from the node
                         leadingComments = getLeadingCommentsOfNode(node, currentSourceFile);
                     }
                     else {
                         // get the leading comments from detachedPos
-                        leadingComments = getLeadingComments(currentSourceFile.text, detachedCommentsEndPos);
-                        detachedCommentsEndPos = undefined;
+                        leadingComments = getLeadingComments(currentSourceFile.text, detachedCommentsInfo[detachedCommentsInfo.length - 1].detachedCommentEndPos);
+                        if (detachedCommentsInfo.length - 1) {
+                            detachedCommentsInfo.pop();
+                        }
+                        else {
+                            detachedCommentsInfo = undefined;
+                        }
                     }
                     emitNewLineBeforeLeadingComments(node, leadingComments, writer);
                     // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
@@ -2094,7 +2103,7 @@ module ts {
                 }
             }
 
-            function emitDetachedCommentsAtPosition(node: Node) {
+            function emitDetachedCommentsAtPosition(node: TextRange) {
                 var leadingComments = getLeadingComments(currentSourceFile.text, node.pos);
                 if (leadingComments) {
                     var detachedComments: Comment[] = [];
@@ -2125,8 +2134,15 @@ module ts {
                         var astLine = currentSourceFile.getLineAndCharacterFromPosition(skipTrivia(currentSourceFile.text, node.pos)).line;
                         if (astLine >= lastCommentLine + 2) {
                             // Valid detachedComments
+                            emitNewLineBeforeLeadingComments(node, leadingComments, writer);
                             emitComments(detachedComments, /*trailingSeparator*/ true, writer, writeComment);
-                            detachedCommentsEndPos = detachedComments[detachedComments.length - 1].end;
+                            var currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: detachedComments[detachedComments.length - 1].end };
+                            if (detachedCommentsInfo) {
+                                detachedCommentsInfo.push(currentDetachedCommentInfo);
+                            }
+                            else {
+                                detachedCommentsInfo = [currentDetachedCommentInfo];
+                            }
                         }
                     }
                 }
diff --git a/tests/baselines/reference/detachedCommentAtStartOfFunctionBody2.js b/tests/baselines/reference/detachedCommentAtStartOfFunctionBody2.js
@@ -14,10 +14,10 @@ var TestFile = (function () {
     function TestFile() {
     }
     TestFile.prototype.foo = function (message) {
-        var _this = this;
         /// <summary>Test summary</summary>
         /// <param name="message" type="String" />
         /// <returns type="Function" />
+        var _this = this;
         return function () { return message + _this.name; };
     };
     return TestFile;
diff --git a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.js b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.js
@@ -0,0 +1,31 @@
+//// [detachedCommentAtStartOfLambdaFunction1.ts]
+class TestFile {
+    name: string;
+    foo(message: string): () => string {
+        return (...x: string[]) =>
+            /// <summary>Test summary</summary>
+            /// <param name="message" type="String" />
+            /// <returns type="Function" />
+            message + this.name;
+    }
+}
+
+//// [detachedCommentAtStartOfLambdaFunction1.js]
+var TestFile = (function () {
+    function TestFile() {
+    }
+    TestFile.prototype.foo = function (message) {
+        var _this = this;
+        return function () {
+            var x = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                x[_i - 0] = arguments[_i];
+            }
+            /// <summary>Test summary</summary>
+            /// <param name="message" type="String" />
+            /// <returns type="Function" />
+            return message + _this.name;
+        };
+    };
+    return TestFile;
+})();
diff --git a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.js b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.js
@@ -0,0 +1,32 @@
+//// [detachedCommentAtStartOfLambdaFunction2.ts]
+class TestFile {
+    name: string;
+    foo(message: string): () => string {
+        return (...x: string[]) =>
+            /// <summary>Test summary</summary>
+            /// <param name="message" type="String" />
+            /// <returns type="Function" />
+
+            message + this.name;
+    }
+}
+
+//// [detachedCommentAtStartOfLambdaFunction2.js]
+var TestFile = (function () {
+    function TestFile() {
+    }
+    TestFile.prototype.foo = function (message) {
+        var _this = this;
+        return function () {
+            /// <summary>Test summary</summary>
+            /// <param name="message" type="String" />
+            /// <returns type="Function" />
+            var x = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                x[_i - 0] = arguments[_i];
+            }
+            return message + _this.name;
+        };
+    };
+    return TestFile;
+})();
diff --git a/tests/baselines/reference/mergeThreeInterfaces.js b/tests/baselines/reference/mergeThreeInterfaces.js
@@ -80,7 +80,6 @@ module M {
 
 //// [mergeThreeInterfaces.js]
 // interfaces with the same root module should merge
-// basic case
 var a;
 var r1 = a.foo;
 var r2 = a.bar;
diff --git a/tests/baselines/reference/mergeTwoInterfaces.js b/tests/baselines/reference/mergeTwoInterfaces.js
@@ -59,7 +59,6 @@ module M {
 
 //// [mergeTwoInterfaces.js]
 // two interfaces with the same root module should merge
-// basic case
 var a;
 var r1 = a.foo;
 var r2 = a.bar;
diff --git a/tests/baselines/reference/parserSbp_7.9_A9_T3.js b/tests/baselines/reference/parserSbp_7.9_A9_T3.js
@@ -22,11 +22,4 @@ do {
 do {
     ;
 } while (false);
-/**
- * Check Do-While Statement for automatic semicolon insertion
- *
- * @path bestPractice/Sbp_7.9_A9_T3.js
- * @description Execute do { \n ; \n }while(false) true
- */
-//CHECK#1
 true;
diff --git a/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.js b/tests/baselines/reference/stringLiteralTypeIsSubtypeOfString.js
@@ -101,7 +101,6 @@ function f16<T extends String, U extends T>(x: any) { }
 
 //// [stringLiteralTypeIsSubtypeOfString.js]
 // string literal types are subtypes of string, any
-// ok
 function f1(x) {
 }
 function f2(x) {
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality.js b/tests/baselines/reference/subtypingWithObjectMembersOptionality.js
@@ -75,6 +75,7 @@ module TwoLevels {
 
 //// [subtypingWithObjectMembersOptionality.js]
 // Derived member is not optional but base member is, should be ok
+// object literal case
 var a;
 var b = { Foo: null };
 var r = true ? a : b;
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality2.js b/tests/baselines/reference/subtypingWithObjectMembersOptionality2.js
@@ -35,6 +35,7 @@ var r = true ? a : b; // error
 
 //// [subtypingWithObjectMembersOptionality2.js]
 // Derived member is optional but base member is not, should be an error
+// object literal case
 var a;
 var b;
 var r = true ? a : b; // error
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality3.js b/tests/baselines/reference/subtypingWithObjectMembersOptionality3.js
@@ -35,6 +35,7 @@ var r = true ? a : b; // ok
 
 //// [subtypingWithObjectMembersOptionality3.js]
 // Base property is optional and derived type has no property of that name
+// object literal case
 var a;
 var b;
 var r = true ? a : b; // ok
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality4.js b/tests/baselines/reference/subtypingWithObjectMembersOptionality4.js
@@ -35,6 +35,7 @@ var r = true ? a : b; // ok
 
 //// [subtypingWithObjectMembersOptionality4.js]
 // Base has required property, derived adds an optional property, no errors
+// object literal case
 var a;
 var b;
 var r = true ? a : b; // ok
diff --git a/tests/baselines/reference/typeResolution.js.map b/tests/baselines/reference/typeResolution.js.map
diff --git a/tests/baselines/reference/typeResolution.sourcemap.txt b/tests/baselines/reference/typeResolution.sourcemap.txt
diff --git a/tests/cases/compiler/detachedCommentAtStartOfLambdaFunction1.ts b/tests/cases/compiler/detachedCommentAtStartOfLambdaFunction1.ts
diff --git a/tests/cases/compiler/detachedCommentAtStartOfLambdaFunction2.ts b/tests/cases/compiler/detachedCommentAtStartOfLambdaFunction2.ts

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,6 @@ function f16<T extends String, U extends T>(x: any) { }`
`101`	`101`
`102`	`102`	`//// [stringLiteralTypeIsSubtypeOfString.js]`
`103`	`103`	`// string literal types are subtypes of string, any`
`104`		`-// ok`
`105`	`104`	`function f1(x) {`
`106`	`105`	`}`
`107`	`106`	`function f2(x) {`