@typescript-deploys/pr-build 4.9.0-pr-50776-2 → 4.9.0-pr-50976-13

package/lib/tsserverlibrary.js

@@ -108,7 +108,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 = "".concat(ts.versionMajorMinor, ".0-insiders.20220922");
+    ts.version = "".concat(ts.versionMajorMinor, ".0-insiders.20220929");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -3214,11 +3214,13 @@ var ts;
     // > alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty. Numeric identifiers
     // > MUST NOT include leading zeroes.
     var prereleaseRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)(?:\.(?:0|[1-9]\d*|[a-z-][a-z0-9-]*))*$/i;
+    var prereleasePartRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)$/i;
     // https://semver.org/#spec-item-10
     // > Build metadata MAY be denoted by appending a plus sign and a series of dot separated
     // > identifiers immediately following the patch or pre-release version. Identifiers MUST
     // > comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty.
     var buildRegExp = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i;
+    var buildPartRegExp = /^[a-z0-9-]+$/i;
     // https://semver.org/#spec-item-9
     // > Numeric identifiers MUST NOT include leading zeroes.
     var numericIdentifierRegExp = /^(0|[1-9]\d*)$/;
@@ -3238,13 +3240,15 @@ var ts;
             ts.Debug.assert(major >= 0, "Invalid argument: major");
             ts.Debug.assert(minor >= 0, "Invalid argument: minor");
             ts.Debug.assert(patch >= 0, "Invalid argument: patch");
-            ts.Debug.assert(!prerelease || prereleaseRegExp.test(prerelease), "Invalid argument: prerelease");
-            ts.Debug.assert(!build || buildRegExp.test(build), "Invalid argument: build");
+            var prereleaseArray = prerelease ? ts.isArray(prerelease) ? prerelease : prerelease.split(".") : ts.emptyArray;
+            var buildArray = build ? ts.isArray(build) ? build : build.split(".") : ts.emptyArray;
+            ts.Debug.assert(ts.every(prereleaseArray, function (s) { return prereleasePartRegExp.test(s); }), "Invalid argument: prerelease");
+            ts.Debug.assert(ts.every(buildArray, function (s) { return buildPartRegExp.test(s); }), "Invalid argument: build");
             this.major = major;
             this.minor = minor;
             this.patch = patch;
-            this.prerelease = prerelease ? prerelease.split(".") : ts.emptyArray;
-            this.build = build ? build.split(".") : ts.emptyArray;
+            this.prerelease = prereleaseArray;
+            this.build = buildArray;
         }
         Version.tryParse = function (text) {
             var result = tryParseComponents(text);
@@ -3283,6 +3287,10 @@ var ts;
                 default: return ts.Debug.assertNever(field);
             }
         };
+        Version.prototype.with = function (fields) {
+            var _a = fields.major, major = _a === void 0 ? this.major : _a, _b = fields.minor, minor = _b === void 0 ? this.minor : _b, _c = fields.patch, patch = _c === void 0 ? this.patch : _c, _d = fields.prerelease, prerelease = _d === void 0 ? this.prerelease : _d, _e = fields.build, build = _e === void 0 ? this.build : _e;
+            return new Version(major, minor, patch, prerelease, build);
+        };
         Version.prototype.toString = function () {
             var result = "".concat(this.major, ".").concat(this.minor, ".").concat(this.patch);
             if (ts.some(this.prerelease))
@@ -3291,7 +3299,7 @@ var ts;
                 result += "+".concat(this.build.join("."));
             return result;
         };
-        Version.zero = new Version(0, 0, 0);
+        Version.zero = new Version(0, 0, 0, ["0"]);
         return Version;
     }());
     ts.Version = Version;
@@ -3374,6 +3382,10 @@ var ts;
             }
             return undefined;
         };
