rootDirForResolution: string;

resolvedModuleNames: Map<Path, ModeAwareCache<CachedResolvedModuleWithFailedLookupLocations>>;

resolvedTypeReferenceDirectives: Map<Path, ModeAwareCache<CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations>>;

resolvedLibraries: Map<string, CachedResolvedModuleWithFailedLookupLocations>;

resolvedFileToResolution: Map<Path, Set<ResolutionWithFailedLookupLocations>>;

resolutionsWithFailedLookups: Set<ResolutionWithFailedLookupLocations>;

resolutionsWithOnlyAffectingLocations: Set<ResolutionWithFailedLookupLocations>;

directoryWatchesOfFailedLookups: Map<string, DirectoryWatchesOfFailedLookup>;

fileWatchesOfAffectingLocations: Map<string, FileWatcherOfAffectingLocation>;

packageDirWatchers: Map<Path, PackageDirWatcher>;

dirPathToSymlinkPackageRefCount: Map<Path, number>;

startRecordingFilesWithChangedResolutions(): void;

finishRecordingFilesWithChangedResolutions(): Path[] | undefined;

watchFailedLookupLocationsOfExternalModuleResolutions<T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName>(

name: string,

resolution: T,

filePath: Path,

getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>,

deferWatchingNonRelativeResolution: boolean,

): void;

resolveModuleNameLiterals(

moduleLiterals: readonly StringLiteralLike[],

containingFile: string,

redirectedReference: ResolvedProjectReference | undefined,

options: CompilerOptions,

containingSourceFile: SourceFile,

reusedNames: readonly StringLiteralLike[] | undefined,

): readonly ResolvedModuleWithFailedLookupLocations[];

resolveTypeReferenceDirectiveReferences<T extends FileReference | string>(

typeDirectiveReferences: readonly T[],

containingFile: string,

redirectedReference: ResolvedProjectReference | undefined,

options: CompilerOptions,

containingSourceFile: SourceFile | undefined,

reusedNames: readonly T[] | undefined,

): readonly ResolvedTypeReferenceDirectiveWithFailedLookupLocations[];

resolveLibrary(

libraryName: string,

resolveFrom: string,

options: CompilerOptions,

libFileName: string,

): ResolvedModuleWithFailedLookupLocations;

resolveSingleModuleNameWithoutWatching(

moduleName: string,

containingFile: string,

): ResolvedModuleWithFailedLookupLocations;

invalidateResolutionsOfFailedLookupLocations(): boolean;

invalidateResolutionOfFile(filePath: Path): void;

removeResolutionsOfFile(filePath: Path, syncDirWatcherRemove?: boolean): void;

removeResolutionsFromProjectReferenceRedirects(filePath: Path): void;

setFilesWithInvalidatedNonRelativeUnresolvedImports(filesWithUnresolvedImports: Map<Path, readonly string[]>): void;

createHasInvalidatedResolutions(

customHasInvalidatedResolutions: HasInvalidatedResolutions,

customHasInvalidatedLibResolutions: HasInvalidatedLibResolutions,

): HasInvalidatedFromResolutionCache;

hasChangedAutomaticTypeDirectiveNames(): boolean;

isFileWithInvalidatedNonRelativeUnresolvedImports(path: Path): boolean;

startCachingPerDirectoryResolution(): void;

finishCachingPerDirectoryResolution(newProgram: Program | undefined, oldProgram: Program | undefined): void;

updateTypeRootsWatch(): void;

closeTypeRootsWatch(): void;

getModuleResolutionCache(): ModuleResolutionCache;

clear(): void;

onChangesAffectModuleResolution(): void;

failedLookupLocations?: string[];

affectingLocations?: string[];

isInvalidated?: boolean;

refCount?: number;

// Files that have this resolution using

files?: Set<Path>;

alternateResult?: string;

toPath(fileName: string): Path;

getCanonicalFileName: GetCanonicalFileName;

getCompilationSettings(): CompilerOptions;

watchDirectoryOfFailedLookupLocation(directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags): FileWatcher;

watchAffectingFileLocation(file: string, cb: FileWatcherCallback): FileWatcher;

onInvalidatedResolution(): void;

watchTypeRootsDirectory(directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags): FileWatcher;

