All tsserver unittests use session and typing installer (#56337)

Author: sheetalkamat

src/harness/fourslashImpl.ts

@@ -6,7 +6,7 @@ import * as Utils from "./_namespaces/Utils";
 import * as vfs from "./_namespaces/vfs";
 import * as vpath from "./_namespaces/vpath";
 import {
-    Logger,
+    LoggerWithInMemoryLogs,
 } from "./tsserverLogger";
 
 import ArrayOrSingle = FourSlashInterface.ArrayOrSingle;
@@ -259,7 +259,7 @@ export class TestState {
 
     private inputFiles = new Map<string, string>(); // Map between inputFile's fileName and its content for easily looking up when resolving references
 
-    private logger: Logger | undefined;
+    private logger: LoggerWithInMemoryLogs | undefined;
 
     private static getDisplayPartsJson(displayParts: ts.SymbolDisplayPart[] | undefined) {
         let result = "";
@@ -519,7 +519,7 @@ export class TestState {
         if (this.logger) {
             Harness.Baseline.runBaseline(
                 `tsserver/fourslashServer/${ts.getBaseFileName(this.originalInputFileName).replace(".ts", ".js")}`,
-                this.logger.logs!.join("\n"),
+                this.logger.logs.join("\n"),
             );
         }
     }

src/harness/harnessLanguageService.ts

@@ -17,7 +17,7 @@ import {
 import {
     createLoggerWithInMemoryLogs,
     HarnessLSCouldNotResolveModule,
-    Logger,
+    LoggerWithInMemoryLogs,
 } from "./tsserverLogger";
 import {
     createWatchUtils,
@@ -130,7 +130,7 @@ export interface LanguageServiceAdapter {
     getLanguageService(): ts.LanguageService;
     getClassifier(): ts.Classifier;
     getPreProcessedFileInfo(fileName: string, fileContents: string): ts.PreProcessedFileInfo;
-    getLogger(): Logger | undefined;
+    getLogger(): LoggerWithInMemoryLogs | undefined;
 }
 
 export abstract class LanguageServiceAdapterHost {
@@ -611,7 +611,7 @@ export class ServerLanguageServiceAdapter implements LanguageServiceAdapter {
     private host: SessionClientHost;
     private client: ts.server.SessionClient;
     private server: FourslashSession;
-    private logger: Logger;
+    private logger: LoggerWithInMemoryLogs;
     constructor(cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) {
         // This is the main host that tests use to direct tests
         const clientHost = new SessionClientHost(cancellationToken, options);

src/harness/incrementalUtils.ts

@@ -431,6 +431,7 @@ function verifyProgram(service: ts.server.ProjectService, project: ts.server.Pro
     const getDefaultLibLocation = compilerHost.getDefaultLibLocation!;
     compilerHost.getDefaultLibLocation = () => ts.getNormalizedAbsolutePath(getDefaultLibLocation(), service.host.getCurrentDirectory());
     compilerHost.getDefaultLibFileName = options => ts.combinePaths(compilerHost.getDefaultLibLocation!(), ts.getDefaultLibFileName(options));
+    compilerHost.trace = ts.noop; // We dont want to update host just because of trace
     const readFile = compilerHost.readFile;
     compilerHost.readFile = fileName => {
         const path = project.toPath(fileName);

src/harness/tsserverLogger.ts

@@ -50,24 +50,31 @@ export function nullLogger(): Logger {
 }
 
 export function createHasErrorMessageLogger(): Logger {
-    return {
-        ...nullLogger(),
-        msg: (s, type) => ts.Debug.fail(`Error: ${s}, type: ${type}`),
-    };
+    const logger = nullLogger();
+    logger.msg = (s, type) => ts.Debug.fail(`Error: ${s}, type: ${type}`);
+    return logger;
 }
-function handleLoggerGroup(logger: Logger): Logger {
+function handleLoggerGroup(logger: Logger, host: ts.server.ServerHost, logText: (s: string) => void, sanitizeLibs: true | undefined): Logger {
+    logger.hasLevel = ts.returnTrue;
+    logger.loggingEnabled = ts.returnTrue;
+    logger.host = host;
+    if (host) logText(`currentDirectory:: ${host.getCurrentDirectory()} useCaseSensitiveFileNames: ${host.useCaseSensitiveFileNames}`);
+
     let inGroup = false;
     let firstInGroup = false;
     logger.startGroup = () => {
         inGroup = true;
         firstInGroup = true;
     };
     logger.endGroup = () => inGroup = false;
-    const originalInfo = logger.info;
-    logger.info = s => msg(s, ts.server.Msg.Info, s => originalInfo.call(logger, s));
-    logger.log = s => originalInfo.call(logger, s);
+    logger.info = s => msg(s, ts.server.Msg.Info, log);
+    logger.log = log;
     return logger;
 
+    function log(s: string) {
+        logText((sanitizeLibs ? sanitizeLibFileText : ts.identity)(sanitizeLog(s)));
+    }
+
     function msg(s: string, type = ts.server.Msg.Err, write: (s: string) => void) {
         s = `[${nowString(logger)}] ${s}`;
         if (!inGroup || firstInGroup) s = padStringRight(type + " seq", "          ") + s;
@@ -86,16 +93,19 @@ export function nowString(logger: Logger) {
     return `hh:mm:ss:mss`;
 }
 
-export function createLoggerWritingToConsole(host: ts.server.ServerHost) {
-    return handleLoggerGroup({
-        ...nullLogger(),
-        hasLevel: ts.returnTrue,
-        loggingEnabled: ts.returnTrue,
-        perftrc: s => console.log(s),
-        info: s => console.log(s),
-        msg: (s, type) => console.log(`${type}:: ${s}`),
+export function createLoggerWritingToConsole(host: ts.server.ServerHost, sanitizeLibs?: true) {
+    const logger = createHasErrorMessageLogger();
+    logger.logs = [];
+    logger.logs.push = (...args) => {
+        args.forEach(s => console.log(s));
+        return 0;
+    };
+    return handleLoggerGroup(
+        logger,
         host,
-    });
+        s => console.log(s),
+        sanitizeLibs,
+    ) as LoggerWithInMemoryLogs;
 }
 
 export function sanitizeLog(s: string): string {
@@ -117,6 +127,7 @@ export function sanitizeLog(s: string): string {
     s = s.replace(/"exportMapKey":\s*"\d+ \d+ /g, match => match.replace(/ \d+ /, ` * `));
     s = s.replace(/getIndentationAtPosition: getCurrentSourceFile: \d+(?:\.\d+)?/, `getIndentationAtPosition: getCurrentSourceFile: *`);
     s = s.replace(/getIndentationAtPosition: computeIndentation\s*: \d+(?:\.\d+)?/, `getIndentationAtPosition: computeIndentation: *`);
+    s = replaceAll(s, `@ts${ts.versionMajorMinor}`, `@tsFakeMajor.Minor`);
     s = sanitizeHarnessLSException(s);
     return s;
 }
@@ -135,16 +146,12 @@ export function sanitizeLibFileText(s: string): string {
     return s;
 }
 
-export function createLoggerWithInMemoryLogs(host: ts.server.ServerHost, sanitizeLibs?: true): Logger {
+export interface LoggerWithInMemoryLogs extends Logger {
+    logs: string[];
+}
+
+export function createLoggerWithInMemoryLogs(host: ts.server.ServerHost, sanitizeLibs?: true): LoggerWithInMemoryLogs {
     const logger = createHasErrorMessageLogger();
-    const logs: string[] = [];
-    if (host) logs.push(`currentDirectory:: ${host.getCurrentDirectory()} useCaseSensitiveFileNames: ${host.useCaseSensitiveFileNames}`);
-    return handleLoggerGroup({
-        ...logger,
-        logs,
-        hasLevel: ts.returnTrue,
-        loggingEnabled: ts.returnTrue,
-        info: s => logs.push((sanitizeLibs ? sanitizeLibFileText : ts.identity)(sanitizeLog(s))),
-        host,
-    });
+    logger.logs = [];
+    return handleLoggerGroup(logger, host, s => logger.logs!.push(s), sanitizeLibs) as LoggerWithInMemoryLogs;
 }

src/server/session.ts

@@ -1131,9 +1131,10 @@ export class Session<TMessage = string> implements EventSender {
     }
 
     private projectsUpdatedInBackgroundEvent(openFiles: string[]): void {
-        this.projectService.logger.info(`got projects updated in background, updating diagnostics for ${openFiles}`);
+        this.projectService.logger.info(`got projects updated in background ${openFiles}`);
         if (openFiles.length) {
             if (!this.suppressDiagnosticEvents && !this.noGetErrOnBackgroundUpdate) {
+                this.projectService.logger.info(`Queueing diagnostics update for ${openFiles}`);
                 // For now only queue error checking for open files. We can change this to include non open files as well
                 this.errorCheck.startNew(next => this.updateErrorCheck(next, openFiles, 100, /*requireOpen*/ true));
             }
@@ -1193,7 +1194,7 @@ export class Session<TMessage = string> implements EventSender {
     public send(msg: protocol.Message) {
         if (msg.type === "event" && !this.canUseEvents) {
             if (this.logger.hasLevel(LogLevel.verbose)) {
-                this.logger.info(`Session does not support events: ignored event: ${JSON.stringify(msg)}`);
+                this.logger.info(`Session does not support events: ignored event: ${stringifyIndented(msg)}`);
             }
             return;
         }

src/testRunner/unittests/helpers/tscWatch.ts

@@ -20,6 +20,8 @@ import {
 import {
     changeToHostTrackingWrittenFiles,
     File,
+    SerializeOutputOrder,
+    StateLogger,
     TestServerHost,
     TestServerHostTrackingWrittenFiles,
 } from "./virtualFileSystemWithWatch";
@@ -63,13 +65,12 @@ export interface TscWatchCompile extends TscWatchCompileBase {
 export const noopChange: TscWatchCompileChange = {
     caption: "No change",
     edit: ts.noop,
-    timeouts: sys => sys.logTimeoutQueueLength(),
+    timeouts: ts.noop,
 };
 
-export type SystemSnap = ReturnType<TestServerHost["snap"]>;
 function tscWatchCompile(input: TscWatchCompile) {
     it("tsc-watch:: Generates files matching the baseline", () => {
-        const { sys, baseline, oldSnap } = createBaseline(input.sys());
+        const { sys, baseline } = createBaseline(input.sys());
         const {
             scenario,
             subScenario,
@@ -92,7 +93,6 @@ function tscWatchCompile(input: TscWatchCompile) {
             commandLineArgs,
             sys,
             baseline,
-            oldSnap,
             getPrograms,
             baselineSourceMap,
             baselineDependencies,
@@ -102,44 +102,21 @@ function tscWatchCompile(input: TscWatchCompile) {
     });
 }
 
-export interface TestServerHostWithTimeoutLogging {
-    logTimeoutQueueLength(): void;
-}
-
-export type TscWatchSystem = TestServerHostTrackingWrittenFiles & TestServerHostWithTimeoutLogging;
+export type TscWatchSystem = TestServerHostTrackingWrittenFiles;
 
-function changeToTestServerHostWithTimeoutLogging(inputHost: TestServerHostTrackingWrittenFiles, baseline: string[]): TscWatchSystem {
-    const host = inputHost as TscWatchSystem;
-    const originalRunQueuedTimeoutCallbacks = host.runQueuedTimeoutCallbacks;
-    const originalRunQueuedImmediateCallbacks = host.runQueuedImmediateCallbacks;
-    host.runQueuedTimeoutCallbacks = runQueuedTimeoutCallbacks;
-    host.runQueuedImmediateCallbacks = runQueuedImmediateCallbacks;
-    host.logTimeoutQueueLength = logTimeoutQueueLength;
+function changeToTestServerHostWithTimeoutLogging(host: TestServerHostTrackingWrittenFiles, baseline: string[]): TscWatchSystem {
+    const logger: StateLogger = {
+        log: s => baseline.push(s),
+        logs: baseline,
+    };
+    host.timeoutCallbacks.switchToBaseliningInvoke(logger, SerializeOutputOrder.BeforeDiff);
+    host.immediateCallbacks.switchToBaseliningInvoke(logger, SerializeOutputOrder.BeforeDiff);
     return host;
-
-    function logTimeoutQueueLength() {
-        baseline.push(host.timeoutCallbacks.log());
-        baseline.push(host.immediateCallbacks.log());
-    }
-
-    function runQueuedTimeoutCallbacks(timeoutId?: number) {
-        baseline.push(`Before running ${host.timeoutCallbacks.log()}`);
-        if (timeoutId !== undefined) baseline.push(`Invoking ${host.timeoutCallbacks.callbackType} callback:: timeoutId:: ${timeoutId}:: ${host.timeoutCallbacks.map[timeoutId].args[0]}`);
-        originalRunQueuedTimeoutCallbacks.call(host, timeoutId);
-        baseline.push(`After running ${host.timeoutCallbacks.log()}`);
-    }
-
-    function runQueuedImmediateCallbacks() {
-        baseline.push(`Before running ${host.immediateCallbacks.log()}`);
-        originalRunQueuedImmediateCallbacks.call(host);
-        baseline.push(`After running ${host.immediateCallbacks.log()}`);
-    }
 }
 
 export interface BaselineBase {
     baseline: string[];
     sys: TscWatchSystem;
-    oldSnap: SystemSnap;
 }
 
 export interface Baseline extends BaselineBase, CommandLineCallbacks {
@@ -153,9 +130,9 @@ export function createBaseline(system: TestServerHost, modifySystem?: (sys: Test
     const sys = changeToTestServerHostWithTimeoutLogging(changeToHostTrackingWrittenFiles(initialSys), baseline);
     baseline.push(`currentDirectory:: ${sys.getCurrentDirectory()} useCaseSensitiveFileNames: ${sys.useCaseSensitiveFileNames}`);
     baseline.push("Input::");
-    sys.diff(baseline);
+    sys.serializeState(baseline, SerializeOutputOrder.None);
     const { cb, getPrograms } = commandLineCallbacks(sys);
-    return { sys, baseline, oldSnap: sys.snap(), cb, getPrograms };
+    return { sys, baseline, cb, getPrograms };
 }
 
 export function createSolutionBuilderWithWatchHostForBaseline(sys: TestServerHost, cb: ts.ExecuteCommandLineCallbacks) {
@@ -208,13 +185,10 @@ function updateWatchHostForBaseline<T extends ts.BuilderProgram>(host: ts.WatchC
 }
 
 export function applyEdit(sys: BaselineBase["sys"], baseline: BaselineBase["baseline"], edit: TscWatchCompileChange["edit"], caption?: TscWatchCompileChange["caption"]) {
-    const oldSnap = sys.snap();
     baseline.push(`Change::${caption ? " " + caption : ""}`, "");
     edit(sys);
     baseline.push("Input::");
-    sys.diff(baseline, oldSnap);
-    sys.serializeWatches(baseline);
-    return sys.snap();
+    sys.serializeState(baseline, SerializeOutputOrder.AfterDiff);
 }
 
 export interface RunWatchBaseline<T extends ts.BuilderProgram> extends BaselineBase, TscWatchCompileBase<T> {
@@ -230,7 +204,6 @@ export function runWatchBaseline<T extends ts.BuilderProgram = ts.EmitAndSemanti
     getPrograms,
     sys,
     baseline,
-    oldSnap,
     baselineSourceMap,
     baselineDependencies,
     edits,
@@ -243,21 +216,19 @@ export function runWatchBaseline<T extends ts.BuilderProgram = ts.EmitAndSemanti
         getPrograms,
         oldPrograms: ts.emptyArray,
         sys,
-        oldSnap,
         baselineSourceMap,
         baselineDependencies,
     });
 
     if (edits) {
         for (const { caption, edit, timeouts, symlinksNotReflected, skipStructureCheck } of edits) {
-            oldSnap = applyEdit(sys, baseline, edit, caption);
+            applyEdit(sys, baseline, edit, caption);
             timeouts(sys, programs, watchOrSolution);
             programs = watchBaseline({
                 baseline,
                 getPrograms,
                 oldPrograms: programs,
                 sys,
-                oldSnap,
                 baselineSourceMap,
                 baselineDependencies,
                 caption,
@@ -291,7 +262,6 @@ export function watchBaseline({
     getPrograms,
     oldPrograms,
     sys,
-    oldSnap,
     baselineSourceMap,
     baselineDependencies,
     caption,
@@ -300,21 +270,18 @@ export function watchBaseline({
     symlinksNotReflected,
 }: WatchBaseline) {
     if (baselineSourceMap) generateSourceMapBaselineFiles(sys);
-    sys.serializeOutput(baseline);
     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`);
     });
+    sys.serializeState(baseline, SerializeOutputOrder.BeforeDiff);
+    baselinePrograms(baseline, programs, oldPrograms, baselineDependencies);
+    baseline.push(`exitCode:: ExitStatus.${ts.ExitStatus[sys.exitCode as ts.ExitStatus]}`, "");
     // 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(