In preparation of sharing resolutions, watch the resolutions right away instead of defering external module reoslutions to watch all failed lookup locations

Author: sheetalkamat

src/compiler/resolutionCache.ts

@@ -106,12 +106,10 @@ export interface ResolutionCache extends Required<CompilerHostSupportingResoluti
     startRecordingFilesWithChangedResolutions(): void;
     finishRecordingFilesWithChangedResolutions(): Path[] | undefined;
 
-    watchFailedLookupLocationsOfExternalModuleResolutions<T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName>(
-        name: string,
+    watchResolution<T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName>(
         resolution: T,
         filePath: Path,
         getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>,
-        deferWatchingNonRelativeResolution: boolean,
     ): void;
 
     resolveModuleNameLiterals(
@@ -171,10 +169,13 @@ export interface ResolutionCache extends Required<CompilerHostSupportingResoluti
 export interface ResolutionWithFailedLookupLocations {
     failedLookupLocations?: string[];
     affectingLocations?: string[];
+    node10Result?: string;
     isInvalidated?: boolean;
     // Files that have this resolution using
     files?: Set<Path>;
-    node10Result?: string;
+    watchedFailed?: number;
+    watchedAffected?: number;
+    setAtRoot?: boolean;
 }
 
 /** @internal */
@@ -501,7 +502,6 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
     let filesWithChangedSetOfUnresolvedImports: Path[] | undefined;
     let filesWithInvalidatedResolutions: Set<Path> | undefined;
     let filesWithInvalidatedNonRelativeUnresolvedImports: ReadonlyMap<Path, readonly string[]> | undefined;
-    const nonRelativeExternalModuleResolutions = new Set<ResolutionWithFailedLookupLocations>();
 
     const resolutionsWithFailedLookups = new Set<ResolutionWithFailedLookupLocations>();
     const resolutionsWithOnlyAffectingLocations = new Set<ResolutionWithFailedLookupLocations>();
@@ -564,7 +564,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
         resolutionsWithOnlyAffectingLocations,
         directoryWatchesOfFailedLookups,
         fileWatchesOfAffectingLocations,
-        watchFailedLookupLocationsOfExternalModuleResolutions,
+        watchResolution,
         getModuleResolutionCache: () => moduleResolutionCache,
         startRecordingFilesWithChangedResolutions,
         finishRecordingFilesWithChangedResolutions,
@@ -603,7 +603,6 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
     function clear() {
         clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
         clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
-        nonRelativeExternalModuleResolutions.clear();
         closeTypeRootsWatch();
         resolvedModuleNames.clear();
         resolvedTypeReferenceDirectives.clear();
@@ -678,7 +677,6 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
         libraryResolutionCache.clearAllExceptPackageJsonInfoCache();
         // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update
         // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)
-        watchFailedLookupLocationOfNonRelativeModuleResolutions();
     }
 
     function cleanupLibResolutionWatching(newProgram: Program | undefined) {
@@ -697,7 +695,6 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
     function finishCachingPerDirectoryResolution(newProgram: Program | undefined, oldProgram: Program | undefined) {
         filesWithInvalidatedNonRelativeUnresolvedImports = undefined;
         allModuleAndTypeResolutionsAreInvalidated = false;
-        watchFailedLookupLocationOfNonRelativeModuleResolutions();
         // Update file watches
         if (newProgram !== oldProgram) {
             cleanupLibResolutionWatching(newProgram);
@@ -754,12 +751,11 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
         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, ambientModuleNames,
-        loader, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution,
+        loader, getResolutionWithResolvedFileName,
         shouldRetryResolution, logChanges,
     }: ResolveNamesWithLocalCacheInput<Entry, SourceFile, T, R>): readonly T[] {
         const path = resolutionHost.toPath(containingFile);
@@ -791,7 +787,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
                 }
                 resolutionsInFile.set(name, mode, resolution);
                 if (resolution !== existingResolution) {
-                    watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
+                    watchResolution(resolution, path, getResolutionWithResolvedFileName);
                     if (existingResolution) {
                         stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolutionWithResolvedFileName);
                     }
@@ -887,7 +883,6 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
             ),
             getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective,
             shouldRetryResolution: resolution => resolution.resolvedTypeReferenceDirective === undefined,
-            deferWatchingNonRelativeResolution: false,
         });
     }
 
@@ -919,7 +914,6 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
             getResolutionWithResolvedFileName: getResolvedModule,
             shouldRetryResolution: resolution => !resolution.resolvedModule || !resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension),
             logChanges: logChangesWhenResolvingModule,
-            deferWatchingNonRelativeResolution: true, // Defer non relative resolution watch because we could be using ambient modules
         });
     }
 
@@ -935,7 +929,7 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
             const existingResolution = resolution;
             resolution = ts_resolveLibrary(libraryName, resolveFrom, options, host, libraryResolutionCache);
             const path = resolutionHost.toPath(resolveFrom);
