typescript 4.9.0-dev.20220811 → 4.9.0-dev.20220814

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.9";
-    ts.version = ts.versionMajorMinor + ".0-dev.20220811";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220814";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -3025,6 +3025,8 @@ var ts;
             typeof performance.mark === "function" &&
             typeof performance.measure === "function" &&
             typeof performance.now === "function" &&
+            typeof performance.clearMarks === "function" &&
+            typeof performance.clearMeasures === "function" &&
             typeof PerformanceObserver === "function";
     }
     function tryGetWebPerformanceHooks() {
@@ -3062,7 +3064,9 @@ var ts;
                                 if (end === "__performance.measure-fix__") {
                                     nodePerformance_1.clearMarks("__performance.measure-fix__");
                                 }
-                            }
+                            },
+                            clearMarks: function (name) { return nodePerformance_1.clearMarks(name); },
+                            clearMeasures: function (name) { return nodePerformance_1.clearMeasures(name); },
                         };
                     }
                     return {
@@ -3157,6 +3161,30 @@ var ts;
             durations.forEach(function (duration, measureName) { return cb(measureName, duration); });
         }
         performance.forEachMeasure = forEachMeasure;
+        function forEachMark(cb) {
+            marks.forEach(function (_time, markName) { return cb(markName); });
+        }
+        performance.forEachMark = forEachMark;
+        function clearMeasures(name) {
+            if (name !== undefined)
+                durations.delete(name);
+            else
+                durations.clear();
+            performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.clearMeasures(name);
+        }
+        performance.clearMeasures = clearMeasures;
+        function clearMarks(name) {
+            if (name !== undefined) {
+                counts.delete(name);
+                marks.delete(name);
+            }
+            else {
+                counts.clear();
+                marks.clear();
+            }
+            performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.clearMarks(name);
+        }
+        performance.clearMarks = clearMarks;
         function isEnabled() {
             return enabled;
         }
@@ -61486,25 +61514,7 @@ var ts;
         }
         function getTypeOfPropertyOfContextualType(type, name, nameType) {
             return mapType(type, function (t) {
-                if (t.flags & 2097152) {
-                    var intersection = t;
-                    var newTypes = ts.mapDefined(intersection.types, getTypeOfConcretePropertyOfContextualType);
-                    if (newTypes.length > 0) {
-                        return getIntersectionType(newTypes);
-                    }
-                    newTypes = ts.mapDefined(intersection.types, getTypeOfApplicableIndexInfoOfContextualType);
-                    if (newTypes.length > 0) {
-                        return getIntersectionType(newTypes);
-                    }
-                    return undefined;
-                }
-                var concretePropertyType = getTypeOfConcretePropertyOfContextualType(t);
-                if (concretePropertyType) {
-                    return concretePropertyType;
-                }
-                return getTypeOfApplicableIndexInfoOfContextualType(t);
-            }, true);
-            function getTypeOfConcretePropertyOfContextualType(t) {
+                var _a;
                 if (isGenericMappedType(t) && !t.declaration.nameType) {
                     var constraint = getConstraintTypeFromMappedType(t);
                     var constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
@@ -61512,9 +61522,8 @@ var ts;
                     if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
                         return substituteIndexedMappedType(t, propertyNameType);
                     }
-                    return undefined;
                 }
-                if (t.flags & 3670016) {
+                else if (t.flags & 3670016) {
                     var prop = getPropertyOfType(t, name);
                     if (prop) {
                         return isCircularMappedProperty(prop) ? undefined : getTypeOfSymbol(prop);
@@ -61525,16 +61534,10 @@ var ts;
                             return restType;
                         }
                     }
+                    return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type;
                 }
                 return undefined;
-            }
-            function getTypeOfApplicableIndexInfoOfContextualType(t) {
-                var _a;
-                if (!(t.flags & 3670016)) {
-                    return undefined;
-                }
-                return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type;
-            }
+            }, true);
         }
         function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
             ts.Debug.assert(ts.isObjectLiteralMethod(node));
