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

@@ -113,12 +113,10 @@ export interface ResolutionCache extends Required<CompilerHostSupportingResoluti
     countResolutionsResolvedWithGlobalCache(): number;
     countResolutionsResolvedWithoutGlobalCache(): number;
 
-    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(
@@ -179,10 +177,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;
     globalCacheResolution?: boolean;
 }
 
@@ -553,7 +554,6 @@ export function createResolutionCache(
     rootDirForResolution: string,
 ): ResolutionCache {
     let filesWithInvalidatedResolutions: Set<Path> | undefined;
-    const nonRelativeExternalModuleResolutions = new Set<ResolutionWithFailedLookupLocations>();
 
     const resolutionsWithFailedLookups = new Set<ResolutionWithFailedLookupLocations>();
     const resolutionsWithOnlyAffectingLocations = new Set<ResolutionWithFailedLookupLocations>();
@@ -625,7 +625,7 @@ export function createResolutionCache(
         fileWatchesOfAffectingLocations,
         countResolutionsResolvedWithGlobalCache: () => resolutionsResolvedWithGlobalCache,
         countResolutionsResolvedWithoutGlobalCache: () => resolutionsResolvedWithoutGlobalCache,
-        watchFailedLookupLocationsOfExternalModuleResolutions,
+        watchResolution,
         getModuleResolutionCache: () => moduleResolutionCache,
         // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update
         // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)
@@ -655,7 +655,6 @@ export function createResolutionCache(
     function clear() {
         clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
         clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
-        nonRelativeExternalModuleResolutions.clear();
         closeTypeRootsWatch();
         resolvedModuleNames.clear();
         resolvedTypeReferenceDirectives.clear();
@@ -723,7 +722,6 @@ export function createResolutionCache(
         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) {
@@ -744,7 +742,6 @@ export function createResolutionCache(
         resolutionsWithGlobalCachePassAreInvalidated = false;
         resolutionsWithoutGlobalCachePassAreInvalidated = false;
         unresolvedResolutionsWithGlobalCachePassAreInvalidated = false;
-        watchFailedLookupLocationOfNonRelativeModuleResolutions();
         // Update file watches
         if (newProgram !== oldProgram) {
             cleanupLibResolutionWatching(newProgram);
@@ -810,7 +807,6 @@ export function createResolutionCache(
         perFileCache: Map<Path, ModeAwareCache<T>>;
         loader: ResolutionLoader<Entry, T, SourceFile>;
         getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>;
-        deferWatchingNonRelativeResolution: boolean;
         onNewResolution?: CallbackOnNewResolution<T>;
     }
     function resolveNamesWithLocalCache<Entry, SourceFile, T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName>({
@@ -824,7 +820,6 @@ export function createResolutionCache(
         ambientEntries,
         loader,
         getResolutionWithResolvedFileName,
-        deferWatchingNonRelativeResolution,
         onNewResolution,
     }: ResolveNamesWithLocalCacheInput<Entry, SourceFile, T, R>): readonly T[] {
         const path = resolutionHost.toPath(containingFile);
@@ -861,7 +856,7 @@ export function createResolutionCache(
                 }
                 resolutionsInFile.set(name, mode, resolution);
                 if (resolution !== existingResolution) {
-                    watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
+                    watchResolution(resolution, path, getResolutionWithResolvedFileName);
                     if (existingResolution) {
                         stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolutionWithResolvedFileName);
                     }
@@ -1018,7 +1013,6 @@ export function createResolutionCache(
                 typeReferenceDirectiveResolutionCache,
             ),
             getResolutionWithResolvedFileName: getResolvedTypeReferenceDirectiveFromResolution,
-            deferWatchingNonRelativeResolution: false,
         });
     }
 
@@ -1049,7 +1043,6 @@ export function createResolutionCache(
                 moduleResolutionCache,
             ),
             getResolutionWithResolvedFileName: getResolvedModuleFromResolution,
-            deferWatchingNonRelativeResolution: true, // Defer non relative resolution watch because we could be using ambient modules
             onNewResolution,
         });
     }
@@ -1066,7 +1059,7 @@ export function createResolutionCache(
             const existingResolution = resolution;
             resolution = ts_resolveLibrary(libraryName, resolveFrom, options, host, libraryResolutionCache);
             const path = resolutionHost.toPath(resolveFrom);
-            watchFailedLookupLocationsOfExternalModuleResolutions(libraryName, resolution, path, getResolvedModuleFromResolution, /*deferWatchingNonRelativeResolution*/ false);
+            watchResolution(resolution, path, getResolvedModuleFromResolution);
             resolvedLibraries.set(libFileName, resolution);
             if (existingResolution) {
                 stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolvedModuleFromResolution);
@@ -1115,25 +1108,19 @@ export function createResolutionCache(
         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 (resolution.globalCacheResolution) resolutionsResolvedWithGlobalCache++;
         else if (resolution.globalCacheResolution === false) resolutionsResolvedWithoutGlobalCache++;
 
-        if (!deferWatchingNonRelativeResolution || isExternalModuleNameRelative(name)) {
-            watchFailedLookupLocationOfResolution(resolution);
-        }
-        else {
-            nonRelativeExternalModuleResolutions.add(resolution);
-        }
         const resolved = getResolutionWithResolvedFileName(resolution);
         if (resolved && resolved.resolvedFileName) {
             const key = resolutionHost.toPath(resolved.resolvedFileName);
@@ -1169,33 +1156,38 @@ export function createResolutionCache(
     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) {
@@ -1263,11 +1255,6 @@ export function createResolutionCache(
         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

@@ -222,7 +222,6 @@ export function verifyResolutionCache(
             path,
             resolutions,
             getResolvedModuleFileName,
-            /*deferWatchingNonRelativeResolution*/ true,
             expected.resolvedModuleNames,
             (name, mode) => actualProgram.getResolvedModule(actualProgram.getSourceFileByPath(path)!, name, mode),
         )
@@ -233,7 +232,6 @@ export function verifyResolutionCache(
             path,
             resolutions,
             getResolvedTypeRefFileName,
-            /*deferWatchingNonRelativeResolution*/ false,
             expected.resolvedTypeReferenceDirectives,
             (name, mode) =>
                 path !== inferredTypesPath ?
@@ -251,7 +249,6 @@ export function verifyResolutionCache(
             getResolvedModuleFileName(resolved),
             ts.getLibraryNameFromLibFileName(libFileName),
             /*mode*/ undefined,
-            /*deferWatchingNonRelativeResolution*/ false,
         );
         expected.resolvedLibraries.set(libFileName, expectedResolution);
     });
@@ -304,7 +301,20 @@ export function verifyResolutionCache(
             !resolution.isInvalidated,
             `${projectName}:: Resolution should not be invalidated`,
         );
-        verifySet(resolutionToExpected.get(resolution)!.files, resolution.files, `${projectName}:: Resolution files`);
+        const expected = resolutionToExpected.get(resolution)!;
+        verifySet(expected.files, resolution.files, `${projectName}:: 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`);
@@ -364,7 +374,6 @@ export function verifyResolutionCache(
         fileName: ts.Path,
         cache: ts.ModeAwareCache<T> | undefined,
         getResolvedFileName: (resolution: T) => string | undefined,
-        deferWatchingNonRelativeResolution: boolean,
         storeExpected: Map<ts.Path, ts.ModeAwareCache<ts.ResolutionWithFailedLookupLocations>>,
         getProgramResolutions: (name: string, mode: ts.ResolutionMode) => T | undefined,
     ) {
@@ -375,7 +384,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) storeExpected.set(fileName, expectedCache = ts.createModeAwareCache());
             expectedCache.set(name, mode, expected);
             // Resolution in cache should be same as that is in program
@@ -393,7 +402,6 @@ export function verifyResolutionCache(
         resolvedFileName: string | undefined,
         name: string,
         mode: ts.ResolutionMode,
-        deferWatchingNonRelativeResolution: boolean,
     ): ExpectedResolution {
         const existing = resolutionToRefs.get(resolved);
         let expectedResolution: ExpectedResolution;
@@ -414,7 +422,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;
     }