Transient node properties for transformations.

rbuckton · rbuckton · commit e64724ea35af · 2016-05-24T16:27:39.000-07:00
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -1059,6 +1059,7 @@ namespace ts {
         this.excludeTransformFlags = TransformFlags.None;
         this.parent = undefined;
         this.original = undefined;
+        this.transformId = 0;
     }
 
     export let objectAllocator: ObjectAllocator = {
@@ -1181,16 +1182,20 @@ namespace ts {
             }
         }
 
+        /**
+         * Gets the names of all marks.
+         */
+        export function getMarkNames() {
+            return getKeys(markCounts);
+        }
+
         /**
          * Gets the number of marks with the specified name.
          *
          * @param markName The name of the marks that should be counted.
          */
         export function getCount(markName: string) {
-            if (enabled) {
-                return getProperty(markCounts, markName) || 0;
-            }
-            return 0;
+            return enabled && getProperty(markCounts, markName) || 0;
         }
 
         /**
@@ -1199,10 +1204,7 @@ namespace ts {
          * @param markName The name of the mark.
          */
         export function getTimestamp(markName: string) {
-            if (enabled) {
-                return getProperty(markTimestamps, markName) || 0;
-            }
-            return 0;
+            return enabled && getProperty(markTimestamps, markName) || 0;
         }
 
         /**
@@ -1221,8 +1223,9 @@ namespace ts {
         }
 
         function clearMark(markName: string) {
-            markTimestamps[markName] = 0;
-            markCounts[markName] = 0;
+            if (delete markTimestamps[markName]) {
+                delete markCounts[markName];
+            }
         }
 
         /**
@@ -1246,13 +1249,20 @@ namespace ts {
             }
         }
 
+        /**
+         * Gets the names of all recorded measures.
+         */
+        export function getMeasureNames() {
+            return getKeys(measureDurations);
+        }
+
         /**
          * Gets the total duration of all measurements with the supplied name.
          *
          * @param measureName The name of the measure whose durations should be accumulated.
          */
         export function getDuration(measureName: string) {
-            return getProperty(measureDurations, measureName) || 0;
+            return enabled && getProperty(measureDurations, measureName) || 0;
         }
 
         /**
@@ -1271,7 +1281,7 @@ namespace ts {
         }
 
         function clearMeasure(measureName: string) {
-            measureDurations[measureName] = 0;
+            delete measureDurations[measureName];
         }
 
         /**
diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts
@@ -45,6 +45,14 @@ namespace ts {
         return transformers;
     }
 
+    /**
+     * Tracks a monotonically increasing transformation id used to associate a node with a specific
+     * transformation. This ensures transient properties related to transformations can be safely
+     * stored on source tree nodes that may be reused across multiple transformations (such as
+     * with compile-on-save).
+     */
+    let nextTransformId = 1;
+
     /**
      * Transforms an array of SourceFiles by passing them through each transformer.
      *
@@ -54,12 +62,13 @@ namespace ts {
      * @param transforms An array of Transformers.
      */
     export function transformFiles(resolver: EmitResolver, host: EmitHost, sourceFiles: SourceFile[], transformers: Transformer[]) {
-        const nodeEmitFlags: Map<NodeEmitFlags> = {};
-        const sourceMapRanges: Map<TextRange> = {};
-        const commentRanges: Map<TextRange> = {};
+        const transformId = nextTransformId++;
+        const tokenSourceMapRanges: Map<TextRange> = { };
         const lexicalEnvironmentVariableDeclarationsStack: VariableDeclaration[][] = [];
         const lexicalEnvironmentFunctionDeclarationsStack: FunctionDeclaration[][] = [];
         const enabledSyntaxKindFeatures = new Array<SyntaxKindFeatureFlags>(SyntaxKind.Count);
+        const sourceTreeNodesWithAnnotations: Node[] = [];
+
         let lastNodeEmitFlagsNode: Node;
         let lastNodeEmitFlags: NodeEmitFlags;
         let lastSourceMapRangeNode: Node;
@@ -118,7 +127,20 @@ namespace ts {
             }
 
             currentSourceFile = sourceFile;
-            return transformation(sourceFile);
+            sourceFile = transformation(sourceFile);
+
+            // Cleanup source tree nodes with annotations
+            for (const node of sourceTreeNodesWithAnnotations) {
+                if (node.transformId === transformId) {
+                    node.transformId = 0;
+                    node.emitFlags = 0;
+                    node.commentRange = undefined;
+                    node.sourceMapRange = undefined;
+                }
+            }
+
+            sourceTreeNodesWithAnnotations.length = 0;
+            return sourceFile;
         }
 
         /**
@@ -181,6 +203,28 @@ namespace ts {
             emit(node);
         }
 
+        /**
+         * Associates a node with the current transformation, initializing
+         * various transient transformation properties.
+         *
+         * @param node The node.
+         */
+        function beforeSetAnnotation(node: Node) {
+            if (node.transformId !== transformId) {
+                node.transformId = transformId;
+                if ((node.flags & NodeFlags.Synthesized) === 0) {
+                    node.emitFlags = 0;
+                    node.sourceMapRange = undefined;
+                    node.commentRange = undefined;
+
+                    // To avoid holding onto transformation artifacts, we keep track of any
+                    // source tree node we are annotating. This allows us to clean them up after
+                    // all transformations have completed.
+                    sourceTreeNodesWithAnnotations.push(node);
+                }
+            }
+        }
+
         /**
          * Gets flags that control emit behavior of a node.
          *
@@ -196,15 +240,19 @@ namespace ts {
                 return lastNodeEmitFlags;
             }
 
-
+            // Get the emit flags for a node or from one of its original nodes.
             let flags: NodeEmitFlags;
-            while (node) {
-                let flags = node.id ? nodeEmitFlags[node.id] : undefined;
-                if (flags !== undefined) {
-                    break;
+            let current = node;
+            while (current) {
+                if (current.transformId === transformId) {
+                    const nodeEmitFlags = current.emitFlags;
+                    if (nodeEmitFlags) {
+                        flags = nodeEmitFlags & ~NodeEmitFlags.HasNodeEmitFlags;
+                        break;
+                    }
                 }
 
-                node = node.original;
+                current = current.original;
             }
 
             // Cache the most recently requested value.
@@ -220,14 +268,17 @@ namespace ts {
          * @param emitFlags The NodeEmitFlags for the node.
          */
         function setNodeEmitFlags<T extends Node>(node: T, emitFlags: NodeEmitFlags) {
+            // Merge existing flags.
             if (emitFlags & NodeEmitFlags.Merge) {
                 emitFlags = getNodeEmitFlags(node) | (emitFlags & ~NodeEmitFlags.Merge);
             }
 
+            beforeSetAnnotation(node);
+
             // Cache the most recently requested value.
             lastNodeEmitFlagsNode = node;
             lastNodeEmitFlags = emitFlags;
-            nodeEmitFlags[getNodeId(node)] = emitFlags;
+            node.emitFlags = emitFlags | NodeEmitFlags.HasNodeEmitFlags;
             return node;
         }
 