-            watchFailedLookupLocationsOfExternalModuleResolutions(libraryName, resolution, path, getResolvedModule, /*deferWatchingNonRelativeResolution*/ false);
+            watchResolution(resolution, path, getResolvedModule);
             resolvedLibraries.set(libFileName, resolution);
             if (existingResolution) {
                 stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolvedModule);
@@ -1066,21 +1060,15 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
         return endsWith(dirPath, "/node_modules/@types");
     }
 
-    function watchFailedLookupLocationsOfExternalModuleResolutions<T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName>(
-        name: string,
+    function watchResolution<T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName>(
         resolution: T,
         filePath: Path,
         getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>,
-        deferWatchingNonRelativeResolution: boolean,
     ) {
         (resolution.files ??= new Set()).add(filePath);
+        watchFailedLookupLocationOfResolution(resolution);
+        watchAffectingLocationsOfResolution(resolution);
         if (resolution.files.size !== 1) return;
-        if (!deferWatchingNonRelativeResolution || isExternalModuleNameRelative(name)) {
-            watchFailedLookupLocationOfResolution(resolution);
-        }
-        else {
-            nonRelativeExternalModuleResolutions.add(resolution);
-        }
         const resolved = getResolutionWithResolvedFileName(resolution);
         if (resolved && resolved.resolvedFileName) {
             const key = resolutionHost.toPath(resolved.resolvedFileName);
@@ -1116,33 +1104,38 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
     function watchFailedLookupLocationOfResolution(resolution: ResolutionWithFailedLookupLocations) {
         Debug.assert(!!resolution.files?.size);
 
-        const { failedLookupLocations, affectingLocations, node10Result } = resolution;
-        if (!failedLookupLocations?.length && !affectingLocations?.length && !node10Result) return;
-        if (failedLookupLocations?.length || node10Result) resolutionsWithFailedLookups.add(resolution);
+        const { failedLookupLocations, node10Result, watchedFailed } = resolution;
+        // There have to be failed lookup locations if there is node10Result so storing failedLookupLocation length is good enough,
+        // node10Result doesnt change later only failed lookup locations get added on
+        if (watchedFailed === failedLookupLocations?.length) return;
+        if (!watchedFailed) {
+            resolutionsWithFailedLookups.add(resolution);
+            if (resolution.watchedAffected) resolutionsWithOnlyAffectingLocations.delete(resolution);
+        }
 
-        let setAtRoot = false;
-        if (failedLookupLocations) {
-            for (const failedLookupLocation of failedLookupLocations) {
-                setAtRoot = watchFailedLookupLocation(failedLookupLocation, setAtRoot);
-            }
+        let setAtRoot = !!resolution.setAtRoot;
+        for (let i = watchedFailed || 0; i < failedLookupLocations!.length; i++) {
+            setAtRoot = watchFailedLookupLocation(failedLookupLocations![i], setAtRoot);
         }
-        if (node10Result) setAtRoot = watchFailedLookupLocation(node10Result, setAtRoot);
-        if (setAtRoot) {
+        if (!watchedFailed && node10Result) setAtRoot = watchFailedLookupLocation(node10Result, setAtRoot);
+        if (!resolution.setAtRoot && setAtRoot) {
             // This is always non recursive
             setDirectoryWatcher(rootDir, rootPath, /*nonRecursive*/ true);
         }
-        watchAffectingLocationsOfResolution(resolution, !failedLookupLocations?.length && !node10Result);
+        resolution.watchedFailed = failedLookupLocations?.length;
+        resolution.setAtRoot = setAtRoot;
     }
 
-    function watchAffectingLocationsOfResolution(resolution: ResolutionWithFailedLookupLocations, addToResolutionsWithOnlyAffectingLocations: boolean) {
+    function watchAffectingLocationsOfResolution(resolution: ResolutionWithFailedLookupLocations) {
         Debug.assert(!!resolution.files?.size);
-        const { affectingLocations } = resolution;
-        if (!affectingLocations?.length) return;
-        if (addToResolutionsWithOnlyAffectingLocations) resolutionsWithOnlyAffectingLocations.add(resolution);
+        const { affectingLocations, watchedAffected } = resolution;
+        if (affectingLocations?.length === watchedAffected) return;
+        if (!watchedAffected && !resolution.watchedFailed) resolutionsWithOnlyAffectingLocations.add(resolution);
         // Watch package json
-        for (const affectingLocation of affectingLocations) {
-            createFileWatcherOfAffectingLocation(affectingLocation, /*forResolution*/ true);
+        for (let i = watchedAffected || 0; i < affectingLocations!.length; i++) {
+            createFileWatcherOfAffectingLocation(affectingLocations![i], /*forResolution*/ true);
         }
+        resolution.watchedAffected = affectingLocations?.length;
     }
 
     function createFileWatcherOfAffectingLocation(affectingLocation: string, forResolution: boolean) {
@@ -1210,11 +1203,6 @@ export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootD
         packageJsonMap?.delete(resolutionHost.toPath(path));
     }
 
-    function watchFailedLookupLocationOfNonRelativeModuleResolutions() {
-        nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfResolution);
-        nonRelativeExternalModuleResolutions.clear();
-    }
-
     function setDirectoryWatcher(dir: string, dirPath: Path, nonRecursive?: boolean) {
         const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
         if (dirWatcher) {

src/harness/incrementalUtils.ts

@@ -204,7 +204,6 @@ export function verifyResolutionCache(
         path,
         resolutions,
         getResolvedModuleFileName,
-        /*deferWatchingNonRelativeResolution*/ true,
         expected.resolvedModuleNames,
         actualProgram.getSourceFileByPath(path)!.resolvedModules,
     ));
@@ -213,7 +212,6 @@ export function verifyResolutionCache(
         path,
         resolutions,
         getResolvedTypeRefFileName,
-        /*deferWatchingNonRelativeResolution*/ false,
         expected.resolvedTypeReferenceDirectives,
         path !== inferredTypesPath ?
             actualProgram.getSourceFileByPath(path)!.resolvedTypeReferenceDirectiveNames :
@@ -229,7 +227,6 @@ export function verifyResolutionCache(
             getResolvedModuleFileName(resolved),
             ts.getLibraryNameFromLibFileName(libFileName),
             /*mode*/ undefined,
-            /*deferWatchingNonRelativeResolution*/ false,
         );
         expected.resolvedLibraries.set(libFileName, expectedResolution);
     });
@@ -257,7 +254,20 @@ export function verifyResolutionCache(
             !resolution.isInvalidated,
             `${projectName}:: Resolution should not be invalidated`
         );
-        verifySet(resolutionToExpected.get(resolution)!.files, resolution.files, `Resolution files`);
+        const expected = resolutionToExpected.get(resolution)!;
+        verifySet(expected.files, resolution.files, `Resolution files`);
+        ts.Debug.assert(
+            expected.watchedFailed === resolution.watchedFailed,
+            `${projectName}:: Expected watchedFailed of Resolution ${expected.watchedFailed} but got ${resolution.watchedFailed}`
+        );
+        ts.Debug.assert(
+            expected.watchedAffected === resolution.watchedAffected,
+            `${projectName}:: Expected watchedAffected of Resolution ${expected.watchedAffected} but got ${resolution.watchedAffected}`
+        );
+        ts.Debug.assert(
+            expected.setAtRoot === resolution.setAtRoot,
+            `${projectName}:: Expected setAtRoot of Resolution ${expected.setAtRoot} but got ${resolution.setAtRoot}`
+        );
     });
     verifyMapOfResolutionSet(expected.resolvedFileToResolution, actual.resolvedFileToResolution, `resolvedFileToResolution`);
     verifyResolutionSet(expected.resolutionsWithFailedLookups, actual.resolutionsWithFailedLookups, `resolutionsWithFailedLookups`);
@@ -299,7 +309,6 @@ export function verifyResolutionCache(
         fileName: ts.Path,
         cache: ts.ModeAwareCache<T> | undefined,
         getResolvedFileName: (resolution: T) => string | undefined,
-        deferWatchingNonRelativeResolution: boolean,
         storeExpcted: Map<ts.Path, ts.ModeAwareCache<ts.ResolutionWithFailedLookupLocations>>,
         fromProgramResolutions: ts.ModeAwareCache<T> | undefined,
     ) {
@@ -310,7 +319,7 @@ export function verifyResolutionCache(
         let expectedCache: ts.ModeAwareCache<ts.ResolutionWithFailedLookupLocations> | undefined;
         cache?.forEach((resolved, name, mode) => {
             const resolvedFileName = getResolvedFileName(resolved);
-            const expected = collectResolution(cacheType, fileName, resolved, resolvedFileName, name, mode, deferWatchingNonRelativeResolution);
+            const expected = collectResolution(cacheType, fileName, resolved, resolvedFileName, name, mode);
             if (!expectedCache) storeExpcted.set(fileName, expectedCache = ts.createModeAwareCache());
             expectedCache.set(name, mode, expected);
             // Resolution in program should be same as in resolution cache
@@ -326,7 +335,6 @@ export function verifyResolutionCache(
         resolvedFileName: string | undefined,
         name: string,
         mode: ts.ResolutionMode,
-        deferWatchingNonRelativeResolution: boolean,
     ): ExpectedResolution {
         const existing = resolutionToRefs.get(resolved);
         let expectedResolution: ExpectedResolution;
@@ -346,7 +354,7 @@ export function verifyResolutionCache(
             expectedToResolution.set(expectedResolution, resolved);
             resolutionToExpected.set(resolved, expectedResolution);
         }
-        expected.watchFailedLookupLocationsOfExternalModuleResolutions(name, expectedResolution, fileName, () => ({ resolvedFileName }), deferWatchingNonRelativeResolution);
+        expected.watchResolution(expectedResolution, fileName, () => ({ resolvedFileName }));
         return expectedResolution;
     }