typescript 4.8.0-dev.20220522 → 4.8.0-dev.20220525

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.8";
-    ts.version = ts.versionMajorMinor + ".0-dev.20220522";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220525";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -51631,7 +51631,7 @@ var ts;
         function substituteIndexedMappedType(objectType, index) {
             var mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
             var templateMapper = combineTypeMappers(objectType.mapper, mapper);
-            return instantiateType(getTemplateTypeFromMappedType(objectType), templateMapper);
+            return instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
         }
         function getIndexedAccessType(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) {
             if (accessFlags === void 0) { accessFlags = 0; }
@@ -60320,7 +60320,7 @@ var ts;
                 if (result) {
                     return result;
                 }
-                if (!(contextFlags & 8) && ts.isBindingPattern(declaration.name)) {
+                if (!(contextFlags & 8) && ts.isBindingPattern(declaration.name) && declaration.name.elements.length > 0) {
                     return getTypeFromBindingPattern(declaration.name, true, false);
                 }
             }
@@ -60737,16 +60737,14 @@ var ts;
         function instantiateContextualType(contextualType, node, contextFlags) {
             if (contextualType && maybeTypeOfKind(contextualType, 465829888)) {
                 var inferenceContext = getInferenceContext(node);
-                if (inferenceContext && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
-                    if (contextFlags && contextFlags & 1) {
-                        return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
-                    }
-                    if (inferenceContext.returnMapper) {
-                        var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
-                        return type.flags & 1048576 && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
-                            filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
-                            type;
-                    }
+                if (inferenceContext && contextFlags & 1 && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
+                    return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+                }
+                if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnMapper) {
+                    var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+                    return type.flags & 1048576 && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
+                        filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
+                        type;
                 }
             }
             return contextualType;
@@ -62900,18 +62898,22 @@ var ts;
                 return inferJsxTypeArguments(node, signature, checkMode, context);
             }
             if (node.kind !== 165) {
-                var contextualType = getContextualType(node, ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }) ? 8 : 0);
+                var skipBindingPatterns = ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); });
+                var contextualType = getContextualType(node, skipBindingPatterns ? 8 : 0);
                 if (contextualType) {
                     var inferenceTargetType = getReturnTypeOfSignature(signature);
                     if (couldContainTypeVariables(inferenceTargetType)) {
                         var outerContext = getInferenceContext(node);
-                        var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1));
-                        var instantiatedType = instantiateType(contextualType, outerMapper);
-                        var contextualSignature = getSingleCallSignature(instantiatedType);
-                        var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
-                            getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
-                            instantiatedType;
-                        inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128);
+                        var isFromBindingPattern = !skipBindingPatterns && getContextualType(node, 8) !== contextualType;
+                        if (!isFromBindingPattern) {
+                            var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1));
+                            var instantiatedType = instantiateType(contextualType, outerMapper);
+                            var contextualSignature = getSingleCallSignature(instantiatedType);
+                            var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
+                                getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
+                                instantiatedType;
+                            inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128);
+                        }
                         var returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
                         var returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
                         inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
@@ -87835,7 +87837,7 @@ var ts;
         function visitor(node) {
             switch (node.kind) {
                 case 265:
-                    return ts.getEmitScriptTarget(compilerOptions) >= ts.ModuleKind.ES2020 ? visitImportEqualsDeclaration(node) : undefined;
+                    return ts.getEmitModuleKind(compilerOptions) >= ts.ModuleKind.Node16 ? visitImportEqualsDeclaration(node) : undefined;
                 case 271:
                     return visitExportAssignment(node);
                 case 272:
@@ -102742,7 +102744,6 @@ var ts;
             allProjectBuildPending: true,
             needsSummary: true,
             watchAllProjectsPending: watch,
-            currentInvalidatedProject: undefined,
             watch: watch,
             allWatchedWildcardDirectories: new ts.Map(),
             allWatchedInputFiles: new ts.Map(),
@@ -102967,7 +102968,6 @@ var ts;
     })(InvalidatedProjectKind = ts.InvalidatedProjectKind || (ts.InvalidatedProjectKind = {}));
     function doneInvalidatedProject(state, projectPath) {
         state.projectPendingBuild.delete(projectPath);
-        state.currentInvalidatedProject = undefined;
         return state.diagnostics.has(projectPath) ?
             ts.ExitStatus.DiagnosticsPresent_OutputsSkipped :
             ts.ExitStatus.Success;
@@ -103302,16 +103302,11 @@ var ts;
             !!ts.getConfigFileParsingDiagnostics(config).length ||
             !ts.isIncrementalCompilation(config.options);
     }