@@ -246,12 +297,15 @@ namespace ts {
                 return lastSourceMapRange || node;
             }
 
+            // Get the custom source map range for a node or from one of its original nodes.
             let range: TextRange;
             let current = node;
             while (current) {
-                range = current.id ? sourceMapRanges[current.id] : undefined;
-                if (range !== undefined) {
-                    break;
+                if (current.transformId === transformId) {
+                    range = current.sourceMapRange;
+                    if (range !== undefined) {
+                        break;
+                    }
                 }
 
                 current = current.original;
@@ -270,10 +324,12 @@ namespace ts {
          * @param range The text range.
          */
         function setSourceMapRange<T extends Node>(node: T, range: TextRange) {
+            beforeSetAnnotation(node);
+
             // Cache the most recently requested value.
             lastSourceMapRangeNode = node;
             lastSourceMapRange = range;
-            sourceMapRanges[getNodeId(node)] = range;
+            node.sourceMapRange = range;
             return node;
         }
 
@@ -290,13 +346,15 @@ namespace ts {
             // As a performance optimization, use the cached value of the most recent node.
             // This helps for cases where this function is called repeatedly for the same node.
             if (lastTokenSourceMapRangeNode === node && lastTokenSourceMapRangeToken === token) {
-                return lastSourceMapRange;
+                return lastTokenSourceMapRange;
             }
 
+            // Get the custom token source map range for a node or from one of its original nodes.
+            // Custom token ranges are not stored on the node to avoid the GC burden.
             let range: TextRange;
             let current = node;
             while (current) {
-                range = current.id ? sourceMapRanges[current.id + "-" + token] : undefined;
+                range = current.id ? tokenSourceMapRanges[current.id + "-" + token] : undefined;
                 if (range !== undefined) {
                     break;
                 }
@@ -323,7 +381,7 @@ namespace ts {
             lastTokenSourceMapRangeNode = node;
             lastTokenSourceMapRangeToken = token;
             lastTokenSourceMapRange = range;
-            sourceMapRanges[getNodeId(node) + "-" + token] = range;
+            tokenSourceMapRanges[getNodeId(node) + "-" + token] = range;
             return node;
         }
 
@@ -342,12 +400,15 @@ namespace ts {
                 return lastCommentMapRange || node;
             }
 
+            // Get the custom comment range for a node or from one of its original nodes.
             let range: TextRange;
             let current = node;
             while (current) {
-                range = current.id ? commentRanges[current.id] : undefined;
-                if (range !== undefined) {
-                    break;
+                if (current.transformId === transformId) {
+                    range = current.commentRange;
+                    if (range !== undefined) {
+                        break;
+                    }
                 }
 
                 current = current.original;
@@ -363,10 +424,12 @@ namespace ts {
          * Sets a custom text range to use when emitting comments.
          */
         function setCommentRange<T extends Node>(node: T, range: TextRange) {
+            beforeSetAnnotation(node);
+
             // Cache the most recently requested value.
             lastCommentMapRangeNode = node;
             lastCommentMapRange = range;
-            commentRanges[getNodeId(node)] = range;
+            node.commentRange = range;
             return node;
         }
 
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
@@ -544,7 +544,7 @@ namespace ts {
     }
 
     function compile(fileNames: string[], compilerOptions: CompilerOptions, compilerHost: CompilerHost) {
-        if (compilerOptions.diagnostics) {
+        if (compilerOptions.diagnostics || compilerOptions.extendedDiagnostics) {
             performance.enable();
             performance.reset();
         }
@@ -558,7 +558,7 @@ namespace ts {
             });
         }
 
-        if (compilerOptions.diagnostics) {
+        if (compilerOptions.diagnostics || compilerOptions.extendedDiagnostics) {
             const memoryUsed = sys.getMemoryUsage ? sys.getMemoryUsage() : -1;
             reportCountStatistic("Files", program.getSourceFiles().length);
             reportCountStatistic("Lines", countLines(program));
@@ -577,9 +577,6 @@ namespace ts {
             // emit time includes I/O write time. We preserve this behavior so we can accurately compare times.
             reportTimeStatistic("I/O read", performance.getDuration("ioReadTime"));
             reportTimeStatistic("I/O write", performance.getDuration("ioWriteTime"));
-            reportTimeStatistic("Print time", performance.getDuration("printTime"));
-            reportTimeStatistic("Comment time", performance.getDuration("commentTime"));
-            reportTimeStatistic("Sourcemap time", performance.getDuration("sourcemapTime"));
             const programTime = performance.getDuration("programTime");
             const bindTime = performance.getDuration("bindTime");
             const checkTime = performance.getDuration("checkTime");
@@ -590,6 +587,27 @@ namespace ts {
             reportTimeStatistic("Emit time", emitTime);
             reportTimeStatistic("Total time", programTime + bindTime + checkTime + emitTime);
 
+            if (compilerOptions.extendedDiagnostics) {
+                sys.write("Extended Diagnostics:" + sys.newLine);
+                sys.write("Marks:" + sys.newLine);
+                for (const markName of performance.getMarkNames()) {
+                    if (/^(ioReadStart|ioWriteStart|programStart|bindStart|checkStart|emitStart)$/.test(markName)) {
+                        continue;
+                    }
+
+                    reportCountStatistic("  " + markName, performance.getCount(markName));
+                }
+
+                sys.write("Measures:" + sys.newLine);
+                for (const measureName of performance.getMeasureNames()) {
+                    if (/^(ioReadTime|ioWriteTime|programTime|bindTime|checkTime|emitTime)$/.test(measureName)) {
+                        continue;
+                    }
+
+                    reportTimeStatistic("  " + measureName, performance.getDuration(measureName));
+                }
+            }
+
             performance.disable();
             performance.reset();
         }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -470,6 +470,10 @@ namespace ts {
         /* @internal */ locals?: SymbolTable;           // Locals associated with node (initialized by binding)
         /* @internal */ nextContainer?: Node;           // Next container in declaration order (initialized by binding)
         /* @internal */ localSymbol?: Symbol;           // Local symbol declared by node (initialized by binding only for exported nodes)
+        /* @internal */ transformId?: number;           // Associates transient transformation properties with a specific transformation (initialized by transformation).
+        /* @internal */ emitFlags?: NodeEmitFlags;      // Transient emit flags for a synthesized node (initialized by transformation).
+        /* @internal */ sourceMapRange?: TextRange;     // Transient custom sourcemap range for a synthesized node (initialized by transformation).
+        /* @internal */ commentRange?: TextRange;       // Transient custom comment range for a synthesized node (initialized by transformation).
     }
 
     export interface NodeArray<T extends Node> extends Array<T>, TextRange {
@@ -2957,6 +2961,8 @@ namespace ts {
         //                 align with the old emitter.
         SourceMapEmitOpenBraceAsToken = 1 << 21,        // Emits the open brace of a block function body as a source mapped token.
         SourceMapAdjustRestParameterLoop = 1 << 22,     // Emits adjusted source map positions for a ForStatement generated when transforming a rest parameter for ES5/3.
+
+        HasNodeEmitFlags = 1 << 31,              // Indicates the node has emit flags set.
     }
 
     /** Additional context provided to `visitEachChild` */

Original file line number	Diff line number	Diff line change
`@@ -1059,6 +1059,7 @@ namespace ts {`
`1059`	`1059`	`this.excludeTransformFlags = TransformFlags.None;`
`1060`	`1060`	`this.parent = undefined;`
`1061`	`1061`	`this.original = undefined;`
	`1062`	`+ this.transformId = 0;`
`1062`	`1063`	`}`
`1063`	`1064`
`1064`	`1065`	`export let objectAllocator: ObjectAllocator = {`
`@@ -1181,16 +1182,20 @@ namespace ts {`
`1181`	`1182`	`}`
`1182`	`1183`	`}`
`1183`	`1184`
	`1185`	`+ /**`
	`1186`	`+ * Gets the names of all marks.`
	`1187`	`+ */`
	`1188`	`+ export function getMarkNames() {`
	`1189`	`+ return getKeys(markCounts);`
	`1190`	`+ }`
	`1191`	`+`
`1184`	`1192`	`/**`
`1185`	`1193`	`* Gets the number of marks with the specified name.`
`1186`	`1194`	`*`
`1187`	`1195`	`* @param markName The name of the marks that should be counted.`
`1188`	`1196`	`*/`
`1189`	`1197`	`export function getCount(markName: string) {`
`1190`		`- if (enabled) {`
`1191`		`- return getProperty(markCounts, markName) \|\| 0;`
`1192`		`- }`
`1193`		`- return 0;`
	`1198`	`+ return enabled && getProperty(markCounts, markName) \|\| 0;`
`1194`	`1199`	`}`
`1195`	`1200`
`1196`	`1201`	`/**`
`@@ -1199,10 +1204,7 @@ namespace ts {`
`1199`	`1204`	`* @param markName The name of the mark.`
`1200`	`1205`	`*/`
`1201`	`1206`	`export function getTimestamp(markName: string) {`
`1202`		`- if (enabled) {`
`1203`		`- return getProperty(markTimestamps, markName) \|\| 0;`
`1204`		`- }`
`1205`		`- return 0;`
	`1207`	`+ return enabled && getProperty(markTimestamps, markName) \|\| 0;`
`1206`	`1208`	`}`
`1207`	`1209`
`1208`	`1210`	`/**`
`@@ -1221,8 +1223,9 @@ namespace ts {`
`1221`	`1223`	`}`
`1222`	`1224`
`1223`	`1225`	`function clearMark(markName: string) {`
`1224`		`- markTimestamps[markName] = 0;`
`1225`		`- markCounts[markName] = 0;`
	`1226`	`+ if (delete markTimestamps[markName]) {`
	`1227`	`+ delete markCounts[markName];`
	`1228`	`+ }`
`1226`	`1229`	`}`
`1227`	`1230`
`1228`	`1231`	`/**`
`@@ -1246,13 +1249,20 @@ namespace ts {`
`1246`	`1249`	`}`
`1247`	`1250`	`}`
`1248`	`1251`
	`1252`	`+ /**`
	`1253`	`+ * Gets the names of all recorded measures.`
	`1254`	`+ */`
	`1255`	`+ export function getMeasureNames() {`
	`1256`	`+ return getKeys(measureDurations);`
	`1257`	`+ }`
	`1258`	`+`
`1249`	`1259`	`/**`
`1250`	`1260`	`* Gets the total duration of all measurements with the supplied name.`
`1251`	`1261`	`*`
`1252`	`1262`	`* @param measureName The name of the measure whose durations should be accumulated.`
`1253`	`1263`	`*/`
`1254`	`1264`	`export function getDuration(measureName: string) {`
`1255`		`- return getProperty(measureDurations, measureName) \|\| 0;`
	`1265`	`+ return enabled && getProperty(measureDurations, measureName) \|\| 0;`
`1256`	`1266`	`}`
`1257`	`1267`
`1258`	`1268`	`/**`
`@@ -1271,7 +1281,7 @@ namespace ts {`
`1271`	`1281`	`}`
`1272`	`1282`
`1273`	`1283`	`function clearMeasure(measureName: string) {`
`1274`		`- measureDurations[measureName] = 0;`
	`1284`	`+ delete measureDurations[measureName];`
`1275`	`1285`	`}`
`1276`	`1286`
`1277`	`1287`	`/**`