Emit copyright headers before anything else in the sourceFile

Author: sheetalkamat

src/compiler/emitter.ts

@@ -319,11 +319,15 @@ module ts {
             /** write emitted output to disk*/
             var writeEmittedFiles = writeJavaScriptFile;
 
-            /** Emit leading comments of the declaration */
-            var emitLeadingComments = compilerOptions.removeComments ? (d: Node) => { } : emitLeadingDeclarationComments;
+            /** Emit leading comments of the node */
+            var emitLeadingComments = compilerOptions.removeComments ? (node: Node) => { } : emitLeadingDeclarationComments;
 
-            /** Emit Trailing comments of the declaration */
-            var emitTrailingComments = compilerOptions.removeComments ? (d: Node) => { } : emitTrailingDeclarationComments;
+            /** Emit Trailing comments of the node */
+            var emitTrailingComments = compilerOptions.removeComments ? (node: Node) => { } : emitTrailingDeclarationComments;
+
+            var detachedCommentsEndPos: number;
+            /** Emit detached comments of the node */
+            var emitDetachedComments = compilerOptions.removeComments ? (node: Node) => { } : emitDetachedCommentsAtPosition;
 
             var writeComment = writeCommentRange;
 
@@ -1912,6 +1916,7 @@ module ts {
 
             function emitSourceFile(node: SourceFile) {
                 currentSourceFile = node;
+                emitDetachedComments(node);
                 // emit prologue directives prior to __extends
                 var startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
                 if (!extendsEmitted && resolver.getNodeCheckFlags(node) & NodeCheckFlags.EmitExtends) {
@@ -2064,7 +2069,16 @@ module ts {
             function emitLeadingDeclarationComments(node: Node) {
                 // 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 = getLeadingCommentsOfNode(node, currentSourceFile);
+                    var leadingComments: Comment[];
+                    if (detachedCommentsEndPos === undefined) {
+                        // 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;
+                    }
                     emitNewLineBeforeLeadingComments(node, leadingComments, writer);
                     // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
                     emitComments(leadingComments, /*trailingSeparator*/ true, writer, writeComment);
@@ -2080,6 +2094,44 @@ module ts {
                 }
             }
 
+            function emitDetachedCommentsAtPosition(node: Node) {
+                var leadingComments = getLeadingComments(currentSourceFile.text, node.pos);
+                if (leadingComments) {
+                    var detachedComments: Comment[] = [];
+                    var lastComment: Comment;
+
+                    forEach(leadingComments, comment => {
+                        if (lastComment) {
+                            var lastCommentLine = currentSourceFile.getLineAndCharacterFromPosition(lastComment.end).line;
+                            var commentLine = currentSourceFile.getLineAndCharacterFromPosition(comment.pos).line;
+
+                            if (commentLine >= lastCommentLine + 2) {
+                                // There was a blank line between the last comment and this comment.  This
+                                // comment is not part of the copyright comments.  Return what we have so 
+                                // far.
+                                return detachedComments;
+                            }
+                        }
+
+                        detachedComments.push(comment);
+                        lastComment = comment;
+                    });
+
+                    if (detachedComments && detachedComments.length) {
+                        // All comments look like they could have been part of the copyright header.  Make
+                        // sure there is at least one blank line between it and the node.  If not, it's not
+                        // a copyright header.
+                        var lastCommentLine = currentSourceFile.getLineAndCharacterFromPosition(detachedComments[detachedComments.length - 1].end).line;
+                        var astLine = currentSourceFile.getLineAndCharacterFromPosition(skipTrivia(currentSourceFile.text, node.pos)).line;
+                        if (astLine >= lastCommentLine + 2) {
+                            // Valid detachedComments
+                            emitComments(detachedComments, /*trailingSeparator*/ true, writer, writeComment);
+                            detachedCommentsEndPos = detachedComments[detachedComments.length - 1].end;
+                        }
+                    }
+                }
+            }
+
             if (compilerOptions.sourceMap) {
                 initializeEmitterWithSourceMaps();
             }

tests/baselines/reference/amdDependencyComment2.js

@@ -5,6 +5,7 @@ import m1 = require("m2")
 m1.f();
 
 //// [amdDependencyComment2.js]
+///<amd-dependency path='bar'/>
 define(["require", "exports", "m2", "bar"], function (require, exports, m1) {
     m1.f();
 });

tests/baselines/reference/anyAssignabilityInInheritance.js

@@ -89,6 +89,7 @@ declare function foo18(x: any): any;
 var r3 = foo3(a); // any
 
 //// [anyAssignabilityInInheritance.js]
+// any is not a subtype of any other types, errors expected on all the below derived classes unless otherwise noted
 var a;
 var r3 = foo2(a); // any, not a subtype of number so it skips that overload, is a subtype of itself so it picks second (if truly ambiguous it would pick first overload)
 var r3 = foo3(a); // any

tests/baselines/reference/anyAssignableToEveryType2.js

@@ -131,6 +131,7 @@ interface I20 {
 
 
 //// [anyAssignableToEveryType2.js]
+// any is not a subtype of any other types, but is assignable, all the below should work
 var A = (function () {
     function A() {
     }

tests/baselines/reference/apparentTypeSubtyping.js

@@ -22,14 +22,14 @@ class Derived2<U extends String> extends Base2 { // error because of the prototy
 }
 
 //// [apparentTypeSubtyping.js]
+// subtype checks use the apparent type of the target type
+// S is a subtype of a type T, and T is a supertype of S, if one of the following is true, where S' denotes the apparent type (section 3.8.1) of S:
 var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
     d.prototype = new __();
 };
-// subtype checks use the apparent type of the target type
-// S is a subtype of a type T, and T is a supertype of S, if one of the following is true, where S' denotes the apparent type (section 3.8.1) of S:
 var Base = (function () {
     function Base() {
     }

tests/baselines/reference/apparentTypeSupertype.js

@@ -12,14 +12,14 @@ class Derived<U extends String> extends Base { // error
 }
 
 //// [apparentTypeSupertype.js]
+// subtype checks use the apparent type of the target type
+// S is a subtype of a type T, and T is a supertype of S, if one of the following is true, where S' denotes the apparent type (section 3.8.1) of S:
 var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
     d.prototype = new __();
 };
-// subtype checks use the apparent type of the target type
-// S is a subtype of a type T, and T is a supertype of S, if one of the following is true, where S' denotes the apparent type (section 3.8.1) of S:
 var Base = (function () {
     function Base() {
     }

tests/baselines/reference/arrayLiterals.js

@@ -45,13 +45,13 @@ var context4: Base[] = [new Derived1(), new Derived1()];
 
 
 //// [arrayLiterals.js]
+// Empty array literal with no contextual type has type Undefined[]
 var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
     d.prototype = new __();
 };
-// Empty array literal with no contextual type has type Undefined[]
 var arr1 = [[], [1], ['']];
 var arr1; // Bug 825172: Error ({}[] does not match {}[]), but should be OK
 var arr2 = [[null], [1], ['']];

tests/baselines/reference/assignmentCompatWithCallSignatures.js

@@ -44,6 +44,7 @@ a = function (x: string) { return ''; }
 
 
 //// [assignmentCompatWithCallSignatures.js]
+// void returning call signatures can be assigned a non-void returning call signature that otherwise matches
 var t;
 var a;
 t = a;

tests/baselines/reference/assignmentCompatWithCallSignatures2.js

@@ -51,6 +51,7 @@ a = function (x: string) { return ''; }
 
 
 //// [assignmentCompatWithCallSignatures2.js]
+// void returning call signatures can be assigned a non-void returning call signature that otherwise matches
 var t;
 var a;
 t = a;

tests/baselines/reference/assignmentCompatWithCallSignatures3.js

@@ -100,13 +100,13 @@ b18 = a18; // ok
 
 
 //// [assignmentCompatWithCallSignatures3.js]
+// these are all permitted with the current rules, since we do not do contextual signature instantiation
 var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
     d.prototype = new __();
 };
-// these are all permitted with the current rules, since we do not do contextual signature instantiation
 var Base = (function () {
     function Base() {
     }