Incremental testing for program structure and resolutions and fixes (#55814)

Author: sheetalkamat

src/compiler/program.ts

@@ -1109,7 +1109,8 @@ export function getInferredLibraryNameResolveFrom(options: CompilerOptions, curr
     return combinePaths(containingDirectory, `__lib_node_modules_lookup_${libFileName}__.ts`);
 }
 
-function getLibraryNameFromLibFileName(libFileName: string) {
+/** @internal */
+export function getLibraryNameFromLibFileName(libFileName: string) {
     // Support resolving to lib.dom.d.ts -> @typescript/lib-dom, and
     //                      lib.dom.iterable.d.ts -> @typescript/lib-dom/iterable
     //                      lib.es2015.symbol.wellknown.d.ts -> @typescript/lib-es2015/symbol-wellknown

src/compiler/resolutionCache.ts

@@ -65,6 +65,7 @@ import {
     perfLogger,
     PollingInterval,
     ProjectReference,
+    ResolutionCache,
     ResolutionCacheHost,
     ResolutionMode,
     ResolvedModule,
@@ -341,6 +342,8 @@ export interface Watch<T> {
     getCurrentProgram(): T;
     /** Closes the watch */
     close(): void;
+    /** @internal */
+    getResolutionCache(): ResolutionCache;
 }
 
 /**
@@ -552,8 +555,8 @@ export function createWatchProgram<T extends BuilderProgram>(host: WatchCompiler
     if (configFileName) updateExtendedConfigFilesWatches(toPath(configFileName), compilerOptions, watchOptions, WatchType.ExtendedConfigFile);
 
     return configFileName ?
-        { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, close } :
-        { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, updateRootFileNames, close };
+        { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, close, getResolutionCache } :
+        { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, updateRootFileNames, close, getResolutionCache };
 
     function close() {
         clearInvalidateResolutionsOfFailedLookupLocations();
@@ -593,6 +596,10 @@ export function createWatchProgram<T extends BuilderProgram>(host: WatchCompiler
         }
     }
 
+    function getResolutionCache() {
+        return resolutionCache;
+    }
+
     function getCurrentBuilderProgram() {
         return builderProgram;
     }

src/compiler/watchPublic.ts

@@ -999,6 +999,7 @@ export class ProjectService {
     private currentPluginEnablementPromise?: Promise<void>;
 
     /** @internal */ verifyDocumentRegistry = noop;
+    /** @internal */ verifyProgram: (project: Project) => void = noop;
 
     readonly jsDocParsingMode: JSDocParsingMode | undefined;
 

src/harness/incrementalUtils.ts

@@ -539,7 +539,6 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
             // If files are listed explicitly or allowJs is specified, allow all extensions
             this.compilerOptions.allowNonTsExtensions = true;
         }
-
         switch (projectService.serverMode) {
             case LanguageServiceMode.Semantic:
                 this.languageServiceEnabled = true;
@@ -1541,13 +1540,13 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
                     if (!newFile || (f.resolvedPath === f.path && newFile.resolvedPath !== f.path)) {
                         // new program does not contain this file - detach it from the project
                         // - remove resolutions only if the new program doesnt contain source file by the path (not resolvedPath since path is used for resolution)
-                        this.detachScriptInfoFromProject(f.fileName, !!this.program.getSourceFileByPath(f.path));
+                        this.detachScriptInfoFromProject(f.fileName, !!this.program.getSourceFileByPath(f.path), /*syncDirWatcherRemove*/ true);
                     }
                 }
 
                 oldProgram.forEachResolvedProjectReference(resolvedProjectReference => {
                     if (!this.program!.getResolvedProjectReferenceByPath(resolvedProjectReference.sourceFile.path)) {
-                        this.detachScriptInfoFromProject(resolvedProjectReference.sourceFile.fileName);
+                        this.detachScriptInfoFromProject(resolvedProjectReference.sourceFile.fileName, /*noRemoveResolution*/ undefined, /*syncDirWatcherRemove*/ true);
                     }
                 });
             }
@@ -1603,6 +1602,7 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
             }
         }
 