@@ -61847,17 +61850,13 @@ var ts;
                     var typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(intrinsicClassAttribs.symbol);
                     var hostClassType = getReturnTypeOfSignature(sig);
                     var libraryManagedAttributeType = void 0;
-                    if (typeParams && typeParams.length === 1) {
+                    if (typeParams) {
                         var inferredArgs = fillMissingTypeArguments([hostClassType], typeParams, getMinTypeArgumentCount(typeParams), ts.isInJSFile(context));
                         libraryManagedAttributeType = instantiateType(intrinsicClassAttribs, createTypeMapper(typeParams, inferredArgs));
                     }
-                    else if (typeParams)
-                        libraryManagedAttributeType = undefined;
                     else
                         libraryManagedAttributeType = intrinsicClassAttribs;
-                    if (libraryManagedAttributeType) {
-                        apparentAttributesType = intersectTypes(libraryManagedAttributeType, apparentAttributesType);
-                    }
+                    apparentAttributesType = intersectTypes(libraryManagedAttributeType, apparentAttributesType);
                 }
                 var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
                 if (!isErrorType(intrinsicAttribs)) {
@@ -104613,6 +104612,7 @@ var ts;
         if (value) {
             return isParsedCommandLine(value) ? value : undefined;
         }
+        ts.performance.mark("SolutionBuilder::beforeConfigFileParsing");
         var diagnostic;
         var parseConfigFileHost = state.parseConfigFileHost, baseCompilerOptions = state.baseCompilerOptions, baseWatchOptions = state.baseWatchOptions, extendedConfigCache = state.extendedConfigCache, host = state.host;
         var parsed;
@@ -104627,6 +104627,8 @@ var ts;
             parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = ts.noop;
         }
         configFileCache.set(configFilePath, parsed || diagnostic);
+        ts.performance.mark("SolutionBuilder::afterConfigFileParsing");
+        ts.performance.measure("SolutionBuilder::Config file parsing", "SolutionBuilder::beforeConfigFileParsing", "SolutionBuilder::afterConfigFileParsing");
         return parsed;
     }
     function resolveProjectName(state, name) {
@@ -104819,6 +104821,7 @@ var ts;
                 if (updateOutputFileStampsPending) {
                     updateOutputTimestamps(state, config, projectPath);
                 }
+                ts.performance.mark("SolutionBuilder::Timestamps only updates");
                 return doneInvalidatedProject(state, projectPath);
             }
         };
@@ -104912,6 +104915,10 @@ var ts;
             };
         function done(cancellationToken, writeFile, customTransformers) {
             executeSteps(BuildStep.Done, cancellationToken, writeFile, customTransformers);
+            if (kind === InvalidatedProjectKind.Build)
+                ts.performance.mark("SolutionBuilder::Projects built");
+            else
+                ts.performance.mark("SolutionBuilder::Bundles updated");
             return doneInvalidatedProject(state, projectPath);
         }
         function withProgramOrUndefined(action) {
@@ -105629,7 +105636,10 @@ var ts;
         if (prior !== undefined) {
             return prior;
         }
+        ts.performance.mark("SolutionBuilder::beforeUpToDateCheck");
         var actual = getUpToDateStatusWorker(state, project, resolvedPath);
+        ts.performance.mark("SolutionBuilder::afterUpToDateCheck");
+        ts.performance.measure("SolutionBuilder::Up-to-date check", "SolutionBuilder::beforeUpToDateCheck", "SolutionBuilder::afterUpToDateCheck");
         state.projectStatus.set(resolvedPath, actual);
         return actual;
     }
