Add rudimentary allocation metrics

Author: amcasey

src/compiler/checker.ts

@@ -24157,27 +24157,39 @@ namespace ts {
             // signature, the subtype pass is useless. So skipping it is an optimization.
 
             if (candidates.length > 1) {
+                const oldCounts = { nextSymbolId, nextNodeId, nextMergeId, nextFlowId };
                 performance.mark("beforeChooseOverloadSubtype");
                 result = chooseOverload(candidates, subtypeRelation, signatureHelpTrailingComma);
                 performance.mark("afterChooseOverloadSubtype");
+                const newCounts = { nextSymbolId, nextNodeId, nextMergeId, nextFlowId };
                 performance.measureOverload("beforeChooseOverloadSubtype", "afterChooseOverloadSubtype", {
                     kind: "subtype",
                     nodePos: nodePosToString(node),
                     candidateCount: candidates.length,
                     symbolName: getSymbolName(result || candidates[0]),
                     succeeded: !!result,
+                    symbolCount: newCounts.nextSymbolId - oldCounts.nextSymbolId,
+                    nodeCount: newCounts.nextNodeId - oldCounts.nextNodeId,
+                    mergeCount: newCounts.nextMergeId - oldCounts.nextMergeId,
+                    flowCount: newCounts.nextFlowId - oldCounts.nextFlowId,
                 });
             }
             if (!result) {
+                const oldCounts = { nextSymbolId, nextNodeId, nextMergeId, nextFlowId };
                 performance.mark("beforeChooseOverloadAssignable");
                 result = chooseOverload(candidates, assignableRelation, signatureHelpTrailingComma);
                 performance.mark("afterChooseOverloadAssignable");
+                const newCounts = { nextSymbolId, nextNodeId, nextMergeId, nextFlowId };
                 performance.measureOverload("beforeChooseOverloadAssignable", "afterChooseOverloadAssignable", {
                     kind: "assignment",
                     nodePos: nodePosToString(node),
                     candidateCount: candidates.length,
                     symbolName: getSymbolName(result || candidates[0]),
                     succeeded: !!result,
+                    symbolCount: newCounts.nextSymbolId - oldCounts.nextSymbolId,
+                    nodeCount: newCounts.nextNodeId - oldCounts.nextNodeId,
+                    mergeCount: newCounts.nextMergeId - oldCounts.nextMergeId,
+                    flowCount: newCounts.nextFlowId - oldCounts.nextFlowId,
                 });
             }
             if (result) {

src/compiler/performance.ts

@@ -26,6 +26,10 @@ namespace ts.performance {
         nodePos: string,
         symbolName: string,
         succeeded: boolean,
+        symbolCount: number,
+        nodeCount: number,
+        mergeCount: number,
+        flowCount: number,
     }
 
     export interface ChooseOverloadMeasure extends ChooseOverloadStats {

src/tsc/executeCommandLine.ts

@@ -654,14 +654,43 @@ namespace ts {
                     candidateCount: measures[0].candidateCount,
                     count: measures.length,
                     timeMs: measures.map(m => m.timeMs).reduce((a, b) => a + b, 0),
+                    symbolCount: measures.map(m => m.symbolCount).reduce((a, b) => a + b, 0),
+                    nodeCount: measures.map(m => m.nodeCount).reduce((a, b) => a + b, 0),
+                    mergeCount: measures.map(m => m.mergeCount).reduce((a, b) => a + b, 0),
+                    flowCount: measures.map(m => m.flowCount).reduce((a, b) => a + b, 0),
                 }));
 
-                const sortedOverloadStatistics = overloadStatistics.sort((a, b) => b.timeMs - a.timeMs);
-                for (let i = 0; i < 10 && i < sortedOverloadStatistics.length; i++) {
-                    const stat = sortedOverloadStatistics[i];
-                    // sys.write(`${stat.symbolName}: ${stat.timeMs}ms (count = ${stat.count}) ${sys.newLine}`);
+                const topCount = 5;
+
+                sys.write("Top " + topCount + " by time" + sys.newLine);
+                for (const stat of takeAtMost(topCount, overloadStatistics.sort((a, b) => b.timeMs - a.timeMs))) {
+                    sys.write(JSON.stringify(stat) + sys.newLine);
+                }
+                sys.write(sys.newLine);
+
+                sys.write("Top " + topCount + " by symbols" + sys.newLine);
+                for (const stat of takeAtMost(topCount, overloadStatistics.sort((a, b) => b.symbolCount - a.symbolCount))) {
                     sys.write(JSON.stringify(stat) + sys.newLine);
                 }
+                sys.write(sys.newLine);
+
+                sys.write("Top " + topCount + " by nodes" + sys.newLine);
+                for (const stat of takeAtMost(topCount, overloadStatistics.sort((a, b) => b.nodeCount - a.nodeCount))) {
+                    sys.write(JSON.stringify(stat) + sys.newLine);
+                }
+                sys.write(sys.newLine);
+
+                sys.write("Top " + topCount + " by merges" + sys.newLine);
+                for (const stat of takeAtMost(topCount, overloadStatistics.sort((a, b) => b.mergeCount - a.mergeCount))) {
+                    sys.write(JSON.stringify(stat) + sys.newLine);
+                }
+                sys.write(sys.newLine);
+
+                sys.write("Top " + topCount + " by flows" + sys.newLine);
+                for (const stat of takeAtMost(topCount, overloadStatistics.sort((a, b) => b.flowCount - a.flowCount))) {
+                    sys.write(JSON.stringify(stat) + sys.newLine);
+                }
+                sys.write(sys.newLine);
             }
             else {
                 // Individual component times.
@@ -681,6 +710,10 @@ namespace ts {
             performance.disable();
         }
 
+        function takeAtMost<T>(count: number, array: readonly T[]): readonly T[] {
+            return array.slice(0, Math.min(array.length, count));
+        }
+
         function reportStatistics() {
             let nameSize = 0;
             let valueSize = 0;