onChangedAutomaticTypeDirectiveNames(): void;

scheduleInvalidateResolutionsOfFailedLookupLocations(): void;

getCachedDirectoryStructureHost(): CachedDirectoryStructureHost | undefined;

projectName?: string;

getGlobalCache?(): string | undefined;

globalCacheResolutionModuleName?(externalModuleName: string): string;

writeLog(s: string): void;

getCurrentProgram(): Program | undefined;

fileIsOpen(filePath: Path): boolean;

onDiscoveredSymlink?(): void;

// For incremental testing

beforeResolveSingleModuleNameWithoutWatching?(

moduleResolutionCache: ModuleResolutionCache,

): any;

afterResolveSingleModuleNameWithoutWatching?(

moduleResolutionCache: ModuleResolutionCache,

moduleName: string,

containingFile: string,

result: ResolvedModuleWithFailedLookupLocations,

data: any,

): any;

/** watcher for the lookup */

watcher: FileWatcher;

resolutions: number;

files: number;

symlinks: Set<string> | undefined;

/** watcher for the lookup */

watcher: FileWatcher;

/** ref count keeping this watch alive */

refCount: number;

/** is the directory watched being non recursive */

nonRecursive?: boolean;

dir: string;

dirPath: Path;

nonRecursive?: boolean;

packageDir?: string;

packageDirPath?: Path;

// Consider whole staging folder as if node_modules changed.

if (endsWith(path, "/node_modules/.staging")) {

return removeSuffix(path, "/.staging") as Path;

}

return some(ignoredPaths, searchPath => path.includes(searchPath)) ?

undefined :

path;

// Ignore "/", "c:/"

if (length <= 1) return 1;

let indexAfterOsRoot = 1;

let isDosStyle = pathComponents[0].search(/[a-zA-Z]:/) === 0;

if (

pathComponents[0] !== directorySeparator &&

!isDosStyle && // Non dos style paths

pathComponents[1].search(/[a-zA-Z]\$$/) === 0 // Dos style nextPart

) {

// ignore "//vda1cs4850/c$/folderAtRoot"

if (length === 2) return 2;

indexAfterOsRoot = 2;

isDosStyle = true;

}

if (

isDosStyle &&

!pathComponents[indexAfterOsRoot].match(/^users$/i)

) {

// Paths like c:/notUsers

return indexAfterOsRoot;

}

if (pathComponents[indexAfterOsRoot].match(/^workspaces$/i)) {

// Paths like: /workspaces as codespaces hoist the repos in /workspaces so we have to exempt these from "2" level from root rule

return indexAfterOsRoot + 1;

}

// Paths like: c:/users/username or /home/username

return indexAfterOsRoot + 2;

if (length === undefined) length = pathComponents.length;

// Ignore "/", "c:/"

// ignore "/user", "c:/users" or "c:/folderAtRoot"

if (length <= 2) return false;

const perceivedOsRootLength = perceivedOsRootLengthForWatching(pathComponents, length);

return length > perceivedOsRootLength + 1;

if (fileOrDirComponents.length < fileOrDirComponents.length) return false;

for (let i = 0; i < dirComponents.length; i++) {

if (fileOrDirComponents[i] !== dirComponents[i]) return false;

}

return true;

failedLookupLocation: string,

failedLookupLocationPath: Path,

rootDir: string,

rootPath: Path,

rootPathComponents: Readonly<PathPathComponents>,

getCurrentDirectory: () => string | undefined,

): DirectoryOfFailedLookupWatch | undefined {

const failedLookupPathComponents: Readonly<PathPathComponents> = getPathComponents(failedLookupLocationPath);

// Ensure failed look up is normalized path

failedLookupLocation = isRootedDiskPath(failedLookupLocation) ? normalizePath(failedLookupLocation) : getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory());

const failedLookupComponents: readonly string[] = getPathComponents(failedLookupLocation);

const perceivedOsRootLength = perceivedOsRootLengthForWatching(failedLookupPathComponents, failedLookupPathComponents.length);

if (failedLookupPathComponents.length <= perceivedOsRootLength + 1) return undefined;

// If directory path contains node module, get the most parent node_modules directory for watching