@@ -105756,6 +105766,13 @@ var ts;
         }
     }
     function build(state, project, cancellationToken, writeFile, getCustomTransformers, onlyReferences) {
+        ts.performance.mark("SolutionBuilder::beforeBuild");
+        var result = buildWorker(state, project, cancellationToken, writeFile, getCustomTransformers, onlyReferences);
+        ts.performance.mark("SolutionBuilder::afterBuild");
+        ts.performance.measure("SolutionBuilder::Build", "SolutionBuilder::beforeBuild", "SolutionBuilder::afterBuild");
+        return result;
+    }
+    function buildWorker(state, project, cancellationToken, writeFile, getCustomTransformers, onlyReferences) {
         var buildOrder = getBuildOrderFor(state, project, onlyReferences);
         if (!buildOrder)
             return ts.ExitStatus.InvalidProject_OutputsSkipped;
@@ -105783,6 +105800,13 @@ var ts;
                     : ts.ExitStatus.DiagnosticsPresent_OutputsSkipped;
     }
     function clean(state, project, onlyReferences) {
+        ts.performance.mark("SolutionBuilder::beforeClean");
+        var result = cleanWorker(state, project, onlyReferences);
+        ts.performance.mark("SolutionBuilder::afterClean");
+        ts.performance.measure("SolutionBuilder::Clean", "SolutionBuilder::beforeClean", "SolutionBuilder::afterClean");
+        return result;
+    }
+    function cleanWorker(state, project, onlyReferences) {
         var buildOrder = getBuildOrderFor(state, project, onlyReferences);
         if (!buildOrder)
             return ts.ExitStatus.InvalidProject_OutputsSkipped;
@@ -105853,6 +105877,14 @@ var ts;
         state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, time, state, changeDetected);
     }
     function buildNextInvalidatedProject(state, changeDetected) {
+        ts.performance.mark("SolutionBuilder::beforeBuild");
+        var buildOrder = buildNextInvalidatedProjectWorker(state, changeDetected);
+        ts.performance.mark("SolutionBuilder::afterBuild");
+        ts.performance.measure("SolutionBuilder::Build", "SolutionBuilder::beforeBuild", "SolutionBuilder::afterBuild");
+        if (buildOrder)
+            reportErrorSummary(state, buildOrder);
+    }
+    function buildNextInvalidatedProjectWorker(state, changeDetected) {
         state.timerToBuildInvalidatedProject = undefined;
         if (state.reportFileChangeDetected) {
             state.reportFileChangeDetected = false;
@@ -105882,7 +105914,7 @@ var ts;
             }
         }
         disableCache(state);
