microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-04-17 01:49:41 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Add noDtsResolution to module resolution cache

Browse Source
This commit is contained in:
Andrew Branch
2023-11-14 14:17:51 -08:00
parent bb302d2a02
commit 3d19c74eaa
9 changed files with 75 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/compiler/checker.ts
View File

@@ -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<string, [specifier: string, mode: ResolutionMode]>();
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);

88
src/compiler/moduleNameResolver.ts
View File

@@ -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<T> {
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<T> {
* This assumes that any module id will have the same resolution for sibling files located in the same folder.
*/
export interface PerDirectoryResolutionCache<T> {
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<T>;
clear(): void;
/**
@@ -869,8 +869,8 @@ export interface PerDirectoryResolutionCache<T> {
}
export interface NonRelativeNameResolutionCache<T> {
getFromNonRelativeNameCache(nonRelativeName: string, mode: ResolutionMode, directoryName: string, redirectedReference: ResolvedProjectReference | undefined): T | undefined;
getOrCreateCacheForNonRelativeName(nonRelativeName: string, mode: ResolutionMode, redirectedReference?: ResolvedProjectReference): PerNonRelativeNameCache<T>;
getFromNonRelativeNameCache(nonRelativeName: string, mode: ResolutionMode, directoryName: string, noDtsResolution: boolean, redirectedReference: ResolvedProjectReference | undefined): T | undefined;
getOrCreateCacheForNonRelativeName(nonRelativeName: string, mode: ResolutionMode, noDtsResolution?: boolean, redirectedReference?: ResolvedProjectReference): PerNonRelativeNameCache<T>;
clear(): void;
/**
* Updates with the current compilerOptions the cache will operate with.
@@ -1079,42 +1079,42 @@ function createPerDirectoryResolutionCache<T>(
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<T>(): ModeAwareCache<T> {
const underlying = new Map<ModeAwareCacheKey, T>();
const memoizedReverseKeys = new Map<ModeAwareCacheKey, [specifier: string, mode: ResolutionMode]>();
const memoizedReverseKeys = new Map<ModeAwareCacheKey, [specifier: string, mode: ResolutionMode, noDtsResolution: boolean]>();
const cache: ModeAwareCache<T> = {
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<T>(): ModeAwareCache<T> {
};
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<T>(
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<T> {
function getOrCreateCacheForNonRelativeName(nonRelativeModuleName: string, mode: ResolutionMode, noDtsResolution: boolean, redirectedReference?: ResolvedProjectReference): PerNonRelativeNameCache<T> {
Debug.assert(!isExternalModuleNameRelative(nonRelativeModuleName));
return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, createModeAwareCacheKey(nonRelativeModuleName, mode), createPerModuleNameCache);
return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, createModeAwareCacheKey(nonRelativeModuleName, mode, noDtsResolution), createPerModuleNameCache);
}
function createPerModuleNameCache(): PerNonRelativeNameCache<T> {
@@ -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<Resolved> {
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<Resolved> {
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;
}

24
src/compiler/program.ts
View File

@@ -1055,7 +1055,7 @@ export function loadWithModeAwareCache<Entry, SourceFile, ResolutionCache, Resol
for (const entry of entries) {
const name = loader.nameAndMode.getName(entry);
const mode = loader.nameAndMode.getMode(entry, containingSourceFile);
const key = createModeAwareCacheKey(name, mode);
const key = createModeAwareCacheKey(name, mode, !!options.noDtsResolution);
let result = cache.get(key);
if (!result) {
cache.set(key, result = loader.resolve(name, mode));
@@ -1768,7 +1768,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(automaticTypeDirectiveNames, containingFilename);
for (let i = 0; i < automaticTypeDirectiveNames.length; i++) {
// under node16/nodenext module resolution, load `types`/ata include names as cjs resolution results by passing an `undefined` mode
automaticTypeDirectiveResolutions.set(automaticTypeDirectiveNames[i], /*mode*/ undefined, resolutions[i]);
automaticTypeDirectiveResolutions.set(automaticTypeDirectiveNames[i], /*mode*/ undefined, !!options.noDtsResolution, resolutions[i]);
processTypeReferenceDirective(
automaticTypeDirectiveNames[i],
/*mode*/ undefined,
@@ -1950,11 +1950,11 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
return program;
function getResolvedModule(file: SourceFile, moduleName: string, mode: ResolutionMode) {
return resolvedModules?.get(file.path)?.get(moduleName, mode);
return resolvedModules?.get(file.path)?.get(moduleName, mode, !!options.noDtsResolution);
}
function getResolvedTypeReferenceDirective(file: SourceFile, typeDirectiveName: string, mode: ResolutionMode) {
return resolvedTypeReferenceDirectiveNames?.get(file.path)?.get(typeDirectiveName, mode);
return resolvedTypeReferenceDirectiveNames?.get(file.path)?.get(typeDirectiveName, mode, !!options.noDtsResolution);
}
function forEachResolvedModule(
@@ -1976,8 +1976,8 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
callback: (resolution: T, moduleName: string, mode: ResolutionMode, filePath: Path) => 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) {

19
src/compiler/resolutionCache.ts
View File

@@ -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);

4
src/harness/incrementalUtils.ts
View File

@@ -301,11 +301,11 @@ export function verifyResolutionCache(
`${projectName}:: ${cacheType} ${fileName} Expect cache for file in program or auto type ref`,
);
let expectedCache: ts.ModeAwareCache<ts.ResolutionWithFailedLookupLocations> | 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);
});
}

2
src/services/goToDefinition.ts
View File

@@ -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 };
}

2
src/services/importTracker.ts
View File

@@ -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 });
}

2
src/testRunner/unittests/tsserver/getEditsForFileRename.ts
View File

@@ -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);

2
src/testRunner/unittests/tsserver/symlinkCache.ts
View File

@@ -74,7 +74,7 @@ describe("unittests:: tsserver:: symlinkCache", () => {
const cache = ts.createSymlinkCache("/", ts.createGetCanonicalFileName(/*useCaseSensitiveFileNames*/ false));
// Used to crash, #44953
const map = ts.createModeAwareCache<ts.ResolvedTypeReferenceDirectiveWithFailedLookupLocations>();
map.set("foo", /*mode*/ undefined, {
map.set("foo", /*mode*/ undefined, /*noDtsResolution*/ false, {
resolvedTypeReferenceDirective: {
primary: true,
originalPath: "/foo",