const nodeModulesIndex = failedLookupPathComponents.indexOf("node_modules" as Path);

if (nodeModulesIndex !== -1 && nodeModulesIndex + 1 <= perceivedOsRootLength + 1) return undefined; // node_modules not at position where it can be watched

const lastNodeModulesIndex = failedLookupPathComponents.lastIndexOf("node_modules" as Path);

if (isInDirectoryPath(rootPathComponents, failedLookupPathComponents)) {

if (failedLookupPathComponents.length > rootPathComponents.length + 1) {

// Instead of watching root, watch directory in root to avoid watching excluded directories not needed for module resolution

return getDirectoryOfFailedLookupWatch(

failedLookupComponents,

failedLookupPathComponents,

Math.max(rootPathComponents.length + 1, perceivedOsRootLength + 1),

lastNodeModulesIndex,

);

}

else {

// Always watch root directory non recursively

return {

dir: rootDir,

dirPath: rootPath,

nonRecursive: true,

};

}

}

return getDirectoryToWatchFromFailedLookupLocationDirectory(

failedLookupComponents,

failedLookupPathComponents,

failedLookupPathComponents.length - 1,

perceivedOsRootLength,

nodeModulesIndex,

rootPathComponents,

lastNodeModulesIndex,

);

dirComponents: readonly string[],

dirPathComponents: Readonly<PathPathComponents>,

dirPathComponentsLength: number,

perceivedOsRootLength: number,

nodeModulesIndex: number,

rootPathComponents: Readonly<PathPathComponents>,

lastNodeModulesIndex: number,

): DirectoryOfFailedLookupWatch | undefined {

// If directory path contains node module, get the most parent node_modules directory for watching

if (nodeModulesIndex !== -1) {

// If the directory is node_modules use it to watch, always watch it recursively

return getDirectoryOfFailedLookupWatch(

dirComponents,

dirPathComponents,

nodeModulesIndex + 1,

lastNodeModulesIndex,

);

}

// Use some ancestor of the root directory

let nonRecursive = true;

let length = dirPathComponentsLength;

for (let i = 0; i < dirPathComponentsLength; i++) {

if (dirPathComponents[i] !== rootPathComponents[i]) {

nonRecursive = false;

length = Math.max(i + 1, perceivedOsRootLength + 1);

break;

}

}

return getDirectoryOfFailedLookupWatch(

dirComponents,

dirPathComponents,

length,

lastNodeModulesIndex,

nonRecursive,

);

dirComponents: readonly string[],

dirPathComponents: Readonly<PathPathComponents>,

length: number,

lastNodeModulesIndex: number,

nonRecursive?: boolean,

): DirectoryOfFailedLookupWatch {

let packageDirLength;

if (lastNodeModulesIndex !== -1 && lastNodeModulesIndex + 1 >= length && lastNodeModulesIndex + 2 < dirPathComponents.length) {

if (!startsWith(dirPathComponents[lastNodeModulesIndex + 1], "@")) {

packageDirLength = lastNodeModulesIndex + 2;

}

else if (lastNodeModulesIndex + 3 < dirPathComponents.length) {

packageDirLength = lastNodeModulesIndex + 3;

}

}

return {

dir: getPathFromPathComponents(dirComponents, length),

dirPath: getPathFromPathComponents(dirPathComponents, length),

nonRecursive,

packageDir: packageDirLength !== undefined ? getPathFromPathComponents(dirComponents, packageDirLength) : undefined,

packageDirPath: packageDirLength !== undefined ? getPathFromPathComponents(dirPathComponents, packageDirLength) : undefined,

};

typeRoot: string,

typeRootPath: Path,

rootPath: Path,

rootPathComponents: Readonly<PathPathComponents>,

getCurrentDirectory: () => string | undefined,

filterCustomPath: (path: Path) => boolean, // Return true if this path can be used

): Path | undefined {

const typeRootPathComponents = getPathComponents(typeRootPath);

if (isInDirectoryPath(rootPathComponents, typeRootPathComponents)) {

// Because this is called when we are watching typeRoot, we dont need additional check whether typeRoot is not say c:/users/node_modules/@types when root is c:/

return rootPath;

}

typeRoot = isRootedDiskPath(typeRoot) ? normalizePath(typeRoot) : getNormalizedAbsolutePath(typeRoot, getCurrentDirectory());

const toWatch = getDirectoryToWatchFromFailedLookupLocationDirectory(

getPathComponents(typeRoot),

typeRootPathComponents,

typeRootPathComponents.length,

perceivedOsRootLengthForWatching(typeRootPathComponents, typeRootPathComponents.length),

typeRootPathComponents.indexOf("node_modules" as Path),

rootPathComponents,

typeRootPathComponents.lastIndexOf("node_modules" as Path),

);

return toWatch && filterCustomPath(toWatch.dirPath) ? toWatch.dirPath : undefined;

const normalized = getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory());