-        reportErrorSummary(state, buildOrder);
+        return buildOrder;
     }
     function watchConfigFile(state, resolved, resolvedPath, parsed) {
         if (!state.watch || state.allWatchedConfigFiles.has(resolvedPath))
@@ -105937,6 +105969,7 @@ var ts;
     function startWatching(state, buildOrder) {
         if (!state.watchAllProjectsPending)
             return;
+        ts.performance.mark("SolutionBuilder::beforeWatcherCreation");
         state.watchAllProjectsPending = false;
         for (var _i = 0, _a = getBuildOrderFromAnyBuildOrder(buildOrder); _i < _a.length; _i++) {
             var resolved = _a[_i];
@@ -105950,6 +105983,8 @@ var ts;
                 watchPackageJsonFiles(state, resolved, resolvedPath, cfg);
             }
         }
+        ts.performance.mark("SolutionBuilder::afterWatcherCreation");
+        ts.performance.measure("SolutionBuilder::Watcher creation", "SolutionBuilder::beforeWatcherCreation", "SolutionBuilder::afterWatcherCreation");
     }
     function stopWatching(state) {
         ts.clearMap(state.allWatchedConfigFiles, ts.closeFileWatcher);
@@ -106101,6 +106136,12 @@ var ts;
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
+    var StatisticType;
+    (function (StatisticType) {
+        StatisticType[StatisticType["time"] = 0] = "time";
+        StatisticType[StatisticType["count"] = 1] = "count";
+        StatisticType[StatisticType["memory"] = 2] = "memory";
+    })(StatisticType = ts.StatisticType || (ts.StatisticType = {}));
     function countLines(program) {
         var counts = getCountsMap();
         ts.forEach(program.getSourceFiles(), function (file) {
@@ -106110,14 +106151,6 @@ var ts;
         });
         return counts;
     }
-    function countNodes(program) {
-        var counts = getCountsMap();
-        ts.forEach(program.getSourceFiles(), function (file) {
-            var key = getCountKey(program, file);
-            counts.set(key, counts.get(key) + file.nodeCount);
-        });
-        return counts;
-    }
     function getCountsMap() {
         var counts = new ts.Map();
         counts.set("Library", 0);
@@ -106661,15 +106694,26 @@ var ts;
             if (reportWatchModeWithoutSysSupport(sys, reportDiagnostic))
                 return;
             var buildHost_1 = ts.createSolutionBuilderWithWatchHost(sys, undefined, reportDiagnostic, ts.createBuilderStatusReporter(sys, shouldBePretty(sys, buildOptions)), createWatchStatusReporter(sys, buildOptions));
-            updateSolutionBuilderHost(sys, cb, buildHost_1);
+            var solutionPerformance_1 = enableSolutionPerformance(sys, buildOptions);
+            updateSolutionBuilderHost(sys, cb, buildHost_1, solutionPerformance_1);
+            var onWatchStatusChange_1 = buildHost_1.onWatchStatusChange;
+            buildHost_1.onWatchStatusChange = function (d, newLine, options, errorCount) {
+                onWatchStatusChange_1 === null || onWatchStatusChange_1 === void 0 ? void 0 : onWatchStatusChange_1(d, newLine, options, errorCount);
+                if (d.code === ts.Diagnostics.Found_0_errors_Watching_for_file_changes.code ||
+                    d.code === ts.Diagnostics.Found_1_error_Watching_for_file_changes.code) {
+                    reportSolutionBuilderTimes(builder_1, solutionPerformance_1);
+                }
+            };
             var builder_1 = ts.createSolutionBuilderWithWatch(buildHost_1, projects, buildOptions, watchOptions);
             builder_1.build();
             return builder_1;
         }
         var buildHost = ts.createSolutionBuilderHost(sys, undefined, reportDiagnostic, ts.createBuilderStatusReporter(sys, shouldBePretty(sys, buildOptions)), createReportErrorSummary(sys, buildOptions));
-        updateSolutionBuilderHost(sys, cb, buildHost);
+        var solutionPerformance = enableSolutionPerformance(sys, buildOptions);
+        updateSolutionBuilderHost(sys, cb, buildHost, solutionPerformance);
         var builder = ts.createSolutionBuilder(buildHost, projects, buildOptions);
         var exitStatus = buildOptions.clean ? builder.clean() : builder.build();
+        reportSolutionBuilderTimes(builder, solutionPerformance);
         ts.dumpTracingLegend();
         return sys.exit(exitStatus);
     }
@@ -106694,7 +106738,7 @@ var ts;
         };
         var program = ts.createProgram(programOptions);
         var exitStatus = ts.emitFilesAndReportErrorsAndGetExitStatus(program, reportDiagnostic, function (s) { return sys.write(s + sys.newLine); }, createReportErrorSummary(sys, options));
-        reportStatistics(sys, program);
+        reportStatistics(sys, program, undefined);
         cb(program);
         return sys.exit(exitStatus);
     }
@@ -106712,36 +106756,36 @@ var ts;
             reportDiagnostic: reportDiagnostic,
             reportErrorSummary: createReportErrorSummary(sys, options),
             afterProgramEmitAndDiagnostics: function (builderProgram) {
-                reportStatistics(sys, builderProgram.getProgram());
+                reportStatistics(sys, builderProgram.getProgram(), undefined);
                 cb(builderProgram);
             }
         });
         return sys.exit(exitStatus);
     }