+        /**
+         * Tests whether a version matches the range. This is equivalent to `satisfies(version, range, { includePrerelease: true })`.
+         * in `node-semver`.
+         */
         VersionRange.prototype.test = function (version) {
             if (typeof version === "string")
                 version = new Version(version);
@@ -3484,19 +3496,20 @@ var ts;
                     break;
                 case "<":
                 case ">=":
-                    comparators.push(createComparator(operator, version));
+                    comparators.push(isWildcard(minor) || isWildcard(patch) ? createComparator(operator, version.with({ prerelease: "0" })) :
+                        createComparator(operator, version));
                     break;
                 case "<=":
                 case ">":
-                    comparators.push(isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("major")) :
-                        isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("minor")) :
+                    comparators.push(isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("major").with({ prerelease: "0" })) :
+                        isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("minor").with({ prerelease: "0" })) :
                             createComparator(operator, version));
                     break;
                 case "=":
                 case undefined:
                     if (isWildcard(minor) || isWildcard(patch)) {
-                        comparators.push(createComparator(">=", version));
-                        comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : "minor")));
+                        comparators.push(createComparator(">=", version.with({ prerelease: "0" })));
+                        comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : "minor").with({ prerelease: "0" })));
                     }
                     else {
                         comparators.push(createComparator("=", version));
@@ -57606,16 +57619,32 @@ var ts;
                 return getTypeFromTypeNode(typeNode);
             }
         }
+        function isParameterOfContextSensitiveSignature(symbol) {
+            var decl = symbol.valueDeclaration;
+            if (!decl) {
+                return false;
+            }
+            if (ts.isBindingElement(decl)) {
+                decl = ts.walkUpBindingElementsAndPatterns(decl);
+            }
+            if (ts.isParameter(decl)) {
+                return isContextSensitiveFunctionOrObjectLiteralMethod(decl.parent);
+            }
+            return false;
+        }
         function getTypeOfVariableOrParameterOrProperty(symbol) {
             var links = getSymbolLinks(symbol);
             if (!links.type) {
                 var type = getTypeOfVariableOrParameterOrPropertyWorker(symbol);
                 // For a contextually typed parameter it is possible that a type has already
                 // been assigned (in assignTypeToParameterAndFixTypeParameters), and we want
-                // to preserve this type.
-                if (!links.type) {
+                // to preserve this type. In fact, we need to _prefer_ that type, but it won't
+                // be assigned until contextual typing is complete, so we need to defer in
+                // cases where contextual typing may take place.
+                if (!links.type && !isParameterOfContextSensitiveSignature(symbol)) {
                     links.type = type;
                 }
+                return type;
             }
             return links.type;
         }
@@ -63342,7 +63371,18 @@ var ts;
                         return accessFlags & 1 /* AccessFlags.IncludeUndefined */ ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
                     }
                     errorIfWritingToReadonlyIndex(indexInfo);
-                    return accessFlags & 1 /* AccessFlags.IncludeUndefined */ ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
+                    // When accessing an enum object with its own type,
+                    // e.g. E[E.A] for enum E { A }, undefined shouldn't
+                    // be included in the result type
+                    if ((accessFlags & 1 /* AccessFlags.IncludeUndefined */) &&
+                        !(objectType.symbol &&
+                            objectType.symbol.flags & (256 /* SymbolFlags.RegularEnum */ | 128 /* SymbolFlags.ConstEnum */) &&
+                            (indexType.symbol &&
+                                indexType.flags & 1024 /* TypeFlags.EnumLiteral */ &&
+                                getParentOfSymbol(indexType.symbol) === objectType.symbol))) {
+                        return getUnionType([indexInfo.type, undefinedType]);
+                    }
+                    return indexInfo.type;
                 }
                 if (indexType.flags & 131072 /* TypeFlags.Never */) {
                     return neverType;
@@ -66999,7 +67039,7 @@ var ts;
                         // with another type parameter unless one extends the other. (Remember: comparability is mostly bidirectional!)
                         var constraint = getConstraintOfTypeParameter(source);
                         if (constraint && hasNonCircularBaseConstraint(source)) {
-                            while (constraint && constraint.flags & 262144 /* TypeFlags.TypeParameter */) {
+                            while (constraint && someType(constraint, function (c) { return !!(c.flags & 262144 /* TypeFlags.TypeParameter */); })) {
                                 if (result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false)) {
                                     return result;
                                 }
@@ -70761,7 +70801,7 @@ var ts;
             }
             if (ts.isEntityNameExpression(node.argumentExpression)) {
                 var symbol = resolveEntityName(node.argumentExpression, 111551 /* SymbolFlags.Value */, /*ignoreErrors*/ true);
-                if (!symbol || !isConstVariable(symbol))
+                if (!symbol || !(isConstVariable(symbol) || (symbol.flags & 8 /* SymbolFlags.EnumMember */)))
                     return undefined;
                 var declaration = symbol.valueDeclaration;
                 if (declaration === undefined)
@@ -70775,7 +70815,12 @@ var ts;
                 }
                 if (ts.hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node.argumentExpression)) {
                     var initializer = ts.getEffectiveInitializer(declaration);
-                    return initializer && tryGetNameFromType(getTypeOfExpression(initializer));
+                    if (initializer) {
+                        return tryGetNameFromType(getTypeOfExpression(initializer));
+                    }
+                    if (ts.isEnumMember(declaration)) {
+                        return ts.getTextOfPropertyName(declaration.name);
+                    }
                 }
             }
             return undefined;
