Adds a simplified pretty printer for tree transformations

Jakefile.js

@@ -42,8 +42,18 @@ var compilerSources = [
     "checker.ts",
     "factory.ts",
     "visitor.ts",
+    "transformers/destructuring.ts",
+    "transformers/ts.ts",
+    "transformers/module/es6.ts",
+    "transformers/module/system.ts",
+    "transformers/module/module.ts",
+    "transformers/jsx.ts",
+    "transformers/es7.ts",
+    "transformers/es6.ts",
     "transformer.ts",
     "sourcemap.ts",
+    "comments.ts",
+    "printer.ts",
     "declarationEmitter.ts",
     "emitter.ts",
     "program.ts",
@@ -65,8 +75,18 @@ var servicesSources = [
     "checker.ts",
     "factory.ts",
     "visitor.ts",
+    "transformers/destructuring.ts",
+    "transformers/ts.ts",
+    "transformers/module/es6.ts",
+    "transformers/module/system.ts",
+    "transformers/module/module.ts",
+    "transformers/jsx.ts",
+    "transformers/es7.ts",
+    "transformers/es6.ts",
     "transformer.ts",
     "sourcemap.ts",
+    "comments.ts",
+    "printer.ts",
     "declarationEmitter.ts",
     "emitter.ts",
     "program.ts",
@@ -218,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);
@@ -277,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");
@@ -400,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);

src/compiler/commandLineParser.ts

@@ -320,6 +320,13 @@ 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
+        },
+        {
+            // this option will be removed when this is merged with master and exists solely
+            // to enable the tree transforming emitter side-by-side with the existing emitter.
+            name: "experimentalTransforms",
+            type: "boolean",
+            experimental: true
         }
     ];
 

src/compiler/comments.ts

@@ -0,0 +1,248 @@
+/// <reference path="sourcemap.ts" />
+
+/* @internal */
+namespace ts {
+    export interface CommentWriter {
+        reset(): void;
+        setSourceFile(sourceFile: SourceFile): 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 {
+        const compilerOptions = host.getCompilerOptions();
+        const newLine = host.getNewLine();
+        const { emitPos } = sourceMap;
+
+        let currentSourceFile: SourceFile;
+        let currentText: string;
+        let currentLineMap: number[];
+        let detachedCommentsInfo: { nodePos: number, detachedCommentEndPos: number}[];
+
+        // This maps start->end for a comment range. See `hasConsumedCommentRange` and
+        // `consumeCommentRange` for usage.
+        let consumedCommentRanges: number[];
+        let leadingCommentRangePositions: boolean[];
+        let trailingCommentRangePositions: boolean[];
+
+        return compilerOptions.removeComments
+            ? createCommentRemovingWriter()
+            : createCommentPreservingWriter();
+
+        function createCommentRemovingWriter(): CommentWriter {
+            return {
+                reset,
+                setSourceFile,
+                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,
+            };
+
+            function emitDetachedComments(node: TextRange): void {
+                emitDetachedCommentsAndUpdateCommentsInfo(node, /*removeComments*/ true);
+            }
+        }
+
+        function createCommentPreservingWriter(): CommentWriter {
+            const noComments: CommentRange[] = [];
+            return {
+                reset,
+                setSourceFile,
+                getLeadingComments,
+                getLeadingCommentsOfPosition,
+                getTrailingComments,
+                getTrailingCommentsOfPosition,
+                emitLeadingComments,
+                emitTrailingComments,
+                emitDetachedComments,
+            };
+
+            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);
+                    }
+                }
+
+                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 comments;
+            }
+
+            function getLeadingCommentsOfPosition(pos: number) {
+                if (positionIsSynthesized(pos) || leadingCommentRangePositions[pos]) {
+                    return undefined;
+                }
+
+                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;
+                }
+
+                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) {
+                return comment.end === consumedCommentRanges[comment.pos];
+            }
+
+            function consumeCommentRange(comment: CommentRange) {
+                if (!hasConsumedCommentRange(comment)) {
+                    consumedCommentRanges[comment.pos] = comment.end;
+                    return true;
+                }
+
+                return false;
+            }
+
+            function consumeCommentRanges(comments: CommentRange[]) {
+                let consumed: CommentRange[];
+                if (comments) {
+                    let commentsSkipped = 0;
+                    let commentsConsumed = 0;
+                    for (let i = 0; i < comments.length; i++) {
+                        const comment = comments[i];
+                        if (consumeCommentRange(comment)) {
+                            commentsConsumed++;
+                            if (commentsSkipped !== 0) {
+                                if (consumed === undefined) {
+                                    consumed = [comment];
+                                }
+                                else {
+                                    consumed.push(comment);
+                                }
+                            }
+                        }
+                        else {
+                            commentsSkipped++;
+                            if (commentsConsumed !== 0 && consumed === undefined) {
+                                consumed = comments.slice(0, i);
+                            }
+                        }
+                    }
+
+                    if (commentsConsumed) {
+                        return consumed || comments;
+                    }
+                }
+
+                return noComments;
+            }
+        }
+
+        function reset() {
+            currentSourceFile = undefined;
+            currentText = undefined;
+            currentLineMap = undefined;
+            detachedCommentsInfo = undefined;
+            consumedCommentRanges = undefined;
+            trailingCommentRangePositions = undefined;
+            leadingCommentRangePositions = undefined;
+        }
+
+        function setSourceFile(sourceFile: SourceFile) {
+            currentSourceFile = sourceFile;
+            currentText = sourceFile.text;
+            currentLineMap = getLineStarts(sourceFile);
+            detachedCommentsInfo = undefined;
+            consumedCommentRanges = [];
+            leadingCommentRangePositions = [];
+            trailingCommentRangePositions = [];
+        }
+
+        function hasDetachedComments(pos: number) {
+            return detachedCommentsInfo !== undefined && lastOrUndefined(detachedCommentsInfo).nodePos === pos;
+        }
+
+        function getLeadingCommentsWithoutDetachedComments() {
+            // get the leading comments from detachedPos
+            const pos = lastOrUndefined(detachedCommentsInfo).detachedCommentEndPos;
+            const leadingComments = getLeadingCommentRanges(currentText, pos);
+            if (detachedCommentsInfo.length - 1) {
+                detachedCommentsInfo.pop();
+            }
+            else {
+                detachedCommentsInfo = undefined;
+            }
+
+            return leadingComments;
+        }
+
+        function emitDetachedCommentsAndUpdateCommentsInfo(node: TextRange, removeComments: boolean) {
+            const currentDetachedCommentInfo = emitDetachedComments(currentText, currentLineMap, writer, writeComment, node, newLine, removeComments);
+
+            if (currentDetachedCommentInfo) {
+                if (detachedCommentsInfo) {
+                    detachedCommentsInfo.push(currentDetachedCommentInfo);
+                }
+                else {
+                    detachedCommentsInfo = [currentDetachedCommentInfo];
+                }
+            }
+        }
+
+        function writeComment(text: string, lineMap: number[], writer: EmitTextWriter, comment: CommentRange, newLine: string) {
+            emitPos(comment.pos);
+            writeCommentRange(text, lineMap, writer, comment, newLine);
+            emitPos(comment.end);
+        }
+    }
+}