Refactor getUnresolvedImports and verify it incrementally

Author: sheetalkamat

src/harness/incrementalUtils.ts

@@ -422,17 +422,25 @@ function verifySet(
     expected?.forEach(expected =>
         ts.Debug.assert(
             actual?.has(expected),
-            `${caption}:: Expected should be present in actual`,
+            `${caption}:: ${expected} should be present in actual`,
         )
     );
     actual?.forEach(actual =>
         ts.Debug.assert(
             expected?.has(actual),
-            `${caption}:: Actual should be present in expected`,
+            `${caption}:: ${actual} should be present in expected`,
         )
     );
 }
 
+function verifyArray(
+    expected: readonly string[] | undefined,
+    actual: readonly string[] | undefined,
+    caption: string,
+) {
+    return verifySet(expected && new Set(expected), actual && new Set(actual), caption);
+}
+
 function verifyProgram(service: ts.server.ProjectService, project: ts.server.Project) {
     if (service.serverMode === ts.LanguageServiceMode.Syntactic) return;
     const options = project.getCompilerOptions();
@@ -523,6 +531,24 @@ function verifyProgram(service: ts.server.ProjectService, project: ts.server.Pro
     verifyResolutionCache(project.resolutionCache, project.getCurrentProgram()!, resolutionHostCacheHost, project.projectName);
 }
 
+function verifyUnresolvedImports(_service: ts.server.ProjectService, project: ts.server.Project) {
+    const cachedUnresolvedImportsPerFile = new Map<ts.Path, readonly string[]>();
+    const lastCachedUnresolvedImportsList = project.useTypingsFromGlobalCache() ?
+        ts.server.getUnresolvedImports(project.getCurrentProgram()!, cachedUnresolvedImportsPerFile, ts.noop) :
+        undefined;
+    verifyArray(
+        lastCachedUnresolvedImportsList,
+        project.lastCachedUnresolvedImportsList,
+        `${project.getProjectName()}:: lastCachedUnresolvedImportsList`,
+    );
+    verifyMap(
+        cachedUnresolvedImportsPerFile,
+        project.cachedUnresolvedImportsPerFile,
+        (expected, actual, caption) => verifyArray(expected, actual, caption),
+        `${project.getProjectName()}:: cachedUnresolvedImportsPerFile`,
+    );
+}
+
 interface ResolveSingleModuleNameWithoutWatchingData {
     resolutionToData: Map<ts.ResolutionWithFailedLookupLocations, Pick<ts.ResolvedModuleWithFailedLookupLocations, "failedLookupLocations" | "affectingLocations" | "resolutionDiagnostics">>;
     packageJsonMap: Map<ts.Path, ts.PackageJsonInfo | boolean> | undefined;
@@ -599,6 +625,7 @@ export interface IncrementalVerifierCallbacks {
 export function incrementalVerifier(service: ts.server.ProjectService) {
     service.verifyDocumentRegistry = withIncrementalVerifierCallbacks(service, verifyDocumentRegistry);
     service.verifyProgram = withIncrementalVerifierCallbacks(service, verifyProgram);
+    service.verifyUnresovedImports = withIncrementalVerifierCallbacks(service, verifyUnresolvedImports);
     service.onProjectCreation = onProjectCreation;
 }
 

src/server/editorServices.ts

@@ -1138,6 +1138,7 @@ export class ProjectService {
 
     /** @internal */ verifyDocumentRegistry = noop;
     /** @internal */ verifyProgram: (project: Project) => void = noop;
+    /** @internal */ verifyUnresovedImports: (project: Project) => void = noop;
     /** @internal */ onProjectCreation: (project: Project) => void = noop;
 
     readonly jsDocParsingMode: JSDocParsingMode | undefined;

src/server/project.ts

@@ -1408,17 +1408,22 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
         this.hasAddedOrRemovedSymlinks = true;
     }
 
+    /** @internal */
+    useTypingsFromGlobalCache() {
+        return this.languageServiceEnabled &&
+            this.projectService.serverMode === LanguageServiceMode.Semantic &&
+            this.projectService.typingsInstaller !== nullTypingsInstaller &&
+            this.getTypeAcquisition().enable;
+    }
+
     /**
      * Updates set of files that contribute to this project
      * @returns: true if set of files in the project stays the same and false - otherwise.
      */
     updateGraph(): boolean {
         tracing?.push(tracing.Phase.Session, "updateGraph", { name: this.projectName, kind: ProjectKind[this.projectKind] });
         perfLogger?.logStartUpdateGraph();
-        const useTypingsFromGlobalCache = this.languageServiceEnabled &&
-            this.projectService.serverMode === LanguageServiceMode.Semantic &&
-            this.projectService.typingsInstaller !== nullTypingsInstaller &&
-            this.getTypeAcquisition().enable;
+        const useTypingsFromGlobalCache = this.useTypingsFromGlobalCache();
         if (!useTypingsFromGlobalCache) this.resolutionCache.invalidateResolutionsWithGlobalCachePass();
         else this.resolutionCache.invalidateResolutionsWithoutGlobalCachePass();
         if (useTypingsFromGlobalCache && this.cachedUnresolvedImportsPerFile.size) this.recordChangesToUnresolvedImports = true;
@@ -1430,14 +1435,19 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
         this.recordChangesToUnresolvedImports = false;
 
         if (useTypingsFromGlobalCache) {
-            this.lastCachedUnresolvedImportsList ??= this.getUnresolvedImports();
+            this.lastCachedUnresolvedImportsList ??= getUnresolvedImports(
+                this.program!,
+                this.cachedUnresolvedImportsPerFile,
+                s => this.writeLog(s),
+            );
             this.enqueueInstallTypingsForProject(hasAddedorRemovedFiles);
         }
         else {
             this.lastCachedUnresolvedImportsList = undefined;
             this.cachedUnresolvedImportsPerFile.clear();
             this.typingsCacheEntry = undefined;
         }
+        this.projectService.verifyUnresovedImports(this);
 
         const isFirstProgramLoad = this.projectProgramVersion === 0 && hasNewProgram;
         if (hasNewProgram) {
@@ -2344,43 +2354,52 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
             noLib: true,
         };
     }
+}
 
-    /** @internal */
-    private getUnresolvedImports(): SortedReadonlyArray<string> {
-        const sourceFiles = this.program!.getSourceFiles();
-        this.writeLog(`Calculating unresolved imports list of program:: Files:: ${sourceFiles.length}`);
-        tracing?.push(tracing.Phase.Session, "getUnresolvedImports", { count: sourceFiles.length });
-        const ambientModules = this.program!.getTypeChecker().getAmbientModules().map(mod => stripQuotes(mod.getName()));
-        const result = sortAndDeduplicate(flatMap(sourceFiles, sourceFile =>
-            this.extractUnresolvedImportsFromSourceFile(
-                sourceFile,
-                ambientModules,
-            )));
-        tracing?.pop();
-        this.writeLog(`Calculating unresolved imports list of program:: Files:: ${sourceFiles.length} Done: ${JSON.stringify(result)}`);
-        return result;
-    }
+/** @internal */
+export function getUnresolvedImports(
+    program: Program,
+    cachedUnresolvedImportsPerFile: Map<Path, readonly string[]>,
+    writeLog: (s: string) => void,
+): SortedReadonlyArray<string> {
+    const sourceFiles = program.getSourceFiles();
+    writeLog(`Calculating unresolved imports list of program:: Files:: ${sourceFiles.length}`);
+    tracing?.push(tracing.Phase.Session, "getUnresolvedImports", { count: sourceFiles.length });
+    const ambientModules = program.getTypeChecker().getAmbientModules().map(mod => stripQuotes(mod.getName()));
+    const result = sortAndDeduplicate(flatMap(sourceFiles, sourceFile =>
+        extractUnresolvedImportsFromSourceFile(
+            program,
+            sourceFile,
+            ambientModules,
+            cachedUnresolvedImportsPerFile,
+            writeLog,
+        )));
+    tracing?.pop();
+    writeLog(`Calculating unresolved imports list of program:: Files:: ${sourceFiles.length} Done: ${JSON.stringify(result)}`);
+    return result;
+}
 
-    /** @internal */
-    private extractUnresolvedImportsFromSourceFile(
-        file: SourceFile,
-        ambientModules: readonly string[],
-    ): readonly string[] {
-        return getOrUpdate(this.cachedUnresolvedImportsPerFile, file.path, () => {
-            let unresolvedImports: string[] | undefined;
-            this.program!.forEachResolvedModule((resolution, name) => {
-                // pick unresolved non-relative names
-                if (
-                    needsResolutionFromGlobalCache(name, resolution) &&
-                    !ambientModules.some(m => m === name)
-                ) {
-                    unresolvedImports = append(unresolvedImports, parsePackageName(name).packageName);
-                }
-            }, file);
-            this.writeLog(`New unresolvedImports for ${file.path}:: ${JSON.stringify(unresolvedImports || emptyArray)}`);
-            return unresolvedImports || emptyArray;
-        });
-    }
+function extractUnresolvedImportsFromSourceFile(
+    program: Program,
+    file: SourceFile,
+    ambientModules: readonly string[],
+    cachedUnresolvedImportsPerFile: Map<Path, readonly string[]>,
+    writeLog: (s: string) => void,
+): readonly string[] {
+    return getOrUpdate(cachedUnresolvedImportsPerFile, file.path, () => {
+        let unresolvedImports: string[] | undefined;
+        program.forEachResolvedModule((resolution, name) => {
+            // pick unresolved non-relative names
+            if (
+                needsResolutionFromGlobalCache(name, resolution) &&
+                !ambientModules.some(m => m === name)
+            ) {
+                unresolvedImports = append(unresolvedImports, parsePackageName(name).packageName);
+            }
+        }, file);
+        writeLog(`New unresolvedImports for ${file.path}:: ${JSON.stringify(unresolvedImports || emptyArray)}`);
+        return unresolvedImports || emptyArray;
+    });
 }
 
 /**