-    function updateSolutionBuilderHost(sys, cb, buildHost) {
-        updateCreateProgram(sys, buildHost);
+    function updateSolutionBuilderHost(sys, cb, buildHost, solutionPerformance) {
+        updateCreateProgram(sys, buildHost, true);
         buildHost.afterProgramEmitAndDiagnostics = function (program) {
-            reportStatistics(sys, program.getProgram());
+            reportStatistics(sys, program.getProgram(), solutionPerformance);
             cb(program);
         };
         buildHost.afterEmitBundle = cb;
     }
-    function updateCreateProgram(sys, host) {
+    function updateCreateProgram(sys, host, isBuildMode) {
         var compileUsingBuilder = host.createProgram;
         host.createProgram = function (rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences) {
             ts.Debug.assert(rootNames !== undefined || (options === undefined && !!oldProgram));
             if (options !== undefined) {
-                enableStatisticsAndTracing(sys, options, true);
+                enableStatisticsAndTracing(sys, options, isBuildMode);
             }
             return compileUsingBuilder(rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences);
         };
     }
     function updateWatchCompilationHost(sys, cb, watchCompilerHost) {
-        updateCreateProgram(sys, watchCompilerHost);
+        updateCreateProgram(sys, watchCompilerHost, false);
         var emitFilesUsingBuilder = watchCompilerHost.afterProgramCreate;
         watchCompilerHost.afterProgramCreate = function (builderProgram) {
             emitFilesUsingBuilder(builderProgram);
-            reportStatistics(sys, builderProgram.getProgram());
+            reportStatistics(sys, builderProgram.getProgram(), undefined);
             cb(builderProgram);
         };
     }
@@ -106774,6 +106818,71 @@ var ts;
         updateWatchCompilationHost(system, cb, watchCompilerHost);
         return ts.createWatchProgram(watchCompilerHost);
     }
+    function enableSolutionPerformance(system, options) {
+        if (system === ts.sys && options.extendedDiagnostics) {
+            ts.performance.enable();
+            return createSolutionPerfomrance();
+        }
+    }
+    function createSolutionPerfomrance() {
+        var statistics;
+        return {
+            addAggregateStatistic: addAggregateStatistic,
+            forEachAggregateStatistics: forEachAggreateStatistics,
+            clear: clear,
+        };
+        function addAggregateStatistic(s) {
+            var existing = statistics === null || statistics === void 0 ? void 0 : statistics.get(s.name);
+            if (existing) {
+                if (existing.type === StatisticType.memory)
+                    existing.value = Math.max(existing.value, s.value);
+                else
+                    existing.value += s.value;
+            }
+            else {
+                (statistics !== null && statistics !== void 0 ? statistics : (statistics = new ts.Map())).set(s.name, s);
+            }
+        }
+        function forEachAggreateStatistics(cb) {
+            statistics === null || statistics === void 0 ? void 0 : statistics.forEach(cb);
+        }
+        function clear() {
+            statistics = undefined;
+        }
+    }
+    function reportSolutionBuilderTimes(builder, solutionPerformance) {
+        if (!solutionPerformance)
+            return;
+        if (!ts.performance.isEnabled()) {
+            ts.sys.write(ts.Diagnostics.Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found.message + "\n");
+            return;
+        }
+        var statistics = [];
+        statistics.push({ name: "Projects in scope", value: ts.getBuildOrderFromAnyBuildOrder(builder.getBuildOrder()).length, type: StatisticType.count });
+        reportSolutionBuilderCountStatistic("SolutionBuilder::Projects built");
+        reportSolutionBuilderCountStatistic("SolutionBuilder::Timestamps only updates");
+        reportSolutionBuilderCountStatistic("SolutionBuilder::Bundles updated");
+        solutionPerformance.forEachAggregateStatistics(function (s) {
+            s.name = "Aggregate " + s.name;
+            statistics.push(s);
+        });
+        ts.performance.forEachMeasure(function (name, duration) {
+            if (isSolutionMarkOrMeasure(name))
+                statistics.push({ name: getNameFromSolutionBuilderMarkOrMeasure(name) + " time", value: duration, type: StatisticType.time });
+        });
+        ts.performance.disable();
+        ts.performance.enable();
+        reportAllStatistics(ts.sys, statistics);
+        function reportSolutionBuilderCountStatistic(name) {
+            var value = ts.performance.getCount(name);
+            if (value) {
+                statistics.push({ name: getNameFromSolutionBuilderMarkOrMeasure(name), value: value, type: StatisticType.count });
+            }
+        }
+        function getNameFromSolutionBuilderMarkOrMeasure(name) {
+            return name.replace("SolutionBuilder::", "");
+        }
+    }
     function canReportDiagnostics(system, compilerOptions) {
         return system === ts.sys && (compilerOptions.diagnostics || compilerOptions.extendedDiagnostics);
     }
@@ -106788,7 +106897,10 @@ var ts;
             ts.startTracing(isBuildMode ? "build" : "project", compilerOptions.generateTrace, compilerOptions.configFilePath);
         }
     }