-    function getNextInvalidatedProject(state, buildOrder, reportQueue) {
+    function getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue) {
         if (!state.projectPendingBuild.size)
             return undefined;
         if (isCircularBuildOrder(buildOrder))
             return undefined;
-        if (state.currentInvalidatedProject) {
-            return ts.arrayIsEqualTo(state.currentInvalidatedProject.buildOrder, buildOrder) ?
-                state.currentInvalidatedProject :
-                undefined;
-        }
         var options = state.options, projectPendingBuild = state.projectPendingBuild;
         for (var projectIndex = 0; projectIndex < buildOrder.length; projectIndex++) {
             var project = buildOrder[projectIndex];
@@ -103343,9 +103338,9 @@ var ts;
                 watchPackageJsonFiles(state, project, projectPath, config);
             }
             var status = getUpToDateStatus(state, config, projectPath);
-            verboseReportProjectStatus(state, project, status);
             if (!options.force) {
                 if (status.type === ts.UpToDateStatusType.UpToDate) {
+                    verboseReportProjectStatus(state, project, status);
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                     projectPendingBuild.delete(projectPath);
                     if (options.dry) {
@@ -103355,10 +103350,18 @@ var ts;
                 }
                 if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes) {
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
-                    return createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder);
+                    return {
+                        kind: InvalidatedProjectKind.UpdateOutputFileStamps,
+                        status: status,
+                        project: project,
+                        projectPath: projectPath,
+                        projectIndex: projectIndex,
+                        config: config
+                    };
                 }
             }
             if (status.type === ts.UpToDateStatusType.UpstreamBlocked) {
+                verboseReportProjectStatus(state, project, status);
                 reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                 projectPendingBuild.delete(projectPath);
                 if (options.verbose) {
@@ -103369,16 +103372,36 @@ var ts;
                 continue;
             }
             if (status.type === ts.UpToDateStatusType.ContainerOnly) {
+                verboseReportProjectStatus(state, project, status);
                 reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                 projectPendingBuild.delete(projectPath);
                 continue;
             }
-            return createBuildOrUpdateInvalidedProject(needsBuild(state, status, config) ?
-                InvalidatedProjectKind.Build :
-                InvalidatedProjectKind.UpdateBundle, state, project, projectPath, projectIndex, config, buildOrder);
+            return {
+                kind: needsBuild(state, status, config) ?
+                    InvalidatedProjectKind.Build :
+                    InvalidatedProjectKind.UpdateBundle,
+                status: status,
+                project: project,
+                projectPath: projectPath,
+                projectIndex: projectIndex,
+                config: config,
+            };
         }
         return undefined;
     }
