More refactoring of tsc baselines to help with easier updates

src/testRunner/unittests/tsbuild/amdModulesWithOut.ts

@@ -19,20 +19,20 @@ namespace ts {
             modifyFs,
             modifyAgainFs
         }: VerifyOutFileScenarioInput) {
-            verifyTscIncrementalEdits({
+            verifyTscWithEdits({
                 scenario: "amdModulesWithOut",
                 subScenario,
                 fs: () => outFileFs,
                 commandLineArgs: ["--b", "/src/app", "--verbose"],
                 baselineSourceMap: true,
                 modifyFs,
-                incrementalScenarios: [
+                edits: [
                     {
-                        buildKind: BuildKind.IncrementalDtsUnchanged,
+                        subScenario: "incremental-declaration-doesnt-change",
                         modifyFs: fs => appendText(fs, "/src/lib/file1.ts", "console.log(x);")
                     },
                     ...(modifyAgainFs ? [{
-                        buildKind: BuildKind.IncrementalHeadersChange,
+                        subScenario: "incremental-headers-change-without-dts-changes",
                         modifyFs: modifyAgainFs
                     }] : emptyArray),
                 ]

src/testRunner/unittests/tsbuild/configFileErrors.ts

@@ -9,7 +9,7 @@ namespace ts {
     });
 
     describe("unittests:: tsbuild:: configFileErrors:: reports syntax errors in config file", () => {
-        verifyTscIncrementalEdits({
+        verifyTscWithEdits({
             scenario: "configFileErrors",
             subScenario: "reports syntax errors in config file",
             fs: () => loadProjectFromFiles({
@@ -27,21 +27,18 @@ namespace ts {
 }`
             }),
             commandLineArgs: ["--b", "/src/tsconfig.json"],
-            incrementalScenarios: [
+            edits: [
                 {
-                    buildKind: BuildKind.IncrementalDtsUnchanged,
                     modifyFs: fs => replaceText(fs, "/src/tsconfig.json", ",", `,
         "declaration": true,`),
                     subScenario: "reports syntax errors after change to config file"
                 },
                 {
-                    buildKind: BuildKind.IncrementalDtsUnchanged,
                     modifyFs: fs => appendText(fs, "/src/a.ts", "export function fooBar() { }"),
                     subScenario: "reports syntax errors after change to ts file"
                 },
                 noChangeRun,
                 {
-                    buildKind: BuildKind.IncrementalDtsChange,
                     modifyFs: fs => fs.writeFileSync(
                         "/src/tsconfig.json",
                         JSON.stringify({

src/testRunner/unittests/tsbuild/containerOnlyReferenced.ts

@@ -1,11 +1,11 @@
 namespace ts {
     describe("unittests:: tsbuild:: when containerOnly project is referenced", () => {
-        verifyTscSerializedIncrementalEdits({
+        verifyTscWithEdits({
             scenario: "containerOnlyReferenced",
             subScenario: "verify that subsequent builds after initial build doesnt build anything",
             fs: () => loadProjectFromDisk("tests/projects/containerOnlyReferenced"),
             commandLineArgs: ["--b", "/src", "--verbose"],
-            incrementalScenarios: noChangeOnlyRuns
+            edits: noChangeOnlyRuns
         });
     });
 }

src/testRunner/unittests/tsbuild/emitDeclarationOnly.ts

@@ -9,24 +9,24 @@ namespace ts {
         });
 
         function verifyEmitDeclarationOnly(disableMap?: true) {
-            verifyTscSerializedIncrementalEdits({
+            verifyTscWithEdits({
                 subScenario: `only dts output in circular import project with emitDeclarationOnly${disableMap ? "" : " and declarationMap"}`,
                 fs: () => projFs,
                 scenario: "emitDeclarationOnly",
                 commandLineArgs: ["--b", "/src", "--verbose"],
                 modifyFs: disableMap ?
                     (fs => replaceText(fs, "/src/tsconfig.json", `"declarationMap": true,`, "")) :
                     undefined,
-                incrementalScenarios: [{
-                    buildKind: BuildKind.IncrementalDtsChange,
+                edits: [{
+                    subScenario: "incremental-declaration-changes",
                     modifyFs: fs => replaceText(fs, "/src/src/a.ts", "b: B;", "b: B; foo: any;"),
                 }],
             });
         }
         verifyEmitDeclarationOnly();
         verifyEmitDeclarationOnly(/*disableMap*/ true);
 
-        verifyTscSerializedIncrementalEdits({
+        verifyTscWithEdits({
             subScenario: `only dts output in non circular imports project with emitDeclarationOnly`,
             fs: () => projFs,
             scenario: "emitDeclarationOnly",
@@ -35,17 +35,16 @@ namespace ts {
                 fs.rimrafSync("/src/src/index.ts");
                 replaceText(fs, "/src/src/a.ts", `import { B } from "./b";`, `export class B { prop = "hello"; }`);
             },
-            incrementalScenarios: [
+            edits: [
                 {
-                    buildKind: BuildKind.IncrementalDtsUnchanged,
+                    subScenario: "incremental-declaration-doesnt-change",
                     modifyFs: fs => replaceText(fs, "/src/src/a.ts", "export interface A {", `class C { }
 export interface A {`),
 
                 },
                 {
-                    buildKind: BuildKind.IncrementalDtsChange,
+                    subScenario: "incremental-declaration-changes",
                     modifyFs: fs => replaceText(fs, "/src/src/a.ts", "b: B;", "b: B; foo: any;"),
-
                 },
             ],
         });

src/testRunner/unittests/tsbuild/helpers.ts

@@ -331,21 +331,22 @@ interface Symbol {
         (originalWriteFile || sys.writeFile).call(sys, `${buildInfoPath}.baseline.txt`, text);
     }
 
-    interface VerifyIncrementalCorrectness {
+    interface VerifyTscEditCorrectnessInput {
         scenario: TestTscCompile["scenario"];
         commandLineArgs: TestTscCompile["commandLineArgs"];
         modifyFs: TestTscCompile["modifyFs"];
-        incrementalModifyFs: TscIncremental["modifyFs"];
+        editFs: TestTscEdit["modifyFs"];
         tick: () => void;
         baseFs: vfs.FileSystem;
         newSys: TscCompileSystem;
-        cleanBuildDiscrepancies: TscIncremental["cleanBuildDiscrepancies"];
+        cleanBuildDiscrepancies: TestTscEdit["cleanBuildDiscrepancies"];
     }
-    function verifyIncrementalCorrectness(input: () => VerifyIncrementalCorrectness, index: number, subScenario: TestTscCompile["subScenario"]) {
-        it(`Verify emit output file text is same when built clean for incremental scenario at:: ${index} ${subScenario}`, () => {
+    /** Verify that emit is same as clean build vs building after edit */
+    function verifyTscEditCorrectness(input: () => VerifyTscEditCorrectnessInput, index: number, subScenario: TestTscCompile["subScenario"]) {
+        it(`Verify emit output file text is same when built clean for incremental edit scenario at:: ${index} ${subScenario}`, () => {
             const {
                 scenario, commandLineArgs, cleanBuildDiscrepancies,
-                modifyFs, incrementalModifyFs,
+                modifyFs, editFs,
                 tick, baseFs, newSys
             } = input();
             const sys = testTscCompile({
@@ -356,7 +357,7 @@ interface Symbol {
                 modifyFs: fs => {
                     tick();
                     if (modifyFs) modifyFs(fs);
-                    incrementalModifyFs(fs);
+                    editFs(fs);
                 },
                 disableUseFileVersionAsSignature: true,
             });
@@ -498,136 +499,45 @@ interface Symbol {
         CleanFilePresent,
     }
 
-    export interface TscIncremental {
-        buildKind: BuildKind;
+    export interface TestTscEdit {
         modifyFs: (fs: vfs.FileSystem) => void;
-        subScenario?: string;
+        subScenario: string;
         commandLineArgs?: readonly string[];
         cleanBuildDiscrepancies?: () => ESMap<string, CleanBuildDescrepancy>;
     }
 
-    export interface VerifyTsBuildInput extends VerifyTsBuildInputWorker {
+    export interface VerifyTscWithEditsInput extends VerifyTscWithEditsWorkerInput {
         baselineIncremental?: boolean;
     }
-
-    export function verifyTscIncrementalEdits(input: VerifyTsBuildInput) {
-        verifyTscIncrementalEditsWorker(input);
-        if (input.baselineIncremental) {
-            verifyTscIncrementalEditsWorker({
-                ...input,
-                subScenario: `${input.subScenario} with incremental`,
-                commandLineArgs: [...input.commandLineArgs, "--incremental"],
-            });
-        }
-    }
-
-    export interface VerifyTsBuildInputWorker extends TestTscCompile {
-        incrementalScenarios: TscIncremental[];
-    }
-    function verifyTscIncrementalEditsWorker({
-        subScenario, fs, scenario, commandLineArgs,
-        baselineSourceMap, modifyFs, baselineReadFileCalls, baselinePrograms,
-        incrementalScenarios
-    }: VerifyTsBuildInputWorker) {
-        describe(`tsc ${commandLineArgs.join(" ")} ${scenario}:: ${subScenario}`, () => {
-            let tick: () => void;
-            let sys: TscCompileSystem;
-            let baseFs: vfs.FileSystem;
-            before(() => {
-                ({ fs: baseFs, tick } = getFsWithTime(fs()));
-                sys = testTscCompile({
-                    scenario,
-                    subScenario,
-                    fs: () => baseFs.makeReadonly(),
-                    commandLineArgs,
-                    modifyFs: fs => {
-                        if (modifyFs) modifyFs(fs);
-                        tick();
-                    },
-                    baselineSourceMap,
-                    baselineReadFileCalls,
-                    baselinePrograms
-                });
-                Debug.assert(!!incrementalScenarios.length, `${scenario}/${subScenario}:: No incremental scenarios, you probably want to use verifyTsc instead.`);
-            });
-            after(() => {
-                baseFs = undefined!;
-                sys = undefined!;
-                tick = undefined!;
-            });
-            describe("initialBuild", () => {
-                verifyTscBaseline(() => sys);
-            });
-
-            incrementalScenarios.forEach(({
-                buildKind,
-                modifyFs: incrementalModifyFs,
-                subScenario: incrementalSubScenario,
-                commandLineArgs: incrementalCommandLineArgs,
-                cleanBuildDiscrepancies,
-            }, index) => {
-                describe(incrementalSubScenario || buildKind, () => {
-                    let newSys: TscCompileSystem;
-                    before(() => {
-                        Debug.assert(buildKind !== BuildKind.Initial, "Incremental edit cannot be initial compilation");
-                        tick();
-                        newSys = testTscCompile({
-                            scenario,
-                            subScenario: incrementalSubScenario || subScenario,
-                            buildKind,
-                            fs: () => sys.vfs,
-                            commandLineArgs: incrementalCommandLineArgs || commandLineArgs,
-                            modifyFs: fs => {
-                                tick();
-                                incrementalModifyFs(fs);
-                                tick();
-                            },
-                            baselineSourceMap,
-                            baselineReadFileCalls,
-                            baselinePrograms
-                        });
-                    });
-                    after(() => {
-                        newSys = undefined!;
-                    });
-                    verifyTscBaseline(() => newSys);
-                    verifyIncrementalCorrectness(() => ({
-                        scenario,
-                        baseFs,
-                        newSys,
-                        commandLineArgs: incrementalCommandLineArgs || commandLineArgs,
-                        cleanBuildDiscrepancies,
-                        incrementalModifyFs,
-                        modifyFs,
-                        tick
-                    }), index, incrementalSubScenario || subScenario);
-                });
-            });
-        });
+    export interface VerifyTscWithEditsWorkerInput extends TestTscCompile {
+        edits: TestTscEdit[];
     }
 
-    export function verifyTscSerializedIncrementalEdits(input: VerifyTsBuildInput) {
-        verifyTscSerializedIncrementalEditsWorker(input);
+    /**
+     * Verify non watch tsc invokcation after each edit
+     */
+    export function verifyTscWithEdits(input: VerifyTscWithEditsInput) {
+        verifyTscWithEditsWorker(input);
         if (input.baselineIncremental) {
-            verifyTscSerializedIncrementalEditsWorker({
+            verifyTscWithEditsWorker({
                 ...input,
                 subScenario: `${input.subScenario} with incremental`,
                 commandLineArgs: [...input.commandLineArgs, "--incremental"],
             });
         }
     }
-    function verifyTscSerializedIncrementalEditsWorker({
+    function verifyTscWithEditsWorker({
         subScenario, fs, scenario, commandLineArgs,
         baselineSourceMap, modifyFs, baselineReadFileCalls, baselinePrograms,
-        incrementalScenarios
-    }: VerifyTsBuildInputWorker) {
+        edits
+    }: VerifyTscWithEditsWorkerInput) {
         describe(`tsc ${commandLineArgs.join(" ")} ${scenario}:: ${subScenario} serializedEdits`, () => {
-            Debug.assert(!!incrementalScenarios.length, `${scenario}/${subScenario}:: No incremental scenarios, you probably want to use verifyTsc instead.`);
             let tick: () => void;
             let sys: TscCompileSystem;
             let baseFs: vfs.FileSystem;
-            let incrementalSys: TscCompileSystem[];
+            let editsSys: TscCompileSystem[];
             before(() => {
+                Debug.assert(!!edits.length, `${scenario}/${subScenario}:: No incremental scenarios, you probably want to use verifyTsc instead.`);
                 ({ fs: baseFs, tick } = getFsWithTime(fs()));
                 sys = testTscCompile({
                     scenario,
@@ -642,18 +552,17 @@ interface Symbol {
                     baselineReadFileCalls,
                     baselinePrograms
                 });
-                incrementalScenarios.forEach((
-                    { buildKind, modifyFs, subScenario: incrementalSubScenario, commandLineArgs: incrementalCommandLineArgs },
+                edits.forEach((
+                    { modifyFs, subScenario: editScenario, commandLineArgs: editCommandLineArgs },
                     index
                 ) => {
-                    Debug.assert(buildKind !== BuildKind.Initial, "Incremental edit cannot be initial compilation");
                     tick();
-                    (incrementalSys || (incrementalSys = [])).push(testTscCompile({
+                    (editsSys || (editsSys = [])).push(testTscCompile({
                         scenario,
-                        subScenario: incrementalSubScenario || subScenario,
-                        buildKind,
-                        fs: () => index === 0 ? sys.vfs : incrementalSys[index - 1].vfs,
-                        commandLineArgs: incrementalCommandLineArgs || commandLineArgs,
+                        subScenario: editScenario || subScenario,
+                        diffWithInitial: true,
+                        fs: () => index === 0 ? sys.vfs : editsSys[index - 1].vfs,
+                        commandLineArgs: editCommandLineArgs || commandLineArgs,
                         modifyFs: fs => {
                             tick();
                             modifyFs(fs);
@@ -669,39 +578,38 @@ interface Symbol {
                 baseFs = undefined!;
                 sys = undefined!;
                 tick = undefined!;
-                incrementalSys = undefined!;
+                editsSys = undefined!;
             });
-            describe("serializedBuild", () => {
-
+            describe("tsc invocation after edit", () => {
                 verifyTscBaseline(() => ({
                     baseLine: () => {
                         const { file, text } = sys.baseLine();
                         const texts: string[] = [text];
-                        incrementalSys.forEach((sys, index) => {
-                            const incrementalScenario = incrementalScenarios[index];
+                        editsSys.forEach((sys, index) => {
+                            const incrementalScenario = edits[index];
                             texts.push("");
-                            texts.push(`Change:: ${incrementalScenario.subScenario || incrementalScenario.buildKind}`);
+                            texts.push(`Change:: ${incrementalScenario.subScenario}`);
                             texts.push(sys.baseLine().text);
                         });
                         return { file, text: texts.join("\r\n") };
                     }
                 }));
             });
-            describe("incremental correctness", () => {
-                incrementalScenarios.forEach(({ commandLineArgs: incrementalCommandLineArgs, subScenario, buildKind, cleanBuildDiscrepancies }, index) => verifyIncrementalCorrectness(() => ({
+            describe("tsc invocation after edit and clean build correctness", () => {
+                edits.forEach(({ commandLineArgs: editCommandLineArgs, subScenario, cleanBuildDiscrepancies }, index) => verifyTscEditCorrectness(() => ({
                     scenario,
                     baseFs,
-                    newSys: incrementalSys[index],
-                    commandLineArgs: incrementalCommandLineArgs || commandLineArgs,
+                    newSys: editsSys[index],
+                    commandLineArgs: editCommandLineArgs || commandLineArgs,
                     cleanBuildDiscrepancies,
-                    incrementalModifyFs: fs => {
+                    editFs: fs => {
                         for (let i = 0; i <= index; i++) {
-                            incrementalScenarios[i].modifyFs(fs);
+                            edits[i].modifyFs(fs);
                         }
                     },
                     modifyFs,
                     tick
-                }), index, subScenario || buildKind));
+                }), index, subScenario));
             });
         });
     }