Should not remove the reused resolutions in the file when file contents have not changed.

Author: sheetalkamat

src/compiler/program.ts

@@ -595,11 +595,11 @@ namespace ts {
         let _compilerOptionsObjectLiteralSyntax: ObjectLiteralExpression;
 
         let moduleResolutionCache: ModuleResolutionCache;
-        let resolveModuleNamesWorker: (moduleNames: string[], containingFile: string) => ResolvedModuleFull[];
+        let resolveModuleNamesWorker: (moduleNames: string[], containingFile: string, reusedNames?: string[]) => ResolvedModuleFull[];
         const hasInvalidatedResolution = host.hasInvalidatedResolution || returnFalse;
         const hasChangedAutomaticTypeDirectiveNames = host.hasChangedAutomaticTypeDirectiveNames && host.hasChangedAutomaticTypeDirectiveNames.bind(host) || returnFalse;
         if (host.resolveModuleNames) {
-            resolveModuleNamesWorker = (moduleNames, containingFile) => host.resolveModuleNames(checkAllDefined(moduleNames), containingFile).map(resolved => {
+            resolveModuleNamesWorker = (moduleNames, containingFile, reusedNames) => host.resolveModuleNames(checkAllDefined(moduleNames), containingFile, reusedNames).map(resolved => {
                 // An older host may have omitted extension, in which case we should infer it from the file extension of resolvedFileName.
                 if (!resolved || (resolved as ResolvedModuleFull).extension !== undefined) {
                     return resolved as ResolvedModuleFull;
@@ -820,6 +820,7 @@ namespace ts {
              * * ResolvedModuleFull instance: can be reused.
              */
             let result: ResolvedModuleFull[];
+            let reusedNames: string[];
             /** A transient placeholder used to mark predicted resolution in the result list. */
             const predictedToResolveToAmbientModuleMarker: ResolvedModuleFull = <any>{};
 
@@ -835,6 +836,7 @@ namespace ts {
                             trace(host, Diagnostics.Reusing_resolution_of_module_0_to_file_1_from_old_program, moduleName, containingFile);
                         }
                         (result || (result = new Array(moduleNames.length)))[i] = oldResolvedModule;
+                        (reusedNames || (reusedNames = [])).push(moduleName);
                         continue;
                     }
                 }
@@ -863,7 +865,7 @@ namespace ts {
             }
 
             const resolutions = unknownModuleNames && unknownModuleNames.length
-                ? resolveModuleNamesWorker(unknownModuleNames, containingFile)
+                ? resolveModuleNamesWorker(unknownModuleNames, containingFile, reusedNames)
                 : emptyArray;
 
             // Combine results of resolutions and predicted results

src/compiler/resolutionCache.ts

@@ -8,7 +8,7 @@ namespace ts {
         startRecordingFilesWithChangedResolutions(): void;
         finishRecordingFilesWithChangedResolutions(): Path[];
 
-        resolveModuleNames(moduleNames: string[], containingFile: string, logChanges: boolean): ResolvedModuleFull[];
+        resolveModuleNames(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, logChanges: boolean): ResolvedModuleFull[];
         resolveTypeReferenceDirectives(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
 
         invalidateResolutionOfFile(filePath: Path): void;
@@ -207,6 +207,7 @@ namespace ts {
             perDirectoryCache: Map<Map<T>>,
             loader: (name: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost) => T,
             getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>,
+            reusedNames: string[] | undefined,
             logChanges: boolean): R[] {
 
             const path = resolutionHost.toPath(containingFile);
@@ -253,7 +254,7 @@ namespace ts {
 
             // Stop watching and remove the unused name
             resolutionsInFile.forEach((resolution, name) => {
-                if (!seenNamesInFile.has(name)) {
+                if (!seenNamesInFile.has(name) && !contains(reusedNames, name)) {
                     stopWatchFailedLookupLocationOfResolution(resolution);
                     resolutionsInFile.delete(name);
                 }
@@ -285,16 +286,16 @@ namespace ts {
                 typeDirectiveNames, containingFile,
                 resolvedTypeReferenceDirectives, perDirectoryResolvedTypeReferenceDirectives,
                 resolveTypeReferenceDirective, getResolvedTypeReferenceDirective,
-                /*logChanges*/ false
+                /*reusedNames*/ undefined, /*logChanges*/ false
             );
         }
 
-        function resolveModuleNames(moduleNames: string[], containingFile: string, logChanges: boolean): ResolvedModuleFull[] {
+        function resolveModuleNames(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, logChanges: boolean): ResolvedModuleFull[] {
             return resolveNamesWithLocalCache(
                 moduleNames, containingFile,
                 resolvedModuleNames, perDirectoryResolvedModuleNames,
                 resolveModuleName, getResolvedModule,
-                logChanges
+                reusedNames, logChanges
             );
         }
 

src/compiler/types.ts

@@ -4138,7 +4138,7 @@ namespace ts {
          * If resolveModuleNames is implemented then implementation for members from ModuleResolutionHost can be just
          * 'throw new Error("NotImplemented")'
          */
-        resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
+        resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames?: string[]): ResolvedModule[];
         /**
          * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
          */

src/compiler/watchedProgram.ts

@@ -396,8 +396,8 @@ namespace ts {
             return partialSystem.getDirectories(path);
         }
 
-        function resolveModuleNames(moduleNames: string[], containingFile: string) {
-            return resolutionCache.resolveModuleNames(moduleNames, containingFile, /*logChanges*/ false);
+        function resolveModuleNames(moduleNames: string[], containingFile: string, reusedNames?: string[]) {
+            return resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, /*logChanges*/ false);
         }
 
         function resolveTypeReferenceDirectives(typeDirectiveNames: string[], containingFile: string) {

src/server/project.ts

@@ -325,8 +325,8 @@ namespace ts.server {
             return !this.isWatchedMissingFile(path) && this.partialSystem.fileExists(file);
         }
 
-        resolveModuleNames(moduleNames: string[], containingFile: string): ResolvedModuleFull[] {
-            return this.resolutionCache.resolveModuleNames(moduleNames, containingFile, /*logChanges*/ true);
+        resolveModuleNames(moduleNames: string[], containingFile: string, reusedNames?: string[]): ResolvedModuleFull[] {
+            return this.resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, /*logChanges*/ true);
         }
 
         resolveTypeReferenceDirectives(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[] {

src/services/services.ts

@@ -1177,7 +1177,7 @@ namespace ts {
             }
 
             if (host.resolveModuleNames) {
-                compilerHost.resolveModuleNames = (moduleNames, containingFile) => host.resolveModuleNames(moduleNames, containingFile);
+                compilerHost.resolveModuleNames = (moduleNames, containingFile, reusedNames) => host.resolveModuleNames(moduleNames, containingFile, reusedNames);
             }
             if (host.resolveTypeReferenceDirectives) {
                 compilerHost.resolveTypeReferenceDirectives = (typeReferenceDirectiveNames, containingFile) => {

src/services/types.ts

@@ -183,7 +183,7 @@ namespace ts {
          * if implementation is omitted then language service will use built-in module resolution logic and get answers to
          * host specific questions using 'getScriptSnapshot'.
          */
-        resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
+        resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames?: string[]): ResolvedModule[];
         resolveTypeReferenceDirectives?(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
         hasInvalidatedResolution?: HasInvalidatedResolution;
         hasChangedAutomaticTypeDirectiveNames?(): boolean;