@@ -118839,7 +118884,7 @@ var ts;
      * Determines if program structure is upto date or needs to be recreated
      */
     /* @internal */
-    function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion, fileExists, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences) {
+    function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion, fileExists, hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences) {
         // If we haven't created a program yet or have changed automatic type directives, then it is not up-to-date
         if (!program || (hasChangedAutomaticTypeDirectiveNames === null || hasChangedAutomaticTypeDirectiveNames === void 0 ? void 0 : hasChangedAutomaticTypeDirectiveNames()))
             return false;
@@ -118867,7 +118912,7 @@ var ts;
         return true;
         function sourceFileNotUptoDate(sourceFile) {
             return !sourceFileVersionUptoDate(sourceFile) ||
-                hasInvalidatedResolution(sourceFile.path);
+                hasInvalidatedResolutions(sourceFile.path);
         }
         function sourceFileVersionUptoDate(sourceFile) {
             return sourceFile.version === getSourceVersion(sourceFile.resolvedPath, sourceFile.fileName);
@@ -119113,7 +119158,7 @@ var ts;
         var moduleResolutionCache;
         var typeReferenceDirectiveResolutionCache;
         var actualResolveModuleNamesWorker;
-        var hasInvalidatedResolution = host.hasInvalidatedResolution || ts.returnFalse;
+        var hasInvalidatedResolutions = host.hasInvalidatedResolutions || ts.returnFalse;
         if (host.resolveModuleNames) {
             actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, reusedNames, redirectedReference) { return host.resolveModuleNames(ts.Debug.checkEachDefined(moduleNames), containingFileName, reusedNames, redirectedReference, options, containingFile).map(function (resolved) {
                 // An older host may have omitted extension, in which case we should infer it from the file extension of resolvedFileName.
@@ -119560,7 +119605,7 @@ var ts;
             for (var i = 0; i < moduleNames.length; i++) {
                 var moduleName = moduleNames[i];
                 // If the source file is unchanged and doesnt have invalidated resolution, reuse the module resolutions
-                if (file === oldSourceFile && !hasInvalidatedResolution(oldSourceFile.path)) {
+                if (file === oldSourceFile && !hasInvalidatedResolutions(oldSourceFile.path)) {
                     var oldResolvedModule = ts.getResolvedModule(oldSourceFile, moduleName, getModeForResolutionAtIndex(oldSourceFile, i));
                     if (oldResolvedModule) {
                         if (ts.isTraceEnabled(options, host)) {
@@ -119796,7 +119841,7 @@ var ts;
                     // tentatively approve the file
                     modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
                 }
-                else if (hasInvalidatedResolution(oldSourceFile.path)) {
+                else if (hasInvalidatedResolutions(oldSourceFile.path)) {
                     // 'module/types' references could have changed
                     structureIsReused = 1 /* StructureIsReused.SafeModules */;
                     // add file to the modified list so that we will resolve it later
@@ -122540,10 +122585,16 @@ var ts;
         var oldCompilerOptions = useOldState ? oldState.compilerOptions : undefined;
         var canCopySemanticDiagnostics = useOldState && oldState.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile &&
             !ts.compilerOptionsAffectSemanticDiagnostics(compilerOptions, oldCompilerOptions);
+        // We can only reuse emit signatures (i.e. .d.ts signatures) if the .d.ts file is unchanged,
+        // which will eg be depedent on change in options like declarationDir and outDir options are unchanged.
+        // We need to look in oldState.compilerOptions, rather than oldCompilerOptions (i.e.we need to disregard useOldState) because
+        // oldCompilerOptions can be undefined if there was change in say module from None to some other option
+        // which would make useOldState as false since we can now use reference maps that are needed to track what to emit, what to check etc
+        // but that option change does not affect d.ts file name so emitSignatures should still be reused.
         var canCopyEmitSignatures = compilerOptions.composite &&
             (oldState === null || oldState === void 0 ? void 0 : oldState.emitSignatures) &&
             !outFilePath &&
-            !ts.compilerOptionsAffectDeclarationPath(compilerOptions, oldCompilerOptions);
+            !ts.compilerOptionsAffectDeclarationPath(compilerOptions, oldState.compilerOptions);
         if (useOldState) {
             // Copy old state's changed files set
             (_a = oldState.changedFilesSet) === null || _a === void 0 ? void 0 : _a.forEach(function (value) { return state.changedFilesSet.add(value); });
@@ -123842,7 +123893,7 @@ var ts;
             invalidateResolutionOfFile: invalidateResolutionOfFile,
             invalidateResolutionsOfFailedLookupLocations: invalidateResolutionsOfFailedLookupLocations,
             setFilesWithInvalidatedNonRelativeUnresolvedImports: setFilesWithInvalidatedNonRelativeUnresolvedImports,
-            createHasInvalidatedResolution: createHasInvalidatedResolution,
+            createHasInvalidatedResolutions: createHasInvalidatedResolutions,
             isFileWithInvalidatedNonRelativeUnresolvedImports: isFileWithInvalidatedNonRelativeUnresolvedImports,
             updateTypeRootsWatch: updateTypeRootsWatch,
             closeTypeRootsWatch: closeTypeRootsWatch,
@@ -123897,12 +123948,12 @@ var ts;
             var value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path);
             return !!value && !!value.length;
         }
-        function createHasInvalidatedResolution(userProvidedHasInvalidatedResolution) {
+        function createHasInvalidatedResolutions(customHasInvalidatedResolutions) {
             // Ensure pending resolutions are applied
             invalidateResolutionsOfFailedLookupLocations();
             var collected = filesWithInvalidatedResolutions;
             filesWithInvalidatedResolutions = undefined;
-            return function (path) { return (userProvidedHasInvalidatedResolution === null || userProvidedHasInvalidatedResolution === void 0 ? void 0 : userProvidedHasInvalidatedResolution(path)) ||
+            return function (path) { return customHasInvalidatedResolutions(path) ||
                 !!(collected === null || collected === void 0 ? void 0 : collected.has(path)) ||
                 isFileWithInvalidatedNonRelativeUnresolvedImports(path); };
         }
@@ -126283,7 +126334,10 @@ var ts;
             ts.maybeBind(host, host.getModuleResolutionCache) :
             (function () { return resolutionCache.getModuleResolutionCache(); });
         var userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
-        var userProvidedHasInvalidatedResolution = ts.maybeBind(host, host.hasInvalidatedResolution) || ts.returnTrue;
+        // All resolutions are invalid if user provided resolutions and didnt supply hasInvalidatedResolutions
+        var customHasInvalidatedResolutions = userProvidedResolution ?
+            ts.maybeBind(host, host.hasInvalidatedResolutions) || ts.returnTrue :
+            ts.returnFalse;
         builderProgram = readBuilderProgram(compilerOptions, compilerHost);
         synchronizeProgram();
         // Update the wild card directory watch
@@ -126349,10 +126403,9 @@ var ts;
                     resolutionCache.clear();
                 }
             }
-            // All resolutions are invalid if user provided resolutions
-            var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution ? userProvidedHasInvalidatedResolution : undefined);
+            var hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions);
             var _a = ts.changeCompilerHostLikeToUseCache(compilerHost, toPath), originalReadFile = _a.originalReadFile, originalFileExists = _a.originalFileExists, originalDirectoryExists = _a.originalDirectoryExists, originalCreateDirectory = _a.originalCreateDirectory, originalWriteFile = _a.originalWriteFile;
-            if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, function (fileName) { return compilerHost.fileExists(fileName); }, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+            if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, function (fileName) { return compilerHost.fileExists(fileName); }, hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
                 if (hasChangedConfigFileParsingErrors) {
                     if (reportFileChangeDetectedOnCreateProgram) {
                         reportWatchDiagnostic(ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
@@ -126365,7 +126418,7 @@ var ts;
                 if (reportFileChangeDetectedOnCreateProgram) {
                     reportWatchDiagnostic(ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
                 }
-                createNewProgram(hasInvalidatedResolution);
+                createNewProgram(hasInvalidatedResolutions);
             }
             reportFileChangeDetectedOnCreateProgram = false;
             if (host.afterProgramCreate && program !== builderProgram) {
@@ -126378,7 +126431,7 @@ var ts;
             compilerHost.writeFile = originalWriteFile;
             return builderProgram;
         }
-        function createNewProgram(hasInvalidatedResolution) {
+        function createNewProgram(hasInvalidatedResolutions) {
             // Compile the program
             writeLog("CreatingProgramWith::");
             writeLog("  roots: ".concat(JSON.stringify(rootFileNames)));
@@ -126389,7 +126442,7 @@ var ts;
             hasChangedCompilerOptions = false;
             hasChangedConfigFileParsingErrors = false;
             resolutionCache.startCachingPerDirectoryResolution();
-            compilerHost.hasInvalidatedResolution = hasInvalidatedResolution;
+            compilerHost.hasInvalidatedResolutions = hasInvalidatedResolutions;
             compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
             var oldProgram = getCurrentProgram();
             builderProgram = createProgram(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
@@ -127976,8 +128029,15 @@ var ts;
             }
             if (buildInfo.program) {
                 // If there are pending changes that are not emitted, project is out of date
+                // When there are syntax errors, changeFileSet will have list of files changed (irrespective of noEmit)
+                // But in case of semantic error we need special treatment.
+                // Checking presence of affectedFilesPendingEmit list is fast and good way to tell if there were semantic errors and file emit was blocked
+                // But if noEmit is true, affectedFilesPendingEmit will have file list even if there are no semantic errors to preserve list of files to be emitted when running with noEmit false
+                // So with noEmit set to true, check on semantic diagnostics needs to be explicit as oppose to when it is false when only files pending emit is sufficient
                 if (((_a = buildInfo.program.changeFileSet) === null || _a === void 0 ? void 0 : _a.length) ||
-                    (!project.options.noEmit && ((_b = buildInfo.program.affectedFilesPendingEmit) === null || _b === void 0 ? void 0 : _b.length))) {
+                    (!project.options.noEmit ?
+                        (_b = buildInfo.program.affectedFilesPendingEmit) === null || _b === void 0 ? void 0 : _b.length :
+                        ts.some(buildInfo.program.semanticDiagnosticsPerFile, ts.isArray))) {
                     return {
                         type: ts.UpToDateStatusType.OutOfDateBuildInfo,
                         buildInfoFile: buildInfoPath
@@ -139592,7 +139652,7 @@ var ts;
                                 break;
                             case 202 /* SyntaxKind.ImportType */:
                                 // Only check for typeof import('xyz')
-                                if (direct.isTypeOf && !direct.qualifier && isExported(direct)) {
+                                if (!isAvailableThroughGlobal && direct.isTypeOf && !direct.qualifier && isExported(direct)) {
                                     addIndirectUser(direct.getSourceFile(), /** addTransitiveDependencies */ true);
                                 }
                                 directImports.push(direct);
@@ -168754,7 +168814,7 @@ var ts;
             var rootFileNames = host.getScriptFileNames().slice();
             // Get a fresh cache of the host information
             var newSettings = host.getCompilationSettings() || getDefaultCompilerOptions();
-            var hasInvalidatedResolution = host.hasInvalidatedResolution || ts.returnFalse;
+            var hasInvalidatedResolutions = host.hasInvalidatedResolutions || ts.returnFalse;
             var hasChangedAutomaticTypeDirectiveNames = ts.maybeBind(host, host.hasChangedAutomaticTypeDirectiveNames);
             var projectReferences = (_b = host.getProjectReferences) === null || _b === void 0 ? void 0 : _b.call(host);
             var parsedCommandLines;
@@ -168785,7 +168845,7 @@ var ts;
                 },
                 onReleaseOldSourceFile: onReleaseOldSourceFile,
                 onReleaseParsedCommandLine: onReleaseParsedCommandLine,
-                hasInvalidatedResolution: hasInvalidatedResolution,
+                hasInvalidatedResolutions: hasInvalidatedResolutions,
                 hasChangedAutomaticTypeDirectiveNames: hasChangedAutomaticTypeDirectiveNames,
                 trace: ts.maybeBind(host, host.trace),
                 resolveModuleNames: ts.maybeBind(host, host.resolveModuleNames),
@@ -168825,7 +168885,7 @@ var ts;
             // as a const variable without downleveling, doesn't crash).
             var documentRegistryBucketKey = documentRegistry.getKeyForCompilationSettings(newSettings);
             // If the program is already up-to-date, we can reuse it
-            if (ts.isProgramUptoDate(program, rootFileNames, newSettings, function (_path, fileName) { return host.getScriptVersion(fileName); }, function (fileName) { return compilerHost.fileExists(fileName); }, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+            if (ts.isProgramUptoDate(program, rootFileNames, newSettings, function (_path, fileName) { return host.getScriptVersion(fileName); }, function (fileName) { return compilerHost.fileExists(fileName); }, hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
                 return;
             }
             // IMPORTANT - It is critical from this moment onward that we do not check
@@ -173700,7 +173760,7 @@ var ts;
                 ts.Debug.assert(!this.isClosed(), "Called update graph worker of closed project");
                 this.writeLog("Starting updateGraphWorker: Project: ".concat(this.getProjectName()));
                 var start = ts.timestamp();
-                this.hasInvalidatedResolution = this.resolutionCache.createHasInvalidatedResolution();
+                this.hasInvalidatedResolutions = this.resolutionCache.createHasInvalidatedResolutions(ts.returnFalse);
                 this.resolutionCache.startCachingPerDirectoryResolution();
                 this.program = this.languageService.getProgram(); // TODO: GH#18217
                 this.dirty = false;
@@ -175691,18 +175751,20 @@ var ts;
                 return ensureProject ? this.ensureDefaultProjectForFile(fileName) : this.tryGetDefaultProjectForFile(fileName);
             };
             /* @internal */
-            ProjectService.prototype.tryGetDefaultProjectForFile = function (fileName) {
-                var scriptInfo = this.getScriptInfoForNormalizedPath(fileName);
+            ProjectService.prototype.tryGetDefaultProjectForFile = function (fileNameOrScriptInfo) {
+                var scriptInfo = ts.isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo;
                 return scriptInfo && !scriptInfo.isOrphan() ? scriptInfo.getDefaultProject() : undefined;
             };
             /* @internal */
-            ProjectService.prototype.ensureDefaultProjectForFile = function (fileName) {
-                return this.tryGetDefaultProjectForFile(fileName) || this.doEnsureDefaultProjectForFile(fileName);
+            ProjectService.prototype.ensureDefaultProjectForFile = function (fileNameOrScriptInfo) {
+                return this.tryGetDefaultProjectForFile(fileNameOrScriptInfo) || this.doEnsureDefaultProjectForFile(fileNameOrScriptInfo);
             };
-            ProjectService.prototype.doEnsureDefaultProjectForFile = function (fileName) {
+            ProjectService.prototype.doEnsureDefaultProjectForFile = function (fileNameOrScriptInfo) {
                 this.ensureProjectStructuresUptoDate();
-                var scriptInfo = this.getScriptInfoForNormalizedPath(fileName);
-                return scriptInfo ? scriptInfo.getDefaultProject() : (this.logErrorForScriptInfoNotFound(fileName), server.Errors.ThrowNoProject());
+                var scriptInfo = ts.isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo;
+                return scriptInfo ?
+                    scriptInfo.getDefaultProject() :
+                    (this.logErrorForScriptInfoNotFound(ts.isString(fileNameOrScriptInfo) ? fileNameOrScriptInfo : fileNameOrScriptInfo.fileName), server.Errors.ThrowNoProject());
             };
             ProjectService.prototype.getScriptInfoEnsuringProjectsUptoDate = function (uncheckedFileName) {
                 this.ensureProjectStructuresUptoDate();
@@ -177874,7 +177936,7 @@ var ts;
                 if (this.serverMode !== ts.LanguageServiceMode.Semantic || !this.eventHandler || !scriptInfo.isJavaScript() || !ts.addToSeen(this.allJsFilesForOpenFileTelemetry, scriptInfo.path)) {
                     return;
                 }
-                var project = scriptInfo.getDefaultProject();
+                var project = this.ensureDefaultProjectForFile(scriptInfo);
                 if (!project.languageServiceEnabled) {
                     return;
                 }
@@ -180474,6 +180536,10 @@ var ts;
                         this.projectService.logErrorForScriptInfoNotFound(args.file);
                         return server.Errors.ThrowNoProject();
                     }
+                    else if (!getScriptInfoEnsuringProjectsUptoDate) {
+                        // Ensure there are containing projects are present
+                        this.projectService.ensureDefaultProjectForFile(scriptInfo);
+                    }
                     projects = scriptInfo.containingProjects;
                     symLinkedProjects = this.projectService.getSymlinkedProjects(scriptInfo);
                 }
@@ -180600,13 +180666,7 @@ var ts;
                 return this.getFileAndProjectWorker(args.file, args.projectFileName);
             };
             Session.prototype.getFileAndLanguageServiceForSyntacticOperation = function (args) {
-                // Since this is syntactic operation, there should always be project for the file
-                // throw if we dont get project
-                var file = server.toNormalizedPath(args.file);
-                var project = this.getProject(args.projectFileName) || this.projectService.ensureDefaultProjectForFile(file);
-                if (!project) {
-                    return server.Errors.ThrowNoProject();
-                }
+                var _a = this.getFileAndProject(args), file = _a.file, project = _a.project;
                 return {
                     file: file,
                     languageService: project.getLanguageService(/*ensureSynchronized*/ false)

package/lib/typescript.d.ts

@@ -3320,7 +3320,8 @@ declare namespace ts {
          */
         resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[] | readonly FileReference[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingFileMode?: SourceFile["impliedNodeFormat"] | undefined): (ResolvedTypeReferenceDirective | undefined)[];
         getEnvironmentVariable?(name: string): string | undefined;
-        hasInvalidatedResolution?(filePath: Path): boolean;
+        /** If provided along with custom resolveModuleNames or resolveTypeReferenceDirectives, used to determine if unchanged file path needs to re-resolve modules/type reference directives */
+        hasInvalidatedResolutions?(filePath: Path): boolean;
         createHash?(data: string): string;
         getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
     }
@@ -5444,7 +5445,7 @@ declare namespace ts {
         /** If provided, used to resolve type reference directives, otherwise typescript's default resolution */
         resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[] | readonly FileReference[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingFileMode?: SourceFile["impliedNodeFormat"] | undefined): (ResolvedTypeReferenceDirective | undefined)[];
         /** If provided along with custom resolveModuleNames or resolveTypeReferenceDirectives, used to determine if unchanged file path needs to re-resolve modules/type reference directives */
-        hasInvalidatedResolution?(filePath: Path): boolean;
+        hasInvalidatedResolutions?(filePath: Path): boolean;
         /**
          * Returns the module resolution cache used by a provided `resolveModuleNames` implementation so that any non-name module resolution operations (eg, package.json lookup) can reuse it
          */