+    function createInvalidatedProjectWithInfo(state, info, buildOrder) {
+        verboseReportProjectStatus(state, info.project, info.status);
+        return info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps ?
+            createBuildOrUpdateInvalidedProject(info.kind, state, info.project, info.projectPath, info.projectIndex, info.config, buildOrder) :
+            createUpdateOutputFileStampsProject(state, info.project, info.projectPath, info.config, buildOrder);
+    }
+    function getNextInvalidatedProject(state, buildOrder, reportQueue) {
+        var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue);
+        if (!info)
+            return info;
+        return createInvalidatedProjectWithInfo(state, info, buildOrder);
+    }
     function listEmittedFile(_a, proj, file) {
         var write = _a.write;
         if (write && proj.options.listEmittedFiles) {
@@ -103782,9 +103805,9 @@ var ts;
     function invalidateProjectAndScheduleBuilds(state, resolvedPath, reloadLevel) {
         state.reportFileChangeDetected = true;
         invalidateProject(state, resolvedPath, reloadLevel);
-        scheduleBuildInvalidatedProject(state);
+        scheduleBuildInvalidatedProject(state, 250, true);
     }
-    function scheduleBuildInvalidatedProject(state) {
+    function scheduleBuildInvalidatedProject(state, time, changeDetected) {
         var hostWithWatch = state.hostWithWatch;
         if (!hostWithWatch.setTimeout || !hostWithWatch.clearTimeout) {
             return;
@@ -103792,24 +103815,35 @@ var ts;
         if (state.timerToBuildInvalidatedProject) {
             hostWithWatch.clearTimeout(state.timerToBuildInvalidatedProject);
         }
-        state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, 250, state);
+        state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, time, state, changeDetected);
     }
-    function buildNextInvalidatedProject(state) {
+    function buildNextInvalidatedProject(state, changeDetected) {
         state.timerToBuildInvalidatedProject = undefined;
         if (state.reportFileChangeDetected) {
             state.reportFileChangeDetected = false;
             state.projectErrorsReported.clear();
             reportWatchStatus(state, ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
         }
+        var projectsBuilt = 0;
         var buildOrder = getBuildOrder(state);
         var invalidatedProject = getNextInvalidatedProject(state, buildOrder, false);
         if (invalidatedProject) {
             invalidatedProject.done();
-            if (state.projectPendingBuild.size) {
-                if (state.watch && !state.timerToBuildInvalidatedProject) {
-                    scheduleBuildInvalidatedProject(state);
+            projectsBuilt++;
+            while (state.projectPendingBuild.size) {
+                if (state.timerToBuildInvalidatedProject)
+                    return;
+                var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, false);
+                if (!info)
+                    break;
+                if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps && (changeDetected || projectsBuilt === 5)) {
+                    scheduleBuildInvalidatedProject(state, 100, false);
+                    return;
                 }
-                return;
+                var project = createInvalidatedProjectWithInfo(state, info, buildOrder);
+                project.done();
+                if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps)
+                    projectsBuilt++;
             }
         }
         disableCache(state);
@@ -103909,8 +103943,6 @@ var ts;
                 return getUpToDateStatus(state, parseConfigFile(state, configFileName, configFilePath), configFilePath);
             },
             invalidateProject: function (configFilePath, reloadLevel) { return invalidateProject(state, configFilePath, reloadLevel || ts.ConfigFileProgramReloadLevel.None); },
-            buildNextInvalidatedProject: function () { return buildNextInvalidatedProject(state); },
-            getAllParsedConfigs: function () { return ts.arrayFrom(ts.mapDefinedIterator(state.configFileCache.values(), function (config) { return isParsedCommandLine(config) ? config : undefined; })); },
             close: function () { return stopWatching(state); },
         };
     }

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220522";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220525";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -62184,7 +62184,7 @@ var ts;
         function substituteIndexedMappedType(objectType, index) {
             var mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
             var templateMapper = combineTypeMappers(objectType.mapper, mapper);
-            return instantiateType(getTemplateTypeFromMappedType(objectType), templateMapper);
+            return instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
         }
         function getIndexedAccessType(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) {
             if (accessFlags === void 0) { accessFlags = 0 /* None */; }
@@ -72296,7 +72296,7 @@ var ts;
                 if (result) {
                     return result;
                 }
-                if (!(contextFlags & 8 /* SkipBindingPatterns */) && ts.isBindingPattern(declaration.name)) { // This is less a contextual type and more an implied shape - in some cases, this may be undesirable
+                if (!(contextFlags & 8 /* SkipBindingPatterns */) && ts.isBindingPattern(declaration.name) && declaration.name.elements.length > 0) {
                     return getTypeFromBindingPattern(declaration.name, /*includePatternInType*/ true, /*reportErrors*/ false);
                 }
             }
@@ -72765,22 +72765,20 @@ var ts;
                 var inferenceContext = getInferenceContext(node);
                 // If no inferences have been made, nothing is gained from instantiating as type parameters
                 // would just be replaced with their defaults similar to the apparent type.
-                if (inferenceContext && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
+                if (inferenceContext && contextFlags & 1 /* Signature */ && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
                     // For contextual signatures we incorporate all inferences made so far, e.g. from return
                     // types as well as arguments to the left in a function call.
-                    if (contextFlags && contextFlags & 1 /* Signature */) {
-                        return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
-                    }
+                    return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+                }
+                if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnMapper) {
                     // For other purposes (e.g. determining whether to produce literal types) we only
                     // incorporate inferences made from the return type in a function call. We remove
                     // the 'boolean' type from the contextual type such that contextually typed boolean
                     // literals actually end up widening to 'boolean' (see #48363).
-                    if (inferenceContext.returnMapper) {
-                        var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
-                        return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
-                            filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
-                            type;
-                    }
+                    var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+                    return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
+                        filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
+                        type;
                 }
             }
             return contextualType;
@@ -75314,29 +75312,43 @@ var ts;
             // 'let f: (x: string) => number = wrap(s => s.length)', we infer from the declared type of 'f' to the
             // return type of 'wrap'.
             if (node.kind !== 165 /* Decorator */) {
-                var contextualType = getContextualType(node, ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }) ? 8 /* SkipBindingPatterns */ : 0 /* None */);
+                var skipBindingPatterns = ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); });
+                var contextualType = getContextualType(node, skipBindingPatterns ? 8 /* SkipBindingPatterns */ : 0 /* None */);
                 if (contextualType) {
                     var inferenceTargetType = getReturnTypeOfSignature(signature);
                     if (couldContainTypeVariables(inferenceTargetType)) {
-                        // We clone the inference context to avoid disturbing a resolution in progress for an
-                        // outer call expression. Effectively we just want a snapshot of whatever has been
-                        // inferred for any outer call expression so far.
                         var outerContext = getInferenceContext(node);
-                        var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
-                        var instantiatedType = instantiateType(contextualType, outerMapper);
-                        // If the contextual type is a generic function type with a single call signature, we
-                        // instantiate the type with its own type parameters and type arguments. This ensures that
-                        // the type parameters are not erased to type any during type inference such that they can
-                        // be inferred as actual types from the contextual type. For example:
-                        //   declare function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[];
-                        //   const boxElements: <A>(a: A[]) => { value: A }[] = arrayMap(value => ({ value }));
-                        // Above, the type of the 'value' parameter is inferred to be 'A'.
-                        var contextualSignature = getSingleCallSignature(instantiatedType);
-                        var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
-                            getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
-                            instantiatedType;
-                        // Inferences made from return types have lower priority than all other inferences.
-                        inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+                        var isFromBindingPattern = !skipBindingPatterns && getContextualType(node, 8 /* SkipBindingPatterns */) !== contextualType;
+                        // A return type inference from a binding pattern can be used in instantiating the contextual
+                        // type of an argument later in inference, but cannot stand on its own as the final return type.
+                        // It is incorporated into `context.returnMapper` which is used in `instantiateContextualType`,
+                        // but doesn't need to go into `context.inferences`. This allows a an array binding pattern to
+                        // produce a tuple for `T` in
+                        //   declare function f<T>(cb: () => T): T;
+                        //   const [e1, e2, e3] = f(() => [1, "hi", true]);
+                        // but does not produce any inference for `T` in
+                        //   declare function f<T>(): T;
+                        //   const [e1, e2, e3] = f();
+                        if (!isFromBindingPattern) {
+                            // We clone the inference context to avoid disturbing a resolution in progress for an
+                            // outer call expression. Effectively we just want a snapshot of whatever has been
+                            // inferred for any outer call expression so far.
+                            var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
+                            var instantiatedType = instantiateType(contextualType, outerMapper);
+                            // If the contextual type is a generic function type with a single call signature, we
+                            // instantiate the type with its own type parameters and type arguments. This ensures that
+                            // the type parameters are not erased to type any during type inference such that they can
+                            // be inferred as actual types from the contextual type. For example:
+                            //   declare function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[];
+                            //   const boxElements: <A>(a: A[]) => { value: A }[] = arrayMap(value => ({ value }));
+                            // Above, the type of the 'value' parameter is inferred to be 'A'.
+                            var contextualSignature = getSingleCallSignature(instantiatedType);
+                            var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
+                                getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
+                                instantiatedType;
+                            // Inferences made from return types have lower priority than all other inferences.
+                            inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+                        }
                         // Create a type mapper for instantiating generic contextual types using the inferences made
                         // from the return type. We need a separate inference pass here because (a) instantiation of
                         // the source type uses the outer context's return mapper (which excludes inferences made from
@@ -107261,7 +107273,7 @@ var ts;
                     // Though an error in es2020 modules, in node-flavor es2020 modules, we can helpfully transform this to a synthetic `require` call
                     // To give easy access to a synchronous `require` in node-flavor esm. We do the transform even in scenarios where we error, but `import.meta.url`
                     // is available, just because the output is reasonable for a node-like runtime.
-                    return ts.getEmitScriptTarget(compilerOptions) >= ts.ModuleKind.ES2020 ? visitImportEqualsDeclaration(node) : undefined;
+                    return ts.getEmitModuleKind(compilerOptions) >= ts.ModuleKind.Node16 ? visitImportEqualsDeclaration(node) : undefined;
                 case 271 /* ExportAssignment */:
                     return visitExportAssignment(node);
                 case 272 /* ExportDeclaration */:
@@ -124092,7 +124104,6 @@ var ts;
             allProjectBuildPending: true,
             needsSummary: true,
             watchAllProjectsPending: watch,
-            currentInvalidatedProject: undefined,
             // Watch state
             watch: watch,
             allWatchedWildcardDirectories: new ts.Map(),
@@ -124325,7 +124336,6 @@ var ts;
     })(InvalidatedProjectKind = ts.InvalidatedProjectKind || (ts.InvalidatedProjectKind = {}));
     function doneInvalidatedProject(state, projectPath) {
         state.projectPendingBuild.delete(projectPath);
-        state.currentInvalidatedProject = undefined;
         return state.diagnostics.has(projectPath) ?
             ts.ExitStatus.DiagnosticsPresent_OutputsSkipped :
             ts.ExitStatus.Success;
@@ -124676,17 +124686,11 @@ var ts;
             !!ts.getConfigFileParsingDiagnostics(config).length ||
             !ts.isIncrementalCompilation(config.options);
     }