return !isDiskPathRoot(normalized) ?

removeTrailingDirectorySeparator(normalized) :

normalized;

containingFile: string,

redirectedReference: ResolvedProjectReference | undefined,

options: CompilerOptions,

resolutionHost: ResolutionCacheHost,

moduleResolutionCache: ModuleResolutionCache,

): ResolutionLoader<StringLiteralLike, ResolvedModuleWithFailedLookupLocations, SourceFile> {

return {

nameAndMode: moduleResolutionNameAndModeGetter,

resolve: (moduleName, resoluionMode) =>

resolveModuleNameUsingGlobalCache(

resolutionHost,

moduleResolutionCache,

moduleName,

containingFile,

options,

redirectedReference,

resoluionMode,

),

};

resolutionHost: ResolutionCacheHost,

moduleResolutionCache: ModuleResolutionCache,

moduleName: string,

containingFile: string,

compilerOptions: CompilerOptions,

redirectedReference?: ResolvedProjectReference,

mode?: ResolutionMode,

): ResolvedModuleWithFailedLookupLocations {

const host = getModuleResolutionHost(resolutionHost);

const primaryResult = ts_resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode);

// return result immediately only if global cache support is not enabled or if it is .ts, .tsx or .d.ts

if (!resolutionHost.getGlobalCache) {

return primaryResult;

}

// otherwise try to load typings from @types

const globalCache = resolutionHost.getGlobalCache();

if (globalCache !== undefined && !isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && extensionIsTS(primaryResult.resolvedModule.extension))) {

// create different collection of failed lookup locations for second pass

// if it will fail and we've already found something during the first pass - we don't want to pollute its results

const { resolvedModule, failedLookupLocations, affectingLocations, resolutionDiagnostics } = loadModuleFromGlobalCache(

Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName),

resolutionHost.projectName,

compilerOptions,

host,

globalCache,

moduleResolutionCache,

);

if (resolvedModule) {

// Modify existing resolution so its saved in the directory cache as well

(primaryResult.resolvedModule as any) = resolvedModule;

primaryResult.failedLookupLocations = updateResolutionField(primaryResult.failedLookupLocations, failedLookupLocations);

primaryResult.affectingLocations = updateResolutionField(primaryResult.affectingLocations, affectingLocations);

primaryResult.resolutionDiagnostics = updateResolutionField(primaryResult.resolutionDiagnostics, resolutionDiagnostics);

return primaryResult;

}

}

// Default return the result from the first pass

return primaryResult;

let filesWithChangedSetOfUnresolvedImports: Path[] | undefined;

let filesWithInvalidatedResolutions: Set<Path> | undefined;

let filesWithInvalidatedNonRelativeUnresolvedImports: ReadonlyMap<Path, readonly string[]> | undefined;

const nonRelativeExternalModuleResolutions = createMultiMap<string, ResolutionWithFailedLookupLocations>();

const resolutionsWithFailedLookups = new Set<ResolutionWithFailedLookupLocations>();

const resolutionsWithOnlyAffectingLocations = new Set<ResolutionWithFailedLookupLocations>();

const resolvedFileToResolution = new Map<Path, Set<ResolutionWithFailedLookupLocations>>();

const impliedFormatPackageJsons = new Map<Path, readonly string[]>();

let hasChangedAutomaticTypeDirectiveNames = false;

let affectingPathChecksForFile: Set<string> | undefined;

let affectingPathChecks: Set<string> | undefined;

let failedLookupChecks: Set<Path> | undefined;

let startsWithPathChecks: Set<Path> | undefined;

