microsoft · rbuckton · Mar 18, 2016 · Feb 9, 2016 · Feb 9, 2016 · Feb 9, 2016
diff --git a/Jakefile.js b/Jakefile.js
@@ -238,6 +238,7 @@ function concatenateFiles(destinationFile, sourceFiles) {
 }
 
 var useDebugMode = true;
+var useTransforms = process.env.USE_TRANSFORMS || false;
 var host = (process.env.host || process.env.TYPESCRIPT_HOST || "node");
 var compilerFilename = "tsc.js";
 var LKGCompiler = path.join(LKGDirectory, compilerFilename);
@@ -297,6 +298,10 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOu
             options += " --stripInternal"
         }
 
+        if (useBuiltCompiler && useTransforms) {
+            options += " --experimentalTransforms"
+        }
+
         var cmd = host + " " + compilerPath + " " + options + " ";
         cmd = cmd + sources.join(" ");
         console.log(cmd + "\n");
@@ -420,6 +425,10 @@ task("setDebugMode", function() {
     useDebugMode = true;
 });
 
+task("setTransforms", function() {
+    useTransforms = true;
+});
+
 task("configure-nightly", [configureNightlyJs], function() {
     var cmd = host + " " + configureNightlyJs + " " + packageJson + " " + programTs;
     console.log(cmd);

diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
@@ -320,6 +320,11 @@ namespace ts {
             name: "allowSyntheticDefaultImports",
             type: "boolean",
             description: Diagnostics.Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking
+        },
+        {
+            name: "experimentalTransforms",
+            type: "boolean",
+            experimental: true
         }
     ];
 

diff --git a/src/compiler/comments.ts b/src/compiler/comments.ts
@@ -5,11 +5,15 @@ namespace ts {
     export interface CommentWriter {
         reset(): void;
         setSourceFile(sourceFile: SourceFile): void;
-        getLeadingCommentsToEmit(node: TextRange): CommentRange[];
-        getTrailingCommentsToEmit(node: TextRange): CommentRange[];
-        emitDetachedComments(node: TextRange): void;
-        emitLeadingComments(node: TextRange, comments?: CommentRange[]): void;
-        emitTrailingComments(node: TextRange, comments?: CommentRange[]): void;
+        getLeadingComments(range: Node, getAdditionalRange?: (range: Node) => Node): CommentRange[];
+        getLeadingComments(range: TextRange): CommentRange[];
+        getLeadingCommentsOfPosition(pos: number): CommentRange[];
+        getTrailingComments(range: Node, getAdditionalRange?: (range: Node) => Node): CommentRange[];
+        getTrailingComments(range: TextRange): CommentRange[];
+        getTrailingCommentsOfPosition(pos: number): CommentRange[];
+        emitLeadingComments(range: TextRange, comments?: CommentRange[]): void;
+        emitTrailingComments(range: TextRange, comments?: CommentRange[]): void;
+        emitDetachedComments(range: TextRange): void;
     }
 
     export function createCommentWriter(host: EmitHost, writer: EmitTextWriter, sourceMap: SourceMapWriter): CommentWriter {
@@ -25,8 +29,8 @@ namespace ts {
         // This maps start->end for a comment range. See `hasConsumedCommentRange` and
         // `consumeCommentRange` for usage.
         let consumedCommentRanges: number[];
-        let leadingCommentRangeNodeStarts: boolean[];
-        let trailingCommentRangeNodeEnds: boolean[];
+        let leadingCommentRangePositions: boolean[];
+        let trailingCommentRangePositions: boolean[];
 
         return compilerOptions.removeComments
             ? createCommentRemovingWriter()
@@ -36,11 +40,13 @@ namespace ts {
             return {
                 reset,
                 setSourceFile,
-                getLeadingCommentsToEmit(node: TextRange): CommentRange[] { return undefined; },
-                getTrailingCommentsToEmit(node: TextRange): CommentRange[]  { return undefined; },
+                getLeadingComments(range: TextRange, getAdditionalRange?: (range: TextRange) => TextRange): CommentRange[] { return undefined; },
+                getLeadingCommentsOfPosition(pos: number): CommentRange[] { return undefined; },
+                getTrailingComments(range: TextRange, getAdditionalRange?: (range: TextRange) => TextRange): CommentRange[] { return undefined; },
+                getTrailingCommentsOfPosition(pos: number): CommentRange[] { return undefined; },
+                emitLeadingComments(range: TextRange, comments?: CommentRange[]): void { },
+                emitTrailingComments(range: TextRange, comments?: CommentRange[]): void { },
                 emitDetachedComments,
-                emitLeadingComments(node: TextRange, comments?: CommentRange[]): void { },
-                emitTrailingComments(node: TextRange, comments?: CommentRange[]): void { },
             };
 
             function emitDetachedComments(node: TextRange): void {
@@ -53,41 +59,85 @@ namespace ts {
             return {
                 reset,
                 setSourceFile,
-                getLeadingCommentsToEmit,
-                getTrailingCommentsToEmit,
-                emitDetachedComments,
+                getLeadingComments,
+                getLeadingCommentsOfPosition,
+                getTrailingComments,
+                getTrailingCommentsOfPosition,
                 emitLeadingComments,
                 emitTrailingComments,
+                emitDetachedComments,
             };
 
-            function getLeadingCommentsToEmit(node: TextRange) {
-                if (nodeIsSynthesized(node)) {
-                    return;
+            function getLeadingComments(range: TextRange | Node, getAdditionalRange?: (range: Node) => Node) {
+                let comments = getLeadingCommentsOfPosition(range.pos);
+                if (getAdditionalRange) {
+                    let additionalRange = getAdditionalRange(<Node>range);
+                    while (additionalRange) {
+                        comments = concatenate(
+                            getLeadingCommentsOfPosition(additionalRange.pos),
+                            comments
+                        );
+
+                        additionalRange = getAdditionalRange(additionalRange);
+                    }
                 }
 
-                if (!leadingCommentRangeNodeStarts[node.pos]) {
-                    leadingCommentRangeNodeStarts[node.pos] = true;
-                    const comments = hasDetachedComments(node.pos)
-                        ? getLeadingCommentsWithoutDetachedComments()
-                        : getLeadingCommentRanges(currentText, node.pos);
-                    return consumeCommentRanges(comments);
+                return comments;
+            }
+
+            function getTrailingComments(range: TextRange | Node, getAdditionalRange?: (range: Node) => Node) {
+                let comments = getTrailingCommentsOfPosition(range.end);
+                if (getAdditionalRange) {
+                    let additionalRange = getAdditionalRange(<Node>range);
+                    while (additionalRange) {
+                        comments = concatenate(
+                            comments,
+                            getTrailingCommentsOfPosition(additionalRange.end)
+                        );
+
+                        additionalRange = getAdditionalRange(additionalRange);
+                    }
                 }
 
-                return noComments;
+                return comments;
             }
 
-            function getTrailingCommentsToEmit(node: TextRange) {
-                if (nodeIsSynthesized(node)) {
-                    return;
+            function getLeadingCommentsOfPosition(pos: number) {
+                if (positionIsSynthesized(pos) || leadingCommentRangePositions[pos]) {
+                    return undefined;
                 }
 
-                if (!trailingCommentRangeNodeEnds[node.end]) {
-                    trailingCommentRangeNodeEnds[node.end] = true;
-                    const comments = getTrailingCommentRanges(currentText, node.end);
-                    return consumeCommentRanges(comments);
+                leadingCommentRangePositions[pos] = true;
+                const comments = hasDetachedComments(pos)
+                    ? getLeadingCommentsWithoutDetachedComments()
+                    : getLeadingCommentRanges(currentText, pos);
+                return consumeCommentRanges(comments);
+            }
+
+            function getTrailingCommentsOfPosition(pos: number) {
+                if (positionIsSynthesized(pos) || trailingCommentRangePositions[pos]) {
+                    return undefined;
                 }
 
-                return noComments;
+                trailingCommentRangePositions[pos] = true;
+                const comments = getTrailingCommentRanges(currentText, pos);
+                return consumeCommentRanges(comments);
+            }
+
+            function emitLeadingComments(range: TextRange, comments = getLeadingComments(range)) {
+                emitNewLineBeforeLeadingComments(currentLineMap, writer, range, comments);
+
+                // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
+                emitComments(currentText, currentLineMap, writer, comments, /*leadingSeparator*/ false, /*trailingSeparator*/ true, newLine, writeComment);
+            }
+
+            function emitTrailingComments(range: TextRange, comments = getTrailingComments(range)) {
+                // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment*/
+                emitComments(currentText, currentLineMap, writer, comments, /*leadingSeparator*/ true, /*trailingSeparator*/ false, newLine, writeComment);
+            }
+
+            function emitDetachedComments(range: TextRange) {
+                emitDetachedCommentsAndUpdateCommentsInfo(range, /*removeComments*/ false);
             }
 
             function hasConsumedCommentRange(comment: CommentRange) {
@@ -136,22 +186,6 @@ namespace ts {
 
                 return noComments;
             }
-
-            function emitLeadingComments(range: TextRange, leadingComments: CommentRange[] = getLeadingCommentsToEmit(range)) {
-                emitNewLineBeforeLeadingComments(currentLineMap, writer, range, leadingComments);
-
-                // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
-                emitComments(currentText, currentLineMap, writer, leadingComments, /*trailingSeparator*/ true, newLine, writeComment);
-            }
-
-            function emitTrailingComments(range: TextRange, trailingComments = getTrailingCommentsToEmit(range)) {
-                // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment*/
-                emitComments(currentText, currentLineMap, writer, trailingComments, /*trailingSeparator*/ false, newLine, writeComment);
-            }
-
-            function emitDetachedComments(range: TextRange) {
-                emitDetachedCommentsAndUpdateCommentsInfo(range, /*removeComments*/ false);
-            }
         }
 
         function reset() {
@@ -160,8 +194,8 @@ namespace ts {
             currentLineMap = undefined;
             detachedCommentsInfo = undefined;
             consumedCommentRanges = undefined;
-            trailingCommentRangeNodeEnds = undefined;
-            leadingCommentRangeNodeStarts = undefined;
+            trailingCommentRangePositions = undefined;
+            leadingCommentRangePositions = undefined;
         }
 
         function setSourceFile(sourceFile: SourceFile) {
@@ -170,8 +204,8 @@ namespace ts {
             currentLineMap = getLineStarts(sourceFile);
             detachedCommentsInfo = undefined;
             consumedCommentRanges = [];
-            leadingCommentRangeNodeStarts = [];
-            trailingCommentRangeNodeEnds = [];
+            leadingCommentRangePositions = [];
+            trailingCommentRangePositions = [];
         }
 
         function hasDetachedComments(pos: number) {

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -171,15 +171,20 @@ namespace ts {
         return result;
     }
 
-    export function flatMap<T, U>(array: T[], f: (x: T, i: number) => U[]): U[] {
+    /**
+     * Maps an array. If the mapped value is an array, it is spread into the result.
+     */
+    export function flatMap<T, U>(array: T[], f: (x: T, i: number) => U | U[]): U[] {
         let result: U[];
         if (array) {
             result = [];
             for (let i = 0; i < array.length; i++) {
                 const v = array[i];
                 const ar = f(v, i);
                 if (ar) {
-                    result = result.concat(ar);
+                    // We cast to <U> here to leverage the behavior of Array#concat
+                    // which will append a single value here.
+                    result = result.concat(<U[]>ar);
                 }
             }
         }

diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
@@ -91,7 +91,7 @@ namespace ts {
                     // Emit reference in dts, if the file reference was not already emitted
                     if (referencedFile && !contains(emittedReferencedFiles, referencedFile)) {
                         // Add a reference to generated dts file,
-                        // global file reference is added only 
+                        // global file reference is added only
                         //  - if it is not bundled emit (because otherwise it would be self reference)
                         //  - and it is not already added
                         if (writeReferencePath(referencedFile, !isBundledEmit && !addedGlobalFileReference)) {
@@ -144,7 +144,7 @@ namespace ts {
 
             if (!isBundledEmit && isExternalModule(sourceFile) && sourceFile.moduleAugmentations.length && !resultHasExternalModuleIndicator) {
                 // if file was external module with augmentations - this fact should be preserved in .d.ts as well.
-                // in case if we didn't write any external module specifiers in .d.ts we need to emit something 
+                // in case if we didn't write any external module specifiers in .d.ts we need to emit something
                 // that will force compiler to think that this file is an external module - 'export {}' is a reasonable choice here.
                 write("export {};");
                 writeLine();
@@ -349,7 +349,7 @@ namespace ts {
                 const jsDocComments = getJsDocCommentsFromText(declaration, currentText);
                 emitNewLineBeforeLeadingComments(currentLineMap, writer, declaration, jsDocComments);
                 // jsDoc comments are emitted at /*leading comment1 */space/*leading comment*/space
-                emitComments(currentText, currentLineMap, writer, jsDocComments, /*trailingSeparator*/ true, newLine, writeCommentRange);
+                emitComments(currentText, currentLineMap, writer, jsDocComments, /*leadingSeparator*/ false, /*trailingSeparator*/ true, newLine, writeCommentRange);
             }
         }
 
@@ -736,7 +736,7 @@ namespace ts {
 
         function emitExternalModuleSpecifier(parent: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration | ModuleDeclaration) {
             // emitExternalModuleSpecifier is usually called when we emit something in the.d.ts file that will make it an external module (i.e. import/export declarations).
-            // the only case when it is not true is when we call it to emit correct name for module augmentation - d.ts files with just module augmentations are not considered 
+            // the only case when it is not true is when we call it to emit correct name for module augmentation - d.ts files with just module augmentations are not considered
             // external modules since they are indistingushable from script files with ambient modules. To fix this in such d.ts files we'll emit top level 'export {}'
             // so compiler will treat them as external modules.
             resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || parent.kind !== SyntaxKind.ModuleDeclaration;