-    function getNextInvalidatedProject(state, buildOrder, reportQueue) {
+    function getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue) {
         if (!state.projectPendingBuild.size)
             return undefined;
         if (isCircularBuildOrder(buildOrder))
             return undefined;
-        if (state.currentInvalidatedProject) {
-            // Only if same buildOrder the currentInvalidated project can be sent again
-            return ts.arrayIsEqualTo(state.currentInvalidatedProject.buildOrder, buildOrder) ?
-                state.currentInvalidatedProject :
-                undefined;
-        }
         var options = state.options, projectPendingBuild = state.projectPendingBuild;
         for (var projectIndex = 0; projectIndex < buildOrder.length; projectIndex++) {
             var project = buildOrder[projectIndex];
@@ -124719,9 +124723,9 @@ var ts;
                 watchPackageJsonFiles(state, project, projectPath, config);
             }
             var status = getUpToDateStatus(state, config, projectPath);
-            verboseReportProjectStatus(state, project, status);
             if (!options.force) {
                 if (status.type === ts.UpToDateStatusType.UpToDate) {
+                    verboseReportProjectStatus(state, project, status);
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                     projectPendingBuild.delete(projectPath);
                     // Up to date, skip
@@ -124733,10 +124737,18 @@ var ts;
                 }
                 if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes) {
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
-                    return createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder);
+                    return {
+                        kind: InvalidatedProjectKind.UpdateOutputFileStamps,
+                        status: status,
+                        project: project,
+                        projectPath: projectPath,
+                        projectIndex: projectIndex,
+                        config: config
+                    };
                 }
             }
             if (status.type === ts.UpToDateStatusType.UpstreamBlocked) {
+                verboseReportProjectStatus(state, project, status);
                 reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                 projectPendingBuild.delete(projectPath);
                 if (options.verbose) {
@@ -124747,17 +124759,37 @@ var ts;
                 continue;
             }
             if (status.type === ts.UpToDateStatusType.ContainerOnly) {
+                verboseReportProjectStatus(state, project, status);
                 reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                 projectPendingBuild.delete(projectPath);
                 // Do nothing
                 continue;
             }
-            return createBuildOrUpdateInvalidedProject(needsBuild(state, status, config) ?
-                InvalidatedProjectKind.Build :
-                InvalidatedProjectKind.UpdateBundle, state, project, projectPath, projectIndex, config, buildOrder);
+            return {
+                kind: needsBuild(state, status, config) ?
+                    InvalidatedProjectKind.Build :
+                    InvalidatedProjectKind.UpdateBundle,
+                status: status,
+                project: project,
+                projectPath: projectPath,
+                projectIndex: projectIndex,
+                config: config,
+            };
         }
         return undefined;
     }