let isInDirectoryChecks: Set<Path> | undefined;

let allModuleAndTypeResolutionsAreInvalidated = false;

const getCurrentDirectory = memoize(() => resolutionHost.getCurrentDirectory!());

const cachedDirectoryStructureHost = resolutionHost.getCachedDirectoryStructureHost();

// The resolvedModuleNames and resolvedTypeReferenceDirectives are the cache of resolutions per file.

// The key in the map is source file's path.

// The values are Map of resolutions with key being name lookedup.

const resolvedModuleNames = new Map<Path, ModeAwareCache<CachedResolvedModuleWithFailedLookupLocations>>();

const moduleResolutionCache = createModuleResolutionCache(

getCurrentDirectory(),

resolutionHost.getCanonicalFileName,

resolutionHost.getCompilationSettings(),

);

const resolvedTypeReferenceDirectives = new Map<Path, ModeAwareCache<CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations>>();

const typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(

getCurrentDirectory(),

resolutionHost.getCanonicalFileName,

resolutionHost.getCompilationSettings(),

moduleResolutionCache.getPackageJsonInfoCache(),

moduleResolutionCache.optionsToRedirectsKey,

);

const resolvedLibraries = new Map<string, CachedResolvedModuleWithFailedLookupLocations>();

const libraryResolutionCache = createModuleResolutionCache(

getCurrentDirectory(),

resolutionHost.getCanonicalFileName,

getOptionsForLibraryResolution(resolutionHost.getCompilationSettings()),

moduleResolutionCache.getPackageJsonInfoCache(),

);

const directoryWatchesOfFailedLookups = new Map<Path, DirectoryWatchesOfFailedLookup>();

const fileWatchesOfAffectingLocations = new Map<string, FileWatcherOfAffectingLocation>();

const rootDir = getRootDirectoryOfResolutionCache(rootDirForResolution, getCurrentDirectory);

const rootPath = resolutionHost.toPath(rootDir);

const rootPathComponents = getPathComponents(rootPath);

const isSymlinkCache = new Map<Path, boolean>();

const packageDirWatchers = new Map<Path, PackageDirWatcher>(); // Watching packageDir if symlink otherwise watching dirPath

const dirPathToSymlinkPackageRefCount = new Map<Path, number>(); // Refcount for dirPath watches when watching symlinked packageDir

// TypeRoot watches for the types that get added as part of getAutomaticTypeDirectiveNames

const typeRootsWatches = new Map<string, FileWatcher>();

return {

rootDirForResolution,

resolvedModuleNames,

resolvedTypeReferenceDirectives,

resolvedLibraries,

resolvedFileToResolution,

resolutionsWithFailedLookups,

resolutionsWithOnlyAffectingLocations,

directoryWatchesOfFailedLookups,

fileWatchesOfAffectingLocations,

packageDirWatchers,

dirPathToSymlinkPackageRefCount,

watchFailedLookupLocationsOfExternalModuleResolutions,

getModuleResolutionCache: () => moduleResolutionCache,

startRecordingFilesWithChangedResolutions,

finishRecordingFilesWithChangedResolutions,

// perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update

// (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)

startCachingPerDirectoryResolution,

finishCachingPerDirectoryResolution,

resolveModuleNameLiterals,

resolveTypeReferenceDirectiveReferences,

resolveLibrary,

resolveSingleModuleNameWithoutWatching,

removeResolutionsFromProjectReferenceRedirects,

removeResolutionsOfFile,

hasChangedAutomaticTypeDirectiveNames: () => hasChangedAutomaticTypeDirectiveNames,

invalidateResolutionOfFile,

invalidateResolutionsOfFailedLookupLocations,

setFilesWithInvalidatedNonRelativeUnresolvedImports,

createHasInvalidatedResolutions,

isFileWithInvalidatedNonRelativeUnresolvedImports,

updateTypeRootsWatch,

closeTypeRootsWatch,

clear,

onChangesAffectModuleResolution,

};

function getResolvedModule(resolution: CachedResolvedModuleWithFailedLookupLocations) {

return resolution.resolvedModule;

}

function getResolvedTypeReferenceDirective(resolution: CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations) {

return resolution.resolvedTypeReferenceDirective;

}

