From 3d19c74eaaa11f0bc92050b1e65af4be87638e65 Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 14 Nov 2023 14:17:51 -0800 Subject: [PATCH] Add noDtsResolution to module resolution cache --- src/compiler/checker.ts | 6 +- src/compiler/moduleNameResolver.ts | 88 +++++++++---------- src/compiler/program.ts | 24 ++--- src/compiler/resolutionCache.ts | 19 ++-- src/harness/incrementalUtils.ts | 4 +- src/services/goToDefinition.ts | 2 +- src/services/importTracker.ts | 2 +- .../tsserver/getEditsForFileRename.ts | 2 +- .../unittests/tsserver/symlinkCache.ts | 2 +- 9 files changed, 75 insertions(+), 74 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 4a294a2474f..078cbd99af1 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7964,7 +7964,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } const contextFile = getSourceFileOfNode(getOriginalNode(context.enclosingDeclaration)); const resolutionMode = overrideImportMode || contextFile?.impliedNodeFormat; - const cacheKey = createModeAwareCacheKey(contextFile.path, resolutionMode); + const cacheKey = createModeAwareCacheKey(contextFile.path, resolutionMode, !!compilerOptions.noDtsResolution); const links = getSymbolLinks(symbol); let specifier = links.specifierCache && links.specifierCache.get(cacheKey); if (!specifier) { @@ -47979,8 +47979,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (resolvedTypeReferenceDirectives) { // populate reverse mapping: file path -> type reference directive that was resolved to this file fileToDirective = new Map(); - resolvedTypeReferenceDirectives.forEach(({ resolvedTypeReferenceDirective }, key, mode) => { - if (!resolvedTypeReferenceDirective?.resolvedFileName) { + resolvedTypeReferenceDirectives.forEach(({ resolvedTypeReferenceDirective }, key, mode, noDtsResolution) => { + if (!resolvedTypeReferenceDirective?.resolvedFileName || noDtsResolution) { return; } const file = host.getSourceFile(resolvedTypeReferenceDirective.resolvedFileName); diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts index bc46ffb0260..498e36d22a7 100644 --- a/src/compiler/moduleNameResolver.ts +++ b/src/compiler/moduleNameResolver.ts @@ -535,9 +535,9 @@ export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string } const containingDirectory = containingFile ? getDirectoryPath(containingFile) : undefined; - let result = containingDirectory ? cache?.getFromDirectoryCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference) : undefined; + let result = containingDirectory ? cache?.getFromDirectoryCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, !!options.noDtsResolution, redirectedReference) : undefined; if (!result && containingDirectory && !isExternalModuleNameRelative(typeReferenceDirectiveName)) { - result = cache?.getFromNonRelativeNameCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference); + result = cache?.getFromNonRelativeNameCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, !!options.noDtsResolution, redirectedReference); } if (result) { @@ -630,9 +630,9 @@ export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string resolutionDiagnostics: initializeResolutionField(diagnostics), }; if (containingDirectory && cache && !cache.isReadonly) { - cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(typeReferenceDirectiveName, /*mode*/ resolutionMode, result); + cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(typeReferenceDirectiveName, /*mode*/ resolutionMode, !!options.noDtsResolution, result); if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) { - cache.getOrCreateCacheForNonRelativeName(typeReferenceDirectiveName, resolutionMode, redirectedReference).set(containingDirectory, result); + cache.getOrCreateCacheForNonRelativeName(typeReferenceDirectiveName, resolutionMode, !!options.noDtsResolution, redirectedReference).set(containingDirectory, result); } } if (traceEnabled) traceResult(result); @@ -843,11 +843,11 @@ export interface TypeReferenceDirectiveResolutionCache extends PerDirectoryResol } export interface ModeAwareCache { - get(key: string, mode: ResolutionMode): T | undefined; - set(key: string, mode: ResolutionMode, value: T): this; - delete(key: string, mode: ResolutionMode): this; - has(key: string, mode: ResolutionMode): boolean; - forEach(cb: (elem: T, key: string, mode: ResolutionMode) => void): void; + get(key: string, mode: ResolutionMode, noDtsResolution: boolean): T | undefined; + set(key: string, mode: ResolutionMode, noDtsResolution: boolean, value: T): this; + delete(key: string, mode: ResolutionMode, noDtsResolution: boolean): this; + has(key: string, mode: ResolutionMode, noDtsResolution: boolean): boolean; + forEach(cb: (elem: T, key: string, mode: ResolutionMode, noDtsResolution: boolean) => void): void; size(): number; } @@ -856,7 +856,7 @@ export interface ModeAwareCache { * This assumes that any module id will have the same resolution for sibling files located in the same folder. */ export interface PerDirectoryResolutionCache { - getFromDirectoryCache(name: string, mode: ResolutionMode, directoryName: string, redirectedReference: ResolvedProjectReference | undefined): T | undefined; + getFromDirectoryCache(name: string, mode: ResolutionMode, directoryName: string, noDtsResolution: boolean, redirectedReference: ResolvedProjectReference | undefined): T | undefined; getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): ModeAwareCache; clear(): void; /** @@ -869,8 +869,8 @@ export interface PerDirectoryResolutionCache { } export interface NonRelativeNameResolutionCache { - getFromNonRelativeNameCache(nonRelativeName: string, mode: ResolutionMode, directoryName: string, redirectedReference: ResolvedProjectReference | undefined): T | undefined; - getOrCreateCacheForNonRelativeName(nonRelativeName: string, mode: ResolutionMode, redirectedReference?: ResolvedProjectReference): PerNonRelativeNameCache; + getFromNonRelativeNameCache(nonRelativeName: string, mode: ResolutionMode, directoryName: string, noDtsResolution: boolean, redirectedReference: ResolvedProjectReference | undefined): T | undefined; + getOrCreateCacheForNonRelativeName(nonRelativeName: string, mode: ResolutionMode, noDtsResolution?: boolean, redirectedReference?: ResolvedProjectReference): PerNonRelativeNameCache; clear(): void; /** * Updates with the current compilerOptions the cache will operate with. @@ -1079,42 +1079,42 @@ function createPerDirectoryResolutionCache( return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, () => createModeAwareCache()); } - function getFromDirectoryCache(name: string, mode: ResolutionMode, directoryName: string, redirectedReference: ResolvedProjectReference | undefined) { + function getFromDirectoryCache(name: string, mode: ResolutionMode, directoryName: string, noDtsResolution: boolean, redirectedReference: ResolvedProjectReference | undefined) { const path = toPath(directoryName, currentDirectory, getCanonicalFileName); - return directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)?.get(path)?.get(name, mode); + return directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)?.get(path)?.get(name, mode, noDtsResolution); } } /** @internal */ export type ModeAwareCacheKey = string & { __modeAwareCacheKey: any; }; /** @internal */ -export function createModeAwareCacheKey(specifier: string, mode: ResolutionMode) { - return (mode === undefined ? specifier : `${mode}|${specifier}`) as ModeAwareCacheKey; +export function createModeAwareCacheKey(specifier: string, mode: ResolutionMode, noDtsResolution: boolean) { + return (mode === undefined ? specifier : `${mode}|${+noDtsResolution}|${specifier}`) as ModeAwareCacheKey; } /** @internal */ export function createModeAwareCache(): ModeAwareCache { const underlying = new Map(); - const memoizedReverseKeys = new Map(); + const memoizedReverseKeys = new Map(); const cache: ModeAwareCache = { - get(specifier, mode) { - return underlying.get(getUnderlyingCacheKey(specifier, mode)); + get(specifier, mode, noDtsResolution) { + return underlying.get(getUnderlyingCacheKey(specifier, mode, noDtsResolution)); }, - set(specifier, mode, value) { - underlying.set(getUnderlyingCacheKey(specifier, mode), value); + set(specifier, mode, noDtsResolution, value) { + underlying.set(getUnderlyingCacheKey(specifier, mode, noDtsResolution), value); return cache; }, - delete(specifier, mode) { - underlying.delete(getUnderlyingCacheKey(specifier, mode)); + delete(specifier, mode, noDtsResolution) { + underlying.delete(getUnderlyingCacheKey(specifier, mode, noDtsResolution)); return cache; }, - has(specifier, mode) { - return underlying.has(getUnderlyingCacheKey(specifier, mode)); + has(specifier, mode, noDtsResolution) { + return underlying.has(getUnderlyingCacheKey(specifier, mode, noDtsResolution)); }, forEach(cb) { return underlying.forEach((elem, key) => { - const [specifier, mode] = memoizedReverseKeys.get(key)!; - return cb(elem, specifier, mode); + const [specifier, mode, noDtsResolution] = memoizedReverseKeys.get(key)!; + return cb(elem, specifier, mode, noDtsResolution); }); }, size() { @@ -1123,9 +1123,9 @@ export function createModeAwareCache(): ModeAwareCache { }; return cache; - function getUnderlyingCacheKey(specifier: string, mode: ResolutionMode) { - const result = createModeAwareCacheKey(specifier, mode); - memoizedReverseKeys.set(result, [specifier, mode]); + function getUnderlyingCacheKey(specifier: string, mode: ResolutionMode, noDtsResolution: boolean) { + const result = createModeAwareCacheKey(specifier, mode, noDtsResolution); + memoizedReverseKeys.set(result, [specifier, mode, noDtsResolution]); return result; } } @@ -1162,14 +1162,14 @@ function createNonRelativeNameResolutionCache( moduleNameToDirectoryMap.update(options); } - function getFromNonRelativeNameCache(nonRelativeModuleName: string, mode: ResolutionMode, directoryName: string, redirectedReference?: ResolvedProjectReference): T | undefined { + function getFromNonRelativeNameCache(nonRelativeModuleName: string, mode: ResolutionMode, directoryName: string, noDtsResolution: boolean, redirectedReference?: ResolvedProjectReference): T | undefined { Debug.assert(!isExternalModuleNameRelative(nonRelativeModuleName)); - return moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)?.get(createModeAwareCacheKey(nonRelativeModuleName, mode))?.get(directoryName); + return moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)?.get(createModeAwareCacheKey(nonRelativeModuleName, mode, noDtsResolution))?.get(directoryName); } - function getOrCreateCacheForNonRelativeName(nonRelativeModuleName: string, mode: ResolutionMode, redirectedReference?: ResolvedProjectReference): PerNonRelativeNameCache { + function getOrCreateCacheForNonRelativeName(nonRelativeModuleName: string, mode: ResolutionMode, noDtsResolution: boolean, redirectedReference?: ResolvedProjectReference): PerNonRelativeNameCache { Debug.assert(!isExternalModuleNameRelative(nonRelativeModuleName)); - return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, createModeAwareCacheKey(nonRelativeModuleName, mode), createPerModuleNameCache); + return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, createModeAwareCacheKey(nonRelativeModuleName, mode, noDtsResolution), createPerModuleNameCache); } function createPerModuleNameCache(): PerNonRelativeNameCache { @@ -1329,7 +1329,7 @@ export function createModuleResolutionCache( getOriginalOrResolvedModuleFileName, optionsToRedirectsKey, ) as ModuleResolutionCache; - result.getOrCreateCacheForModuleName = (nonRelativeName, mode, redirectedReference) => result.getOrCreateCacheForNonRelativeName(nonRelativeName, mode, redirectedReference); + result.getOrCreateCacheForModuleName = (nonRelativeName, mode, redirectedReference) => result.getOrCreateCacheForNonRelativeName(nonRelativeName, mode, !!options?.noDtsResolution, redirectedReference); return result; } @@ -1374,9 +1374,9 @@ export function resolveLibrary(libraryName: string, resolveFrom: string, compile return resolveModuleName(libraryName, resolveFrom, getOptionsForLibraryResolution(compilerOptions), host, cache); } -export function resolveModuleNameFromCache(moduleName: string, containingFile: string, cache: ModuleResolutionCache, mode?: ResolutionMode): ResolvedModuleWithFailedLookupLocations | undefined { +export function resolveModuleNameFromCache(moduleName: string, containingFile: string, cache: ModuleResolutionCache, noDtsResolution: boolean, mode?: ResolutionMode): ResolvedModuleWithFailedLookupLocations | undefined { const containingDirectory = getDirectoryPath(containingFile); - return cache.getFromDirectoryCache(moduleName, mode, containingDirectory, /*redirectedReference*/ undefined); + return cache.getFromDirectoryCache(moduleName, mode, containingDirectory, noDtsResolution, /*redirectedReference*/ undefined); } export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode): ResolvedModuleWithFailedLookupLocations { @@ -1391,7 +1391,7 @@ export function resolveModuleName(moduleName: string, containingFile: string, co } } const containingDirectory = getDirectoryPath(containingFile); - let result = cache?.getFromDirectoryCache(moduleName, resolutionMode, containingDirectory, redirectedReference); + let result = cache?.getFromDirectoryCache(moduleName, resolutionMode, containingDirectory, !!compilerOptions.noDtsResolution, redirectedReference); if (result) { if (traceEnabled) { @@ -1449,10 +1449,10 @@ export function resolveModuleName(moduleName: string, containingFile: string, co perfLogger?.logStopResolveModule((result && result.resolvedModule) ? "" + result.resolvedModule.resolvedFileName : "null"); if (cache && !cache.isReadonly) { - cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(moduleName, resolutionMode, result); + cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(moduleName, resolutionMode, !!compilerOptions.noDtsResolution, result); if (!isExternalModuleNameRelative(moduleName)) { // put result in per-module name cache - cache.getOrCreateCacheForNonRelativeName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result); + cache.getOrCreateCacheForNonRelativeName(moduleName, resolutionMode, !!compilerOptions.noDtsResolution, redirectedReference).set(containingDirectory, result); } } } @@ -2980,7 +2980,7 @@ function loadModuleFromNearestNodeModulesDirectoryWorker(extensions: Extensions, function lookup(extensions: Extensions) { return forEachAncestorDirectory(normalizeSlashes(directory), ancestorDirectory => { if (getBaseFileName(ancestorDirectory) !== "node_modules") { - const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state); + const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, !!state.compilerOptions.noDtsResolution, redirectedReference, state); if (resolutionFromCache) { return resolutionFromCache; } @@ -3167,8 +3167,8 @@ export function unmangleScopedPackageName(typesPackageName: string): string { typesPackageName; } -function tryFindNonRelativeModuleNameInCache(cache: NonRelativeModuleNameResolutionCache | undefined, moduleName: string, mode: ResolutionMode, containingDirectory: string, redirectedReference: ResolvedProjectReference | undefined, state: ModuleResolutionState): SearchResult { - const result = cache && cache.getFromNonRelativeNameCache(moduleName, mode, containingDirectory, redirectedReference); +function tryFindNonRelativeModuleNameInCache(cache: NonRelativeModuleNameResolutionCache | undefined, moduleName: string, mode: ResolutionMode, containingDirectory: string, noDtsResolution: boolean, redirectedReference: ResolvedProjectReference | undefined, state: ModuleResolutionState): SearchResult { + const result = cache && cache.getFromNonRelativeNameCache(moduleName, mode, containingDirectory, noDtsResolution, redirectedReference); if (result) { if (state.traceEnabled) { trace(state.host, Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory); @@ -3230,7 +3230,7 @@ export function classicNameResolver(moduleName: string, containingFile: string, if (!isExternalModuleNameRelative(moduleName)) { // Climb up parent directories looking for a module. const resolved = forEachAncestorDirectory(containingDirectory, directory => { - const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, /*mode*/ undefined, directory, redirectedReference, state); + const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, /*mode*/ undefined, directory, !!compilerOptions.noDtsResolution, redirectedReference, state); if (resolutionFromCache) { return resolutionFromCache; } diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 04fc89a37d0..c3fc9781caa 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -1055,7 +1055,7 @@ export function loadWithModeAwareCache void, file: SourceFile | undefined, ) { - if (file) resolutionCache?.get(file.path)?.forEach((resolution, name, mode) => callback(resolution, name, mode, file.path)); - else resolutionCache?.forEach((resolutions, filePath) => resolutions.forEach((resolution, name, mode) => callback(resolution, name, mode, filePath))); + if (file) resolutionCache?.get(file.path)?.forEach((resolution, name, mode, noDtsResolution) => !noDtsResolution && callback(resolution, name, mode, file.path)); + else resolutionCache?.forEach((resolutions, filePath) => resolutions.forEach((resolution, name, mode, noDtsResolution) => !noDtsResolution && callback(resolution, name, mode, filePath))); } function getPackagesMap() { @@ -2020,7 +2020,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg // This may totally change if/when the issue of output paths not mapping to input files is fixed in a broader context // When it is, how we extract diagnostics from the module name resolver will have the be refined - the current cache // APIs wrapping the underlying resolver make it almost impossible to smuggle the diagnostics out in a generalized way - const fromCache = moduleResolutionCache.getFromNonRelativeNameCache(name, mode, containingDir, redirectedReference); + const fromCache = moduleResolutionCache.getFromNonRelativeNameCache(name, mode, containingDir, !!options.noDtsResolution, redirectedReference); if (fromCache) addResolutionDiagnostics(fromCache); } @@ -2279,7 +2279,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg const mode = getModeForFileReference(entry, containingSourceFile?.impliedNodeFormat); const oldResolution = !isString(containingFile) ? oldProgram?.getResolvedTypeReferenceDirective(containingFile, typeDirectiveName, mode) : - oldProgram?.getAutomaticTypeDirectiveResolutions()?.get(typeDirectiveName, mode); + oldProgram?.getAutomaticTypeDirectiveResolutions()?.get(typeDirectiveName, mode, !!options.noDtsResolution); if (oldResolution?.resolvedTypeReferenceDirective) { if (isTraceEnabled(options, host)) { trace( @@ -3859,7 +3859,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg const resolvedTypeReferenceDirective = resolutions[index]; // store resolved type directive on the file const fileName = toFileNameLowerCase(ref.fileName); - resolutionsInFile.set(fileName, getModeForFileReference(ref, file.impliedNodeFormat), resolvedTypeReferenceDirective); + resolutionsInFile.set(fileName, getModeForFileReference(ref, file.impliedNodeFormat), !!options.noDtsResolution, resolvedTypeReferenceDirective); const mode = ref.resolutionMode || file.impliedNodeFormat; processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: FileIncludeKind.TypeReferenceDirective, file: file.path, index }); } @@ -3884,7 +3884,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg ): void { addResolutionDiagnostics(resolution); // If we already found this library as a primary reference - nothing to do - const previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode)?.resolvedTypeReferenceDirective; + const previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode, !!options.noDtsResolution)?.resolvedTypeReferenceDirective; if (previousResolution && previousResolution.primary) { return; } @@ -3930,7 +3930,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg } if (saveResolution) { - resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolution); + resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, !!options.noDtsResolution, resolution); } } @@ -4029,7 +4029,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg const resolution = resolutions[index].resolvedModule; const moduleName = moduleNames[index].text; const mode = getModeForUsageLocation(file, moduleNames[index]); - resolutionsInFile.set(moduleName, mode, resolutions[index]); + resolutionsInFile.set(moduleName, mode, !!options.noDtsResolution, resolutions[index]); addResolutionDiagnosticsFromResolutionOrCache(file, moduleName, resolutions[index], mode); if (!resolution) { diff --git a/src/compiler/resolutionCache.ts b/src/compiler/resolutionCache.ts index 6c150cb66ae..35a52b8a11f 100644 --- a/src/compiler/resolutionCache.ts +++ b/src/compiler/resolutionCache.ts @@ -824,10 +824,10 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD for (const entry of entries) { const name = loader.nameAndMode.getName(entry); const mode = loader.nameAndMode.getMode(entry, containingSourceFile); - let resolution = resolutionsInFile.get(name, mode); + let resolution = resolutionsInFile.get(name, mode, !!options.noDtsResolution); // Resolution is valid if it is present and not invalidated if ( - !seenNamesInFile.has(name, mode) && + !seenNamesInFile.has(name, mode, !!options.noDtsResolution) && (allModuleAndTypeResolutionsAreInvalidated || unmatchedRedirects || !resolution || resolution.isInvalidated || // If the name is unresolved import that was invalidated, recalculate (hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution))) @@ -837,7 +837,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) { resolutionHost.onDiscoveredSymlink(); } - resolutionsInFile.set(name, mode, resolution); + resolutionsInFile.set(name, mode, !!options.noDtsResolution, resolution); if (resolution !== existingResolution) { watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution); if (existingResolution) { @@ -853,7 +853,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD } else { const host = getModuleResolutionHost(resolutionHost); - if (isTraceEnabled(options, host) && !seenNamesInFile.has(name, mode)) { + if (isTraceEnabled(options, host) && !seenNamesInFile.has(name, mode, !!options.noDtsResolution)) { const resolved = getResolutionWithResolvedFileName(resolution!); trace( host, @@ -876,22 +876,23 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD } } Debug.assert(resolution !== undefined && !resolution.isInvalidated); - seenNamesInFile.set(name, mode, true); + seenNamesInFile.set(name, mode, !!options.noDtsResolution, true); resolvedModules.push(resolution); } reusedNames?.forEach(entry => seenNamesInFile.set( loader.nameAndMode.getName(entry), loader.nameAndMode.getMode(entry, containingSourceFile), + !!options.noDtsResolution, true, ) ); if (resolutionsInFile.size() !== seenNamesInFile.size()) { // Stop watching and remove the unused name - resolutionsInFile.forEach((resolution, name, mode) => { - if (!seenNamesInFile.has(name, mode)) { + resolutionsInFile.forEach((resolution, name, mode, noDtsResolution) => { + if (!seenNamesInFile.has(name, mode, noDtsResolution)) { stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName); - resolutionsInFile.delete(name, mode); + resolutionsInFile.delete(name, mode, noDtsResolution); } }); } @@ -1016,7 +1017,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD function resolveSingleModuleNameWithoutWatching(moduleName: string, containingFile: string) { const path = resolutionHost.toPath(containingFile); const resolutionsInFile = resolvedModuleNames.get(path); - const resolution = resolutionsInFile?.get(moduleName, /*mode*/ undefined); + const resolution = resolutionsInFile?.get(moduleName, /*mode*/ undefined, !!resolutionHost.getCompilationSettings().noDtsResolution); if (resolution && !resolution.isInvalidated) return resolution; const data = resolutionHost.beforeResolveSingleModuleNameWithoutWatching?.(moduleResolutionCache); const host = getModuleResolutionHost(resolutionHost); diff --git a/src/harness/incrementalUtils.ts b/src/harness/incrementalUtils.ts index c35ffdd9a69..2fd228a1351 100644 --- a/src/harness/incrementalUtils.ts +++ b/src/harness/incrementalUtils.ts @@ -301,11 +301,11 @@ export function verifyResolutionCache( `${projectName}:: ${cacheType} ${fileName} Expect cache for file in program or auto type ref`, ); let expectedCache: ts.ModeAwareCache | undefined; - cache?.forEach((resolved, name, mode) => { + cache?.forEach((resolved, name, mode, noDtsResolution) => { const resolvedFileName = getResolvedFileName(resolved); const expected = collectResolution(cacheType, fileName, resolved, resolvedFileName, name, mode, deferWatchingNonRelativeResolution); if (!expectedCache) storeExpcted.set(fileName, expectedCache = ts.createModeAwareCache()); - expectedCache.set(name, mode, expected); + expectedCache.set(name, mode, noDtsResolution, expected); }); } diff --git a/src/services/goToDefinition.ts b/src/services/goToDefinition.ts index c603c6c7bab..cc2090139ea 100644 --- a/src/services/goToDefinition.ts +++ b/src/services/goToDefinition.ts @@ -322,7 +322,7 @@ export function getReferenceAtPosition(sourceFile: SourceFile, position: number, const typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position); if (typeReferenceDirective) { - const reference = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || sourceFile.impliedNodeFormat)?.resolvedTypeReferenceDirective; + const reference = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || sourceFile.impliedNodeFormat, !!program.getCompilerOptions().noDtsResolution)?.resolvedTypeReferenceDirective; const file = reference && program.getSourceFile(reference.resolvedFileName!); // TODO:GH#18217 return file && { reference: typeReferenceDirective, fileName: file.fileName, file, unverified: false }; } diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts index b0e7215625e..42c9af4c8f1 100644 --- a/src/services/importTracker.ts +++ b/src/services/importTracker.ts @@ -477,7 +477,7 @@ export function findModuleReferences(program: Program, sourceFiles: readonly Sou } } for (const ref of referencingFile.typeReferenceDirectives) { - const referenced = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || referencingFile.impliedNodeFormat)?.resolvedTypeReferenceDirective; + const referenced = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || referencingFile.impliedNodeFormat, /*noDtsResolution*/ false)?.resolvedTypeReferenceDirective; if (referenced !== undefined && referenced.resolvedFileName === (searchSourceFile as SourceFile).fileName) { refs.push({ kind: "reference", referencingFile, ref }); } diff --git a/src/testRunner/unittests/tsserver/getEditsForFileRename.ts b/src/testRunner/unittests/tsserver/getEditsForFileRename.ts index 46367043986..188f4296337 100644 --- a/src/testRunner/unittests/tsserver/getEditsForFileRename.ts +++ b/src/testRunner/unittests/tsserver/getEditsForFileRename.ts @@ -44,7 +44,7 @@ describe("unittests:: tsserver:: getEditsForFileRename", () => { readFile: path => host.readFile(path), fileExists: path => host.fileExists(path), resolveModuleNames: (moduleNames, containingFile) => moduleNames.map(name => ts.resolveModuleName(name, containingFile, options, lsHost, moduleResolutionCache).resolvedModule), - getResolvedModuleWithFailedLookupLocationsFromCache: (moduleName, containingFile, mode) => moduleResolutionCache.getFromDirectoryCache(moduleName, mode, ts.getDirectoryPath(containingFile), /*redirectedReference*/ undefined), + getResolvedModuleWithFailedLookupLocationsFromCache: (moduleName, containingFile, mode) => moduleResolutionCache.getFromDirectoryCache(moduleName, mode, ts.getDirectoryPath(containingFile), /*noDtsResolution*/ false, /*redirectedReference*/ undefined), }; const service = ts.createLanguageService(lsHost); const edits = service.getEditsForFileRename("/old.ts", "/new.ts", ts.testFormatSettings, ts.emptyOptions); diff --git a/src/testRunner/unittests/tsserver/symlinkCache.ts b/src/testRunner/unittests/tsserver/symlinkCache.ts index f31233fba57..d2a01b2216e 100644 --- a/src/testRunner/unittests/tsserver/symlinkCache.ts +++ b/src/testRunner/unittests/tsserver/symlinkCache.ts @@ -74,7 +74,7 @@ describe("unittests:: tsserver:: symlinkCache", () => { const cache = ts.createSymlinkCache("/", ts.createGetCanonicalFileName(/*useCaseSensitiveFileNames*/ false)); // Used to crash, #44953 const map = ts.createModeAwareCache(); - map.set("foo", /*mode*/ undefined, { + map.set("foo", /*mode*/ undefined, /*noDtsResolution*/ false, { resolvedTypeReferenceDirective: { primary: true, originalPath: "/foo",