+    function createInvalidatedProjectWithInfo(state, info, buildOrder) {
+        verboseReportProjectStatus(state, info.project, info.status);
+        return info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps ?
+            createBuildOrUpdateInvalidedProject(info.kind, state, info.project, info.projectPath, info.projectIndex, info.config, buildOrder) :
+            createUpdateOutputFileStampsProject(state, info.project, info.projectPath, info.config, buildOrder);
+    }
+    function getNextInvalidatedProject(state, buildOrder, reportQueue) {
+        var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue);
+        if (!info)
+            return info;
+        return createInvalidatedProjectWithInfo(state, info, buildOrder);
+    }
     function listEmittedFile(_a, proj, file) {
         var write = _a.write;
         if (write && proj.options.listEmittedFiles) {
@@ -125198,9 +125230,9 @@ var ts;
     function invalidateProjectAndScheduleBuilds(state, resolvedPath, reloadLevel) {
         state.reportFileChangeDetected = true;
         invalidateProject(state, resolvedPath, reloadLevel);
-        scheduleBuildInvalidatedProject(state);
+        scheduleBuildInvalidatedProject(state, 250, /*changeDetected*/ true);
     }
-    function scheduleBuildInvalidatedProject(state) {
+    function scheduleBuildInvalidatedProject(state, time, changeDetected) {
         var hostWithWatch = state.hostWithWatch;
         if (!hostWithWatch.setTimeout || !hostWithWatch.clearTimeout) {
             return;
@@ -125208,25 +125240,38 @@ var ts;
         if (state.timerToBuildInvalidatedProject) {
             hostWithWatch.clearTimeout(state.timerToBuildInvalidatedProject);
         }
-        state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, 250, state);
+        state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, time, state, changeDetected);
     }
-    function buildNextInvalidatedProject(state) {
+    function buildNextInvalidatedProject(state, changeDetected) {
         state.timerToBuildInvalidatedProject = undefined;
         if (state.reportFileChangeDetected) {
             state.reportFileChangeDetected = false;
             state.projectErrorsReported.clear();
             reportWatchStatus(state, ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
         }
+        var projectsBuilt = 0;
         var buildOrder = getBuildOrder(state);
         var invalidatedProject = getNextInvalidatedProject(state, buildOrder, /*reportQueue*/ false);
         if (invalidatedProject) {
             invalidatedProject.done();
-            if (state.projectPendingBuild.size) {
-                // Schedule next project for build
-                if (state.watch && !state.timerToBuildInvalidatedProject) {
-                    scheduleBuildInvalidatedProject(state);
+            projectsBuilt++;
+            while (state.projectPendingBuild.size) {
+                // If already scheduled, skip
+                if (state.timerToBuildInvalidatedProject)
+                    return;
+                // Before scheduling check if the next project needs build
+                var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, /*reportQueue*/ false);
+                if (!info)
+                    break; // Nothing to build any more
+                if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps && (changeDetected || projectsBuilt === 5)) {
+                    // Schedule next project for build
+                    scheduleBuildInvalidatedProject(state, 100, /*changeDetected*/ false);
+                    return;
                 }
-                return;
+                var project = createInvalidatedProjectWithInfo(state, info, buildOrder);
+                project.done();
+                if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps)
+                    projectsBuilt++;
             }
         }
         disableCache(state);
@@ -125330,8 +125375,6 @@ var ts;
                 return getUpToDateStatus(state, parseConfigFile(state, configFileName, configFilePath), configFilePath);
             },
             invalidateProject: function (configFilePath, reloadLevel) { return invalidateProject(state, configFilePath, reloadLevel || ts.ConfigFileProgramReloadLevel.None); },
-            buildNextInvalidatedProject: function () { return buildNextInvalidatedProject(state); },
-            getAllParsedConfigs: function () { return ts.arrayFrom(ts.mapDefinedIterator(state.configFileCache.values(), function (config) { return isParsedCommandLine(config) ? config : undefined; })); },
             close: function () { return stopWatching(state); },
         };
     }
@@ -134667,6 +134710,7 @@ var ts;
             return kind === 131 /* AsyncKeyword */
                 || kind === 132 /* AwaitKeyword */
                 || kind === 127 /* AsKeyword */
+                || kind === 152 /* TypeKeyword */
                 || !ts.isContextualKeyword(kind) && !isClassMemberCompletionKeyword(kind);
         }
         function keywordForNode(node) {