function clear() {

clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);

clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);

isSymlinkCache.clear();

packageDirWatchers.clear();

dirPathToSymlinkPackageRefCount.clear();

nonRelativeExternalModuleResolutions.clear();

closeTypeRootsWatch();

resolvedModuleNames.clear();

resolvedTypeReferenceDirectives.clear();

resolvedFileToResolution.clear();

resolutionsWithFailedLookups.clear();

resolutionsWithOnlyAffectingLocations.clear();

failedLookupChecks = undefined;

startsWithPathChecks = undefined;

isInDirectoryChecks = undefined;

affectingPathChecks = undefined;

affectingPathChecksForFile = undefined;

allModuleAndTypeResolutionsAreInvalidated = false;

moduleResolutionCache.clear();

typeReferenceDirectiveResolutionCache.clear();

moduleResolutionCache.update(resolutionHost.getCompilationSettings());

typeReferenceDirectiveResolutionCache.update(resolutionHost.getCompilationSettings());

libraryResolutionCache.clear();

impliedFormatPackageJsons.clear();

resolvedLibraries.clear();

hasChangedAutomaticTypeDirectiveNames = false;

}

function onChangesAffectModuleResolution() {

allModuleAndTypeResolutionsAreInvalidated = true;

moduleResolutionCache.clearAllExceptPackageJsonInfoCache();

typeReferenceDirectiveResolutionCache.clearAllExceptPackageJsonInfoCache();

moduleResolutionCache.update(resolutionHost.getCompilationSettings());

typeReferenceDirectiveResolutionCache.update(resolutionHost.getCompilationSettings());

}

function startRecordingFilesWithChangedResolutions() {

filesWithChangedSetOfUnresolvedImports = [];

}

function finishRecordingFilesWithChangedResolutions() {

const collected = filesWithChangedSetOfUnresolvedImports;

filesWithChangedSetOfUnresolvedImports = undefined;

return collected;

}

function isFileWithInvalidatedNonRelativeUnresolvedImports(path: Path): boolean {

if (!filesWithInvalidatedNonRelativeUnresolvedImports) {

return false;

}

// Invalidated if file has unresolved imports

const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path);

return !!value && !!value.length;

}

function createHasInvalidatedResolutions(

customHasInvalidatedResolutions: HasInvalidatedResolutions,

customHasInvalidatedLibResolutions: HasInvalidatedLibResolutions,

): HasInvalidatedFromResolutionCache {

// Ensure pending resolutions are applied

invalidateResolutionsOfFailedLookupLocations();

const collected = filesWithInvalidatedResolutions;

filesWithInvalidatedResolutions = undefined;

return {

hasInvalidatedResolutions: path =>

customHasInvalidatedResolutions(path) ||

allModuleAndTypeResolutionsAreInvalidated ||

!!collected?.has(path) ||

isFileWithInvalidatedNonRelativeUnresolvedImports(path),

hasInvalidatedLibResolutions: libFileName =>

customHasInvalidatedLibResolutions(libFileName) ||

!!resolvedLibraries?.get(libFileName)?.isInvalidated,

};

}

function startCachingPerDirectoryResolution() {

moduleResolutionCache.isReadonly = undefined;

typeReferenceDirectiveResolutionCache.isReadonly = undefined;

libraryResolutionCache.isReadonly = undefined;

moduleResolutionCache.getPackageJsonInfoCache().isReadonly = undefined;

moduleResolutionCache.clearAllExceptPackageJsonInfoCache();

typeReferenceDirectiveResolutionCache.clearAllExceptPackageJsonInfoCache();

libraryResolutionCache.clearAllExceptPackageJsonInfoCache();

// perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update

// (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)

nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);

nonRelativeExternalModuleResolutions.clear();

isSymlinkCache.clear();

}

function cleanupLibResolutionWatching(newProgram: Program | undefined) {

resolvedLibraries.forEach((resolution, libFileName) => {

if (!newProgram?.resolvedLibReferences?.has(libFileName)) {

stopWatchFailedLookupLocationOfResolution(

resolution,

resolutionHost.toPath(getInferredLibraryNameResolveFrom(resolutionHost.getCompilationSettings(), getCurrentDirectory(), libFileName)),

getResolvedModule,

);

resolvedLibraries.delete(libFileName);

}

});

}

