typescript 4.8.0-dev.20220523 → 4.8.0-dev.20220526

package/lib/typescript.js

@@ -294,7 +294,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.20220523";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220526";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -42237,7 +42237,7 @@ var ts;
         }
         if (ts.isImplicitGlob(spec.substring(spec.lastIndexOf(ts.directorySeparator) + 1))) {
             return {
-                key: useCaseSensitiveFileNames ? spec : ts.toFileNameLowerCase(spec),
+                key: ts.removeTrailingDirectorySeparator(useCaseSensitiveFileNames ? spec : ts.toFileNameLowerCase(spec)),
                 flags: 1 /* Recursive */
             };
         }
@@ -43342,16 +43342,20 @@ var ts;
     function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
         return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
     }
+    var jsOnlyExtensions = [Extensions.JavaScript];
+    var tsExtensions = [Extensions.TypeScript, Extensions.JavaScript];
+    var tsPlusJsonExtensions = __spreadArray(__spreadArray([], tsExtensions, true), [Extensions.Json], false);
+    var tsconfigExtensions = [Extensions.TSConfig];
     function nodeNextModuleNameResolverWorker(features, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
         var containingDirectory = ts.getDirectoryPath(containingFile);
         // es module file or cjs-like input file, use a variant of the legacy cjs resolver that supports the selected modern features
         var esmMode = resolutionMode === ts.ModuleKind.ESNext ? NodeResolutionFeatures.EsmMode : 0;
-        return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions, redirectedReference);
+        var extensions = compilerOptions.noDtsResolution ? [Extensions.TsOnly, Extensions.JavaScript] : tsExtensions;
+        if (compilerOptions.resolveJsonModule) {
+            extensions = __spreadArray(__spreadArray([], extensions, true), [Extensions.Json], false);
+        }
+        return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference);
     }
-    var jsOnlyExtensions = [Extensions.JavaScript];
-    var tsExtensions = [Extensions.TypeScript, Extensions.JavaScript];
-    var tsPlusJsonExtensions = __spreadArray(__spreadArray([], tsExtensions, true), [Extensions.Json], false);
-    var tsconfigExtensions = [Extensions.TSConfig];
     function tryResolveJSModuleWorker(moduleName, initialDir, host) {
         return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, /*cache*/ undefined, jsOnlyExtensions, /*redirectedReferences*/ undefined);
     }
@@ -62378,7 +62382,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 */; }
@@ -72490,7 +72494,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);
                 }
             }
@@ -72959,22 +72963,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;
@@ -75508,29 +75510,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
@@ -107455,7 +107471,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 */:
@@ -123829,6 +123845,7 @@ var ts;
         }
         function reloadFileNamesFromConfigFile() {
             writeLog("Reloading new file names and options");
+            reloadLevel = ts.ConfigFileProgramReloadLevel.None;
             rootFileNames = ts.getFileNamesFromConfigSpecs(compilerOptions.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions);
             if (ts.updateErrorForNoInputFiles(rootFileNames, ts.getNormalizedAbsolutePath(configFileName, currentDirectory), compilerOptions.configFile.configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) {
                 hasChangedConfigFileParsingErrors = true;
@@ -124286,7 +124303,6 @@ var ts;
             allProjectBuildPending: true,
             needsSummary: true,
             watchAllProjectsPending: watch,
-            currentInvalidatedProject: undefined,
             // Watch state
             watch: watch,
             allWatchedWildcardDirectories: new ts.Map(),
@@ -124519,7 +124535,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;
@@ -124870,17 +124885,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];
@@ -124913,9 +124922,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
@@ -124927,10 +124936,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) {
@@ -124941,17 +124958,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) {
@@ -125392,9 +125429,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;
@@ -125402,25 +125439,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);
@@ -125524,8 +125574,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); },
         };
     }
@@ -135278,6 +135326,7 @@ var ts;
             return kind === 131 /* AsyncKeyword */
                 || kind === 132 /* AwaitKeyword */
                 || kind === 127 /* AsKeyword */
+                || kind === 152 /* TypeKeyword */
                 || !ts.isContextualKeyword(kind) && !isClassMemberCompletionKeyword(kind);
         }
         function keywordForNode(node) {
@@ -144532,6 +144581,10 @@ var ts;
                 }
                 var typeDisplayString = printTypeInSingleLine(declarationType);
                 if (typeDisplayString) {
+                    var isVariableNameMatchesType = preferences.includeInlayVariableTypeHintsWhenTypeMatchesName === false && ts.equateStringsCaseInsensitive(decl.name.getText(), typeDisplayString);
+                    if (isVariableNameMatchesType) {
+                        return;
+                    }
                     addTypeHints(typeDisplayString, decl.name.end);
                 }
             }

package/lib/typescriptServices.d.ts

@@ -4120,6 +4120,7 @@ declare namespace ts {
         readonly includeInlayParameterNameHintsWhenArgumentMatchesName?: boolean;
         readonly includeInlayFunctionParameterTypeHints?: boolean;
         readonly includeInlayVariableTypeHints?: boolean;
+        readonly includeInlayVariableTypeHintsWhenTypeMatchesName?: boolean;
         readonly includeInlayPropertyDeclarationTypeHints?: boolean;
         readonly includeInlayFunctionLikeReturnTypeHints?: boolean;
         readonly includeInlayEnumMemberValueHints?: boolean;