Cherry picking microsoft#33145 (microsoft#33170)

implement create Hash to be default hashing plus data so we can verify it easily in baseline

Author: sheetalkamat

src/compiler/builder.ts

@@ -137,7 +137,7 @@ namespace ts {
          */
         emittedBuildInfo?: boolean;
         /**
-         * Already seen affected files
+         * Already seen emitted files
          */
         seenEmittedFiles: Map<true> | undefined;
         /**
@@ -329,7 +329,6 @@ namespace ts {
                         handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash);
                         return affectedFile;
                     }
-                    seenAffectedFiles.set(affectedFile.path, true);
                     affectedFilesIndex++;
                 }
 
@@ -549,7 +548,7 @@ namespace ts {
      * This is called after completing operation on the next affected file.
      * The operations here are postponed to ensure that cancellation during the iteration is handled correctly
      */
-    function doneWithAffectedFile(state: BuilderProgramState, affected: SourceFile | Program, isPendingEmit?: boolean, isBuildInfoEmit?: boolean) {
+    function doneWithAffectedFile(state: BuilderProgramState, affected: SourceFile | Program, isPendingEmit?: boolean, isBuildInfoEmit?: boolean, isEmitResult?: boolean) {
         if (isBuildInfoEmit) {
             state.emittedBuildInfo = true;
         }
@@ -559,6 +558,9 @@ namespace ts {
         }
         else {
             state.seenAffectedFiles!.set((affected as SourceFile).path, true);
+            if (isEmitResult) {
+                (state.seenEmittedFiles || (state.seenEmittedFiles = createMap())).set((affected as SourceFile).path, true);
+            }
             if (isPendingEmit) {
                 state.affectedFilesPendingEmitIndex!++;
             }
@@ -576,6 +578,14 @@ namespace ts {
         return { result, affected };
     }
 
+    /**
+     * Returns the result with affected file
+     */
+    function toAffectedFileEmitResult(state: BuilderProgramState, result: EmitResult, affected: SourceFile | Program, isPendingEmit?: boolean, isBuildInfoEmit?: boolean): AffectedFileResult<EmitResult> {
+        doneWithAffectedFile(state, affected, isPendingEmit, isBuildInfoEmit, /*isEmitResult*/ true);
+        return { result, affected };
+    }
+
     /**
      * Gets the semantic diagnostics either from cache if present, or otherwise from program and caches it
      * Note that it is assumed that the when asked about semantic diagnostics, the file has been taken out of affected files/changed file set
@@ -849,7 +859,7 @@ namespace ts {
                         }
 
                         const affected = Debug.assertDefined(state.program);
-                        return toAffectedFileResult(
+                        return toAffectedFileEmitResult(
                             state,
                             // When whole program is affected, do emit only once (eg when --out or --outFile is specified)
                             // Otherwise just affected file
@@ -872,14 +882,14 @@ namespace ts {
                 }
             }
 
-            return toAffectedFileResult(
+            return toAffectedFileEmitResult(
                 state,
                 // When whole program is affected, do emit only once (eg when --out or --outFile is specified)
                 // Otherwise just affected file
                 Debug.assertDefined(state.program).emit(affected === state.program ? undefined : affected as SourceFile, writeFile || maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers),
                 affected,
-                isPendingEmitFile
-            );
+                isPendingEmitFile,
+           );
         }
 
         /**

src/compiler/builderState.ts

@@ -345,8 +345,13 @@ namespace ts.BuilderState {
         }
         else {
             const emitOutput = getFileEmitOutput(programOfThisState, sourceFile, /*emitOnlyDtsFiles*/ true, cancellationToken);
-            if (emitOutput.outputFiles && emitOutput.outputFiles.length > 0) {
-                latestSignature = computeHash(emitOutput.outputFiles[0].text);
+            const firstDts = emitOutput.outputFiles &&
+                programOfThisState.getCompilerOptions().declarationMap ?
+                emitOutput.outputFiles.length > 1 ? emitOutput.outputFiles[1] : undefined :
+                emitOutput.outputFiles.length > 0 ? emitOutput.outputFiles[0] : undefined;
+            if (firstDts) {
+                Debug.assert(fileExtensionIs(firstDts.name, Extension.Dts), "File extension for signature expected to be dts", () => `Found: ${getAnyExtensionFromPath(firstDts.name)} for ${firstDts.name}:: All output files: ${JSON.stringify(emitOutput.outputFiles.map(f => f.name))}`);
+                latestSignature = computeHash(firstDts.text);
                 if (exportedModulesMapCache && latestSignature !== prevSignature) {
                     updateExportedModules(sourceFile, emitOutput.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
                 }

src/compiler/emitter.ts

@@ -155,6 +155,7 @@ namespace ts {
     }
 
     function getOutputJSFileName(inputFileName: string, configFile: ParsedCommandLine, ignoreCase: boolean) {
+        if (configFile.options.emitDeclarationOnly) return undefined;
         const isJsonFile = fileExtensionIs(inputFileName, Extension.Json);
         const outputFileName = changeExtension(
             getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir),
@@ -187,7 +188,7 @@ namespace ts {
                 const js = getOutputJSFileName(inputFileName, configFile, ignoreCase);
                 addOutput(js);
                 if (fileExtensionIs(inputFileName, Extension.Json)) continue;
-                if (configFile.options.sourceMap) {
+                if (js && configFile.options.sourceMap) {
                     addOutput(`${js}.map`);
                 }
                 if (getEmitDeclarations(configFile.options) && hasTSFileExtension(inputFileName)) {
@@ -214,6 +215,10 @@ namespace ts {
             if (fileExtensionIs(inputFileName, Extension.Dts)) continue;
             const jsFilePath = getOutputJSFileName(inputFileName, configFile, ignoreCase);
             if (jsFilePath) return jsFilePath;
+            if (fileExtensionIs(inputFileName, Extension.Json)) continue;
+            if (getEmitDeclarations(configFile.options) && hasTSFileExtension(inputFileName)) {
+                return getOutputDeclarationFileName(inputFileName, configFile, ignoreCase);
+            }
         }
         const buildInfoPath = getOutputPathForBuildInfo(configFile.options);
         if (buildInfoPath) return buildInfoPath;

src/harness/fakes.ts

@@ -442,6 +442,10 @@ namespace fakes {
             super.writeFile(fileName, ts.getBuildInfoText(buildInfo), writeByteOrderMark);
         }
 
+        createHash(data: string) {
+            return `${ts.generateDjb2Hash(data)}-${data}`;
+        }
+
         now() {
             return new Date(this.sys.vfs.time());
         }

src/testRunner/tsconfig.json

@@ -93,6 +93,7 @@
         "unittests/services/transpile.ts",
         "unittests/tsbuild/amdModulesWithOut.ts",
         "unittests/tsbuild/containerOnlyReferenced.ts",
+        "unittests/tsbuild/emitDeclarationOnly.ts",
         "unittests/tsbuild/emptyFiles.ts",
         "unittests/tsbuild/graphOrdering.ts",
         "unittests/tsbuild/inferredTypeFromTransitiveModule.ts",

src/testRunner/unittests/tsbuild/amdModulesWithOut.ts

@@ -77,7 +77,7 @@ namespace ts {
                     [outputFiles[project.lib][ext.buildinfo], outputFiles[project.lib][ext.js], outputFiles[project.lib][ext.dts]],
                     [outputFiles[project.app][ext.buildinfo], outputFiles[project.app][ext.js], outputFiles[project.app][ext.dts]]
                 ],
-                lastProjectOutputJs: outputFiles[project.app][ext.js],
+                lastProjectOutput: outputFiles[project.app][ext.js],
                 initialBuild: {
                     modifyFs
                 },
@@ -231,7 +231,7 @@ ${internal} export enum internalEnum { a, b, c }`);
                         [libOutputFile[ext.buildinfo], libOutputFile[ext.js], libOutputFile[ext.dts]],
                         [outputFiles[project.app][ext.buildinfo], outputFiles[project.app][ext.js], outputFiles[project.app][ext.dts]]
                     ],
-                    lastProjectOutputJs: outputFiles[project.app][ext.js],
+                    lastProjectOutput: outputFiles[project.app][ext.js],
                     initialBuild: {
                         modifyFs,
                         expectedDiagnostics: [

src/testRunner/unittests/tsbuild/emitDeclarationOnly.ts

@@ -0,0 +1,109 @@
+namespace ts {
+    describe("unittests:: tsbuild:: on project with emitDeclarationOnly set to true", () => {
+        let projFs: vfs.FileSystem;
+        const { time, tick } = getTime();
+        before(() => {
+            projFs = loadProjectFromDisk("tests/projects/emitDeclarationOnly", time);
+        });
+        after(() => {
+            projFs = undefined!;
+        });
+
+        function verifyEmitDeclarationOnly(disableMap?: true) {
+            verifyTsbuildOutput({
+                scenario: `only dts output in circular import project with emitDeclarationOnly${disableMap ? "" : " and declarationMap"}`,
+                projFs: () => projFs,
+                time,
+                tick,
+                proj: "emitDeclarationOnly",
+                rootNames: ["/src"],
+                lastProjectOutput: `/src/lib/index.d.ts`,
+                outputFiles: [
+                    "/src/lib/a.d.ts",
+                    "/src/lib/b.d.ts",
+                    "/src/lib/c.d.ts",
+                    "/src/lib/index.d.ts",
+                    "/src/tsconfig.tsbuildinfo",
+                    ...(disableMap ? emptyArray : [
+                        "/src/lib/a.d.ts.map",
+                        "/src/lib/b.d.ts.map",
+                        "/src/lib/c.d.ts.map",
+                        "/src/lib/index.d.ts.map"
+                    ])
+                ],
+                initialBuild: {
+                    modifyFs: disableMap ?
+                        (fs => replaceText(fs, "/src/tsconfig.json", `"declarationMap": true,`, "")) :
+                        noop,
+                    expectedDiagnostics: [
+                        getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
+                        [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/tsconfig.json", "src/lib/a.d.ts"],
+                        [Diagnostics.Building_project_0, "/src/tsconfig.json"]
+                    ]
+                },
+                incrementalDtsChangedBuild: {
+                    modifyFs: fs => replaceText(fs, "/src/src/a.ts", "b: B;", "b: B; foo: any;"),
+                    expectedDiagnostics: [
+                        getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
+                        [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/lib/a.d.ts", "src/src/a.ts"],
+                        [Diagnostics.Building_project_0, "/src/tsconfig.json"]
+                    ]
+                },
+                baselineOnly: true,
+                verifyDiagnostics: true
+            });
+        }
+        verifyEmitDeclarationOnly();
+        verifyEmitDeclarationOnly(/*disableMap*/ true);
+
+        verifyTsbuildOutput({
+            scenario: `only dts output in non circular imports project with emitDeclarationOnly`,
+            projFs: () => projFs,
+            time,
+            tick,
+            proj: "emitDeclarationOnly",
+            rootNames: ["/src"],
+            lastProjectOutput: `/src/lib/a.d.ts`,
+            outputFiles: [
+                "/src/lib/a.d.ts",
+                "/src/lib/b.d.ts",
+                "/src/lib/c.d.ts",
+                "/src/tsconfig.tsbuildinfo",
+                "/src/lib/a.d.ts.map",
+                "/src/lib/b.d.ts.map",
+                "/src/lib/c.d.ts.map",
+            ],
+            initialBuild: {
+                modifyFs: fs => {
+                    fs.rimrafSync("/src/src/index.ts");
+                    replaceText(fs, "/src/src/a.ts", `import { B } from "./b";`, `export class B { prop = "hello"; }`);
+                },
+                expectedDiagnostics: [
+                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
+                    [Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, "src/tsconfig.json", "src/lib/a.d.ts"],
+                    [Diagnostics.Building_project_0, "/src/tsconfig.json"]
+                ]
+            },
+            incrementalDtsChangedBuild: {
+                modifyFs: fs => replaceText(fs, "/src/src/a.ts", "b: B;", "b: B; foo: any;"),
+                expectedDiagnostics: [
+                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
+                    [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/lib/a.d.ts", "src/src/a.ts"],
+                    [Diagnostics.Building_project_0, "/src/tsconfig.json"]
+                ]
+            },
+            incrementalDtsUnchangedBuild: {
+                modifyFs: fs => replaceText(fs, "/src/src/a.ts", "export interface A {", `class C { }
+export interface A {`),
+                expectedDiagnostics: [
+                    getExpectedDiagnosticForProjectsInBuild("src/tsconfig.json"),
+                    [Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, "src/tsconfig.json", "src/lib/a.d.ts", "src/src/a.ts"],
+                    [Diagnostics.Building_project_0, "/src/tsconfig.json"],
+                    [Diagnostics.Updating_unchanged_output_timestamps_of_project_0, "/src/tsconfig.json"]
+                ]
+            },
+            baselineOnly: true,
+            verifyDiagnostics: true
+        });
+    });
+}

src/testRunner/unittests/tsbuild/helpers.ts

@@ -66,7 +66,22 @@ namespace ts {
 interface ReadonlyArray<T> {}
 declare const console: { log(msg: any): void; };`;
 
-    export function loadProjectFromDisk(root: string, time?: vfs.FileSystemOptions["time"]): vfs.FileSystem {
+    export const symbolLibContent = `
+interface SymbolConstructor {
+    readonly species: symbol;
+    readonly toStringTag: symbol;
+}
+declare var Symbol: SymbolConstructor;
+interface Symbol {
+    readonly [Symbol.toStringTag]: string;
+}
+`;
+
+    export function loadProjectFromDisk(
+        root: string,
+        time?: vfs.FileSystemOptions["time"],
+        libContentToAppend?: string
+    ): vfs.FileSystem {
         const resolver = vfs.createResolver(Harness.IO);
         const fs = new vfs.FileSystem(/*ignoreCase*/ true, {
             files: {
@@ -76,10 +91,29 @@ declare const console: { log(msg: any): void; };`;
             meta: { defaultLibLocation: "/lib" },
             time
         });
+        addLibAndMakeReadonly(fs, libContentToAppend);
+        return fs;
+    }
+
+    export function loadProjectFromFiles(
+        files: vfs.FileSet,
+        time?: vfs.FileSystemOptions["time"],
+        libContentToAppend?: string
+    ): vfs.FileSystem {
+        const fs = new vfs.FileSystem(/*ignoreCase*/ true, {
+            files,
+            cwd: "/",
+            meta: { defaultLibLocation: "/lib" },
+            time
+        });
+        addLibAndMakeReadonly(fs, libContentToAppend);
+        return fs;
+    }
+
+    function addLibAndMakeReadonly(fs: vfs.FileSystem, libContentToAppend?: string) {
         fs.mkdirSync("/lib");
-        fs.writeFileSync("/lib/lib.d.ts", libContent);
+        fs.writeFileSync("/lib/lib.d.ts", libContentToAppend ? `${libContent}${libContentToAppend}` : libContent);
         fs.makeReadonly();
-        return fs;
     }
 
     export function verifyOutputsPresent(fs: vfs.FileSystem, outputs: readonly string[]) {
@@ -163,7 +197,7 @@ declare const console: { log(msg: any): void; };`;
         fs: vfs.FileSystem;
         tick: () => void;
         rootNames: ReadonlyArray<string>;
-        expectedMapFileNames: ReadonlyArray<string>;
+        expectedMapFileNames?: ReadonlyArray<string>;
         expectedBuildInfoFilesForSectionBaselines?: ReadonlyArray<BuildInfoSectionBaselineFiles>;
         modifyFs: (fs: vfs.FileSystem) => void;
     }
@@ -185,7 +219,7 @@ declare const console: { log(msg: any): void; };`;
             return originalReadFile.call(host, path);
         };
         builder.build();
-        generateSourceMapBaselineFiles(fs, expectedMapFileNames);
+        if (expectedMapFileNames) generateSourceMapBaselineFiles(fs, expectedMapFileNames);
         generateBuildInfoSectionBaselineFiles(fs, expectedBuildInfoFilesForSectionBaselines || emptyArray);
         fs.makeReadonly();
         return { fs, actualReadFileMap, host, builder };
@@ -232,9 +266,10 @@ Mismatch Actual(path, actual, expected): ${JSON.stringify(arrayFrom(mapDefinedIt
         tick: () => void;
         proj: string;
         rootNames: ReadonlyArray<string>;
-        expectedMapFileNames: ReadonlyArray<string>;
+        /** map file names to generate baseline of */
+        expectedMapFileNames?: ReadonlyArray<string>;
         expectedBuildInfoFilesForSectionBaselines?: ReadonlyArray<BuildInfoSectionBaselineFiles>;
-        lastProjectOutputJs: string;
+        lastProjectOutput: string;
         initialBuild: BuildState;
         outputFiles?: ReadonlyArray<string>;
         incrementalDtsChangedBuild?: BuildState;
@@ -246,7 +281,7 @@ Mismatch Actual(path, actual, expected): ${JSON.stringify(arrayFrom(mapDefinedIt
 
     export function verifyTsbuildOutput({
         scenario, projFs, time, tick, proj, rootNames, outputFiles, baselineOnly, verifyDiagnostics,
-        expectedMapFileNames, expectedBuildInfoFilesForSectionBaselines, lastProjectOutputJs,
+        expectedMapFileNames, expectedBuildInfoFilesForSectionBaselines, lastProjectOutput,
         initialBuild, incrementalDtsChangedBuild, incrementalDtsUnchangedBuild, incrementalHeaderChangedBuild
     }: VerifyTsBuildInput) {
         describe(`tsc --b ${proj}:: ${scenario}`, () => {
@@ -295,7 +330,7 @@ Mismatch Actual(path, actual, expected): ${JSON.stringify(arrayFrom(mapDefinedIt
                     let beforeBuildTime: number;
                     let afterBuildTime: number;
                     before(() => {
-                        beforeBuildTime = fs.statSync(lastProjectOutputJs).mtimeMs;
+                        beforeBuildTime = fs.statSync(lastProjectOutput).mtimeMs;
                         tick();
                         newFs = fs.shadow();
                         tick();
@@ -307,7 +342,7 @@ Mismatch Actual(path, actual, expected): ${JSON.stringify(arrayFrom(mapDefinedIt
                             expectedBuildInfoFilesForSectionBaselines,
                             modifyFs: incrementalModifyFs,
                         }));
-                        afterBuildTime = newFs.statSync(lastProjectOutputJs).mtimeMs;
+                        afterBuildTime = newFs.statSync(lastProjectOutput).mtimeMs;
                     });
                     after(() => {
                         newFs = undefined!;
@@ -337,7 +372,6 @@ Mismatch Actual(path, actual, expected): ${JSON.stringify(arrayFrom(mapDefinedIt
                             fs: newFs.shadow(),
                             tick,
                             rootNames,
-                            expectedMapFileNames: emptyArray,
                             modifyFs: fs => {
                                 // Delete output files
                                 for (const outputFile of expectedOutputFiles) {