function finishCachingPerDirectoryResolution(newProgram: Program | undefined, oldProgram: Program | undefined) {

filesWithInvalidatedNonRelativeUnresolvedImports = undefined;

allModuleAndTypeResolutionsAreInvalidated = false;

nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);

nonRelativeExternalModuleResolutions.clear();

// Update file watches

if (newProgram !== oldProgram) {

cleanupLibResolutionWatching(newProgram);

newProgram?.getSourceFiles().forEach(newFile => {

const expected = isExternalOrCommonJsModule(newFile) ? newFile.packageJsonLocations?.length ?? 0 : 0;

const existing = impliedFormatPackageJsons.get(newFile.resolvedPath) ?? emptyArray;

for (let i = existing.length; i < expected; i++) {

createFileWatcherOfAffectingLocation(newFile.packageJsonLocations![i], /*forResolution*/ false);

}

if (existing.length > expected) {

for (let i = expected; i < existing.length; i++) {

fileWatchesOfAffectingLocations.get(existing[i])!.files--;

}

}

if (expected) impliedFormatPackageJsons.set(newFile.resolvedPath, newFile.packageJsonLocations!);

else impliedFormatPackageJsons.delete(newFile.resolvedPath);

});

impliedFormatPackageJsons.forEach((existing, path) => {

const newFile = newProgram?.getSourceFileByPath(path);

if (!newFile || newFile.resolvedPath !== path) {

existing.forEach(location => fileWatchesOfAffectingLocations.get(location)!.files--);

impliedFormatPackageJsons.delete(path);

}

});

}

directoryWatchesOfFailedLookups.forEach(closeDirectoryWatchesOfFailedLookup);

fileWatchesOfAffectingLocations.forEach(closeFileWatcherOfAffectingLocation);

packageDirWatchers.forEach(closePackageDirWatcher);

hasChangedAutomaticTypeDirectiveNames = false;

moduleResolutionCache.isReadonly = true;

typeReferenceDirectiveResolutionCache.isReadonly = true;

libraryResolutionCache.isReadonly = true;

moduleResolutionCache.getPackageJsonInfoCache().isReadonly = true;

isSymlinkCache.clear();

}

function closePackageDirWatcher(watcher: PackageDirWatcher, packageDirPath: Path) {

if (watcher.dirPathToWatcher.size === 0) {

packageDirWatchers.delete(packageDirPath);

}

}

function closeDirectoryWatchesOfFailedLookup(watcher: DirectoryWatchesOfFailedLookup, path: Path) {

if (watcher.refCount === 0) {

directoryWatchesOfFailedLookups.delete(path);

watcher.watcher.close();

}

}

function closeFileWatcherOfAffectingLocation(watcher: FileWatcherOfAffectingLocation, path: string) {

if (watcher.files === 0 && watcher.resolutions === 0 && !watcher.symlinks?.size) {

fileWatchesOfAffectingLocations.delete(path);

watcher.watcher.close();

}

}

interface ResolveNamesWithLocalCacheInput<Entry, SourceFile, T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName> {

entries: readonly Entry[];

containingFile: string;

containingSourceFile: SourceFile;

redirectedReference: ResolvedProjectReference | undefined;

options: CompilerOptions;

reusedNames?: readonly Entry[];

perFileCache: Map<Path, ModeAwareCache<T>>;

loader: ResolutionLoader<Entry, T, SourceFile>;

getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>;

shouldRetryResolution: (t: T) => boolean;

logChanges?: boolean;

deferWatchingNonRelativeResolution: boolean;

}

function resolveNamesWithLocalCache<Entry, SourceFile, T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName>({

entries,

containingFile,

containingSourceFile,

redirectedReference,

options,

perFileCache,

reusedNames,

loader,

getResolutionWithResolvedFileName,

deferWatchingNonRelativeResolution,

shouldRetryResolution,

logChanges,

}: ResolveNamesWithLocalCacheInput<Entry, SourceFile, T, R>): readonly T[] {

const path = resolutionHost.toPath(containingFile);

const resolutionsInFile = perFileCache.get(path) || perFileCache.set(path, createModeAwareCache()).get(path)!;