+        this.projectService.verifyProgram(this);
         if (this.exportMapCache && !this.exportMapCache.isEmpty()) {
             this.exportMapCache.releaseSymbols();
             if (this.hasAddedorRemovedFiles || oldProgram && !this.program!.structureIsReused) {
@@ -1671,12 +1671,12 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
         this.projectService.sendPerformanceEvent(kind, durationMs);
     }
 
-    private detachScriptInfoFromProject(uncheckedFileName: string, noRemoveResolution?: boolean) {
+    private detachScriptInfoFromProject(uncheckedFileName: string, noRemoveResolution?: boolean, syncDirWatcherRemove?: boolean) {
         const scriptInfoToDetach = this.projectService.getScriptInfo(uncheckedFileName);
         if (scriptInfoToDetach) {
             scriptInfoToDetach.detachFromProject(this);
             if (!noRemoveResolution) {
-                this.resolutionCache.removeResolutionsOfFile(scriptInfoToDetach.path);
+                this.resolutionCache.removeResolutionsOfFile(scriptInfoToDetach.path, syncDirWatcherRemove);
             }
         }
     }
@@ -2516,16 +2516,17 @@ export class AutoImportProviderProject extends Project {
             );
             if (entrypoints) {
                 const real = host.realpath?.(packageJson.packageDirectory);
-                const isSymlink = real && real !== packageJson.packageDirectory;
+                const realPath = real ? hostProject.toPath(real) : undefined;
+                const isSymlink = realPath && realPath !== hostProject.toPath(packageJson.packageDirectory);
                 if (isSymlink) {
                     symlinkCache.setSymlinkedDirectory(packageJson.packageDirectory, {
-                        real,
-                        realPath: hostProject.toPath(real),
+                        real: real!,
+                        realPath,
                     });
                 }
 
                 return mapDefined(entrypoints, entrypoint => {
-                    const resolvedFileName = isSymlink ? entrypoint.replace(packageJson.packageDirectory, real) : entrypoint;
+                    const resolvedFileName = isSymlink ? entrypoint.replace(packageJson.packageDirectory, real!) : entrypoint;
                     if (!program.getSourceFile(resolvedFileName) && !(isSymlink && program.getSourceFile(entrypoint))) {
                         return resolvedFileName;
                     }

src/server/editorServices.ts

@@ -45,12 +45,10 @@ export function commandLineCallbacks(
     };
 }
 
-export function baselinePrograms(baseline: string[], getPrograms: () => readonly CommandLineProgram[], oldPrograms: readonly (CommandLineProgram | undefined)[], baselineDependencies: boolean | undefined) {
-    const programs = getPrograms();
+export function baselinePrograms(baseline: string[], programs: readonly CommandLineProgram[], oldPrograms: readonly (CommandLineProgram | undefined)[], baselineDependencies: boolean | undefined) {
     for (let i = 0; i < programs.length; i++) {
         baselineProgram(baseline, programs[i], oldPrograms[i], baselineDependencies);
     }
-    return programs;
 }
 
 function baselineProgram(baseline: string[], [program, builderProgram]: CommandLineProgram, oldProgram: CommandLineProgram | undefined, baselineDependencies: boolean | undefined) {

src/server/project.ts

@@ -156,10 +156,11 @@ export function testTscCompile(input: TestTscCompile) {
 
     function additionalBaseline(sys: TscCompileSystem) {
         const { baselineSourceMap, baselineReadFileCalls, baselinePrograms: shouldBaselinePrograms, baselineDependencies } = input;
-        if (input.computeDtsSignatures) storeDtsSignatures(sys, getPrograms!());
+        const programs = getPrograms!();
+        if (input.computeDtsSignatures) storeDtsSignatures(sys, programs);
         if (shouldBaselinePrograms) {
             const baseline: string[] = [];
-            baselinePrograms(baseline, getPrograms!, ts.emptyArray, baselineDependencies);
+            baselinePrograms(baseline, programs, ts.emptyArray, baselineDependencies);
             sys.write(baseline.join("\n"));
         }
         if (baselineReadFileCalls) {

src/testRunner/unittests/helpers/baseline.ts

@@ -1,3 +1,7 @@
+import {
+    verifyProgramStructure,
+    verifyResolutionCache,
+} from "../../../harness/incrementalUtils";
 import {
     patchHostForBuildInfoReadWrite,
 } from "../../_namespaces/fakes";
@@ -38,6 +42,9 @@ export interface TscWatchCompileChange<T extends ts.BuilderProgram = ts.EmitAndS
         programs: readonly CommandLineProgram[],
         watchOrSolution: WatchOrSolution<T>,
     ) => void;
+    // TODO:: sheetal: Needing these fields are technically issues that need to be fixed later
+    symlinksNotReflected?: readonly string[];
+    skipStructureCheck?: true;
 }
 export interface TscWatchCheckOptions {
     baselineSourceMap?: boolean;
@@ -214,6 +221,7 @@ export interface RunWatchBaseline<T extends ts.BuilderProgram> extends BaselineB
     sys: TscWatchSystem;
     getPrograms: () => readonly CommandLineProgram[];
     watchOrSolution: WatchOrSolution<T>;
+    useSourceOfProjectReferenceRedirect?: () => boolean;
 }
 export function runWatchBaseline<T extends ts.BuilderProgram = ts.EmitAndSemanticDiagnosticsBuilderProgram>({
     scenario,
@@ -227,6 +235,7 @@ export function runWatchBaseline<T extends ts.BuilderProgram = ts.EmitAndSemanti
     baselineDependencies,
     edits,
     watchOrSolution,
+    useSourceOfProjectReferenceRedirect,
 }: RunWatchBaseline<T>) {
     baseline.push(`${sys.getExecutingFilePath()} ${commandLineArgs.join(" ")}`);
     let programs = watchBaseline({
@@ -240,7 +249,7 @@ export function runWatchBaseline<T extends ts.BuilderProgram = ts.EmitAndSemanti
     });
 
     if (edits) {
-        for (const { caption, edit, timeouts } of edits) {
+        for (const { caption, edit, timeouts, symlinksNotReflected, skipStructureCheck } of edits) {
             oldSnap = applyEdit(sys, baseline, edit, caption);
             timeouts(sys, programs, watchOrSolution);
             programs = watchBaseline({
@@ -251,6 +260,10 @@ export function runWatchBaseline<T extends ts.BuilderProgram = ts.EmitAndSemanti
                 oldSnap,
                 baselineSourceMap,
                 baselineDependencies,
+                caption,
+                resolutionCache: !skipStructureCheck ? (watchOrSolution as ts.WatchOfConfigFile<T> | undefined)?.getResolutionCache?.() : undefined,
+                useSourceOfProjectReferenceRedirect,
+                symlinksNotReflected,
             });
         }
     }
@@ -268,20 +281,94 @@ export function isWatch(commandLineArgs: readonly string[]) {
 export interface WatchBaseline extends BaselineBase, TscWatchCheckOptions {
     oldPrograms: readonly (CommandLineProgram | undefined)[];
     getPrograms: () => readonly CommandLineProgram[];
+    caption?: string;
+    resolutionCache?: ts.ResolutionCache;
+    useSourceOfProjectReferenceRedirect?: () => boolean;
+    symlinksNotReflected?: readonly string[];
 }
-export function watchBaseline({ baseline, getPrograms, oldPrograms, sys, oldSnap, baselineSourceMap, baselineDependencies }: WatchBaseline) {
+export function watchBaseline({
+    baseline,
+    getPrograms,
+    oldPrograms,
+    sys,
+    oldSnap,
+    baselineSourceMap,
+    baselineDependencies,
+    caption,
+    resolutionCache,
+    useSourceOfProjectReferenceRedirect,
+    symlinksNotReflected,
+}: WatchBaseline) {
     if (baselineSourceMap) generateSourceMapBaselineFiles(sys);
     sys.serializeOutput(baseline);
-    const programs = baselinePrograms(baseline, getPrograms, oldPrograms, baselineDependencies);
+    const programs = getPrograms();
+    baselinePrograms(baseline, programs, oldPrograms, baselineDependencies);
     sys.serializeWatches(baseline);
     baseline.push(`exitCode:: ExitStatus.${ts.ExitStatus[sys.exitCode as ts.ExitStatus]}`, "");
     sys.diff(baseline, oldSnap);
     sys.writtenFiles.forEach((value, key) => {
         assert.equal(value, 1, `Expected to write file ${key} only once`);
     });
+    // Verify program structure and resolution cache when incremental edit with tsc --watch (without build mode)
+    if (resolutionCache && programs.length) {
+        ts.Debug.assert(programs.length === 1);
+        verifyProgramStructureAndResolutionCache(caption!, sys, programs[0][0], resolutionCache, useSourceOfProjectReferenceRedirect, symlinksNotReflected);
+    }
     sys.writtenFiles.clear();
     return programs;
 }
+function verifyProgramStructureAndResolutionCache(
+    caption: string,
+    sys: TscWatchSystem,
+    program: ts.Program,
+    resolutionCache: ts.ResolutionCache,
+    useSourceOfProjectReferenceRedirect?: () => boolean,
+    symlinksNotReflected?: readonly string[],
+) {
+    const options = program.getCompilerOptions();
+    const compilerHost = ts.createCompilerHostWorker(options, /*setParentNodes*/ undefined, sys);
+    compilerHost.trace = ts.noop;
+    compilerHost.writeFile = ts.notImplemented;
+    compilerHost.useSourceOfProjectReferenceRedirect = useSourceOfProjectReferenceRedirect;
+    const readFile = compilerHost.readFile;
+    compilerHost.readFile = fileName => {
+        const text = readFile.call(compilerHost, fileName);
+        if (!ts.contains(symlinksNotReflected, fileName)) return text;
+        // Handle symlinks that dont reflect the watch change
+        ts.Debug.assert(sys.toPath(sys.realpath(fileName)) !== sys.toPath(fileName));
+        const file = program.getSourceFile(fileName)!;
+        ts.Debug.assert(file.text !== text);
+        return file.text;
+    };
+    verifyProgramStructure(
+        ts.createProgram({
+            rootNames: program.getRootFileNames(),
+            options,
+            projectReferences: program.getProjectReferences(),
+            host: compilerHost,
+        }),
+        program,
+        caption,
+    );
+    verifyResolutionCache(resolutionCache, program, {
+        ...compilerHost,
+
+        getCompilerHost: () => compilerHost,
+        toPath: fileName => sys.toPath(fileName),
+        getCompilationSettings: () => options,
+        fileIsOpen: ts.returnFalse,
+        getCurrentProgram: () => program,
+
+        watchDirectoryOfFailedLookupLocation: ts.returnNoopFileWatcher,
+        watchAffectingFileLocation: ts.returnNoopFileWatcher,
+        onInvalidatedResolution: ts.noop,
+        watchTypeRootsDirectory: ts.returnNoopFileWatcher,
+        onChangedAutomaticTypeDirectiveNames: ts.noop,
+        scheduleInvalidateResolutionsOfFailedLookupLocations: ts.noop,
+        getCachedDirectoryStructureHost: ts.returnUndefined,
+        writeLog: ts.noop,
+    }, caption);
+}
 export interface VerifyTscWatch extends TscWatchCompile {
     baselineIncremental?: boolean;
 }

src/testRunner/unittests/helpers/tsc.ts

@@ -489,6 +489,7 @@ function patchHostTimeouts(
 export interface TestSessionOptions extends ts.server.SessionOptions {
     logger: Logger;
     allowNonBaseliningLogger?: boolean;
+    disableAutomaticTypingAcquisition?: boolean;
 }
 
 export type TestSessionRequest<T extends ts.server.protocol.Request> = Pick<T, "command" | "arguments">;
@@ -543,7 +544,7 @@ export class TestSession extends ts.server.Session {
 
 export function createSession(host: TestServerHost, opts: Partial<TestSessionOptions> = {}) {
     const logger = opts.logger || createHasErrorMessageLogger();
-    if (opts.typingsInstaller === undefined) {
+    if (!opts.disableAutomaticTypingAcquisition && opts.typingsInstaller === undefined) {
         opts.typingsInstaller = new TestTypingsInstaller(host.getHostSpecificPath("/a/data/"), /*throttleLimit*/ 5, host, logger);
     }
 
@@ -556,7 +557,6 @@ export function createSession(host: TestServerHost, opts: Partial<TestSessionOpt
         cancellationToken: ts.server.nullCancellationToken,
         useSingleInferredProject: false,
         useInferredProjectPerProjectRoot: false,
-        typingsInstaller: undefined!, // TODO: GH#18217
         byteLength: Buffer.byteLength,
         hrtime: process.hrtime,
         logger,