-    function reportStatistics(sys, program) {
+    function isSolutionMarkOrMeasure(name) {
+        return ts.startsWith(name, "SolutionBuilder::");
+    }
+    function reportStatistics(sys, program, solutionPerformance) {
         var compilerOptions = program.getCompilerOptions();
         if (canTrace(sys, compilerOptions)) {
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.stopTracing();
@@ -106799,27 +106911,21 @@ var ts;
             var memoryUsed = sys.getMemoryUsage ? sys.getMemoryUsage() : -1;
             reportCountStatistic("Files", program.getSourceFiles().length);
             var lineCounts = countLines(program);
-            var nodeCounts = countNodes(program);
             if (compilerOptions.extendedDiagnostics) {
                 for (var _i = 0, _a = ts.arrayFrom(lineCounts.keys()); _i < _a.length; _i++) {
                     var key = _a[_i];
                     reportCountStatistic("Lines of " + key, lineCounts.get(key));
                 }
-                for (var _b = 0, _c = ts.arrayFrom(nodeCounts.keys()); _b < _c.length; _b++) {
-                    var key = _c[_b];
-                    reportCountStatistic("Nodes of " + key, nodeCounts.get(key));
-                }
             }
             else {
                 reportCountStatistic("Lines", ts.reduceLeftIterator(lineCounts.values(), function (sum, count) { return sum + count; }, 0));
-                reportCountStatistic("Nodes", ts.reduceLeftIterator(nodeCounts.values(), function (sum, count) { return sum + count; }, 0));
             }
             reportCountStatistic("Identifiers", program.getIdentifierCount());
             reportCountStatistic("Symbols", program.getSymbolCount());
             reportCountStatistic("Types", program.getTypeCount());
             reportCountStatistic("Instantiations", program.getInstantiationCount());
             if (memoryUsed >= 0) {
-                reportStatisticalValue("Memory used", Math.round(memoryUsed / 1000) + "K");
+                reportStatisticalValue({ name: "Memory used", value: memoryUsed, type: StatisticType.memory }, true);
             }
             var isPerformanceEnabled = ts.performance.isEnabled();
             var programTime = isPerformanceEnabled ? ts.performance.getDuration("Program") : 0;
@@ -106833,53 +106939,83 @@ var ts;
                 reportCountStatistic("Subtype cache size", caches.subtype);
                 reportCountStatistic("Strict subtype cache size", caches.strictSubtype);
                 if (isPerformanceEnabled) {
-                    ts.performance.forEachMeasure(function (name, duration) { return reportTimeStatistic(name + " time", duration); });
+                    ts.performance.forEachMeasure(function (name, duration) {
+                        if (!isSolutionMarkOrMeasure(name))
+                            reportTimeStatistic(name + " time", duration, true);
+                    });
                 }
             }
             else if (isPerformanceEnabled) {
-                reportTimeStatistic("I/O read", ts.performance.getDuration("I/O Read"));
-                reportTimeStatistic("I/O write", ts.performance.getDuration("I/O Write"));
-                reportTimeStatistic("Parse time", programTime);
-                reportTimeStatistic("Bind time", bindTime);
-                reportTimeStatistic("Check time", checkTime);
-                reportTimeStatistic("Emit time", emitTime);
+                reportTimeStatistic("I/O read", ts.performance.getDuration("I/O Read"), true);
+                reportTimeStatistic("I/O write", ts.performance.getDuration("I/O Write"), true);
+                reportTimeStatistic("Parse time", programTime, true);
+                reportTimeStatistic("Bind time", bindTime, true);
+                reportTimeStatistic("Check time", checkTime, true);
+                reportTimeStatistic("Emit time", emitTime, true);
             }
             if (isPerformanceEnabled) {
-                reportTimeStatistic("Total time", programTime + bindTime + checkTime + emitTime);
+                reportTimeStatistic("Total time", programTime + bindTime + checkTime + emitTime, false);
             }
-            reportStatistics();
+            reportAllStatistics(sys, statistics);
             if (!isPerformanceEnabled) {
                 sys.write(ts.Diagnostics.Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found.message + "\n");
             }
             else {
-                ts.performance.disable();
-            }
-        }
-        function reportStatistics() {
-            var nameSize = 0;
-            var valueSize = 0;
-            for (var _i = 0, statistics_1 = statistics; _i < statistics_1.length; _i++) {
-                var _a = statistics_1[_i], name = _a.name, value = _a.value;
-                if (name.length > nameSize) {
-                    nameSize = name.length;
+                if (solutionPerformance) {
+                    ts.performance.forEachMeasure(function (name) {
+                        if (!isSolutionMarkOrMeasure(name))
+                            ts.performance.clearMeasures(name);
+                    });
+                    ts.performance.forEachMark(function (name) {
+                        if (!isSolutionMarkOrMeasure(name))
+                            ts.performance.clearMarks(name);
+                    });
                 }
-                if (value.length > valueSize) {
-                    valueSize = value.length;
+                else {
+                    ts.performance.disable();
                 }
             }
-            for (var _b = 0, statistics_2 = statistics; _b < statistics_2.length; _b++) {
-                var _c = statistics_2[_b], name = _c.name, value = _c.value;
-                sys.write(ts.padRight(name + ":", nameSize + 2) + ts.padLeft(value.toString(), valueSize) + sys.newLine);
-            }
         }
-        function reportStatisticalValue(name, value) {
-            statistics.push({ name: name, value: value });
+        function reportStatisticalValue(s, aggregate) {
+            statistics.push(s);
+            if (aggregate)
+                solutionPerformance === null || solutionPerformance === void 0 ? void 0 : solutionPerformance.addAggregateStatistic(s);
         }
         function reportCountStatistic(name, count) {
-            reportStatisticalValue(name, "" + count);
+            reportStatisticalValue({ name: name, value: count, type: StatisticType.count }, true);
+        }
+        function reportTimeStatistic(name, time, aggregate) {
+            reportStatisticalValue({ name: name, value: time, type: StatisticType.time }, aggregate);
+        }
+    }
+    function reportAllStatistics(sys, statistics) {
+        var nameSize = 0;
+        var valueSize = 0;
+        for (var _i = 0, statistics_1 = statistics; _i < statistics_1.length; _i++) {
+            var s = statistics_1[_i];
+            if (s.name.length > nameSize) {
+                nameSize = s.name.length;
+            }
+            var value = statisticValue(s);
+            if (value.length > valueSize) {
+                valueSize = value.length;
+            }
+        }
+        for (var _a = 0, statistics_2 = statistics; _a < statistics_2.length; _a++) {
+            var s = statistics_2[_a];
+            sys.write(ts.padRight(s.name + ":", nameSize + 2) + ts.padLeft(statisticValue(s).toString(), valueSize) + sys.newLine);
         }
-        function reportTimeStatistic(name, time) {
-            reportStatisticalValue(name, (time / 1000).toFixed(2) + "s");
+    }
+    function statisticValue(s) {
+        switch (s.type) {
+            case StatisticType.count:
+                return "" + s.value;
+            case StatisticType.time:
+                return (s.value / 1000).toFixed(2) + "s";
+            case StatisticType.memory:
+                return Math.round(s.value / 1000) + "K";
+            default:
+                ts.Debug.assertNever(s.type);
         }
     }
     function writeConfigFile(sys, reportDiagnostic, options, fileNames) {