Removing some unnecessary methods from host and function parameters (#51499)

Author: sheetalkamat

src/compiler/builder.ts

@@ -8,10 +8,6 @@ import {
 export type AffectedFileResult<T> = { result: T; affected: SourceFile | Program; } | undefined;
 
 export interface BuilderProgramHost {
-    /**
-     * return true if file names are treated with case sensitivity
-     */
-    useCaseSensitiveFileNames(): boolean;
     /**
      * If provided this would be used this hash instead of actual file shape text for detecting changes
      */
@@ -33,14 +29,11 @@ export interface BuilderProgramHost {
      * @internal
      */
     storeFilesChangingSignatureDuringEmit?: boolean;
-    /**
-     * Gets the current time
-     *
-     * @internal
-     */
-    now?(): Date;
 }
 
+/** @internal */
+export type HostForComputeHash = Pick<BuilderProgramHost, "createHash">;
+
 /**
  * Builder to manage the program state changes
  */

src/compiler/builderPublic.ts

@@ -1,6 +1,7 @@
 import {
-    arrayFrom, CancellationToken, computeSignatureWithDiagnostics, CustomTransformers, Debug, EmitOutput, emptyArray,
+    arrayFrom, CancellationToken, computeSignatureWithDiagnostics, createGetCanonicalFileName, CustomTransformers, Debug, EmitOutput, emptyArray,
     ExportedModulesFromDeclarationEmit, GetCanonicalFileName, getDirectoryPath, getSourceFileOfNode,
+    HostForComputeHash,
     isDeclarationFileName, isExternalOrCommonJsModule, isGlobalScopeAugmentation, isJsonSourceFile,
     isModuleWithStringLiteralName, isStringLiteral, mapDefined, mapDefinedIterator, ModuleDeclaration,
     ModuleKind, outFile, OutputFile, Path, Program, ResolutionMode, some, SourceFile, StringLiteralLike, Symbol,
@@ -158,11 +159,6 @@ export namespace BuilderState {
         return false;
     }
 
-    /**
-     * Compute the hash to store the shape of the file
-     */
-    export type ComputeHash = ((data: string) => string) | undefined;
-
     function getReferencedFilesFromImportedModuleSymbol(symbol: Symbol): Path[] {
         return mapDefined(symbol.declarations, declaration => getSourceFileOfNode(declaration)?.resolvedPath);
     }
@@ -272,14 +268,15 @@ export namespace BuilderState {
     /**
      * Creates the state of file references and signature for the new program from oldState if it is safe
      */
-    export function create(newProgram: Program, getCanonicalFileName: GetCanonicalFileName, oldState?: Readonly<BuilderState>, disableUseFileVersionAsSignature?: boolean): BuilderState {
+    export function create(newProgram: Program, oldState?: Readonly<BuilderState>, disableUseFileVersionAsSignature?: boolean): BuilderState {
         const fileInfos = new Map<Path, FileInfo>();
         const options = newProgram.getCompilerOptions();
         const isOutFile = outFile(options);
         const referencedMap = options.module !== ModuleKind.None && !isOutFile ?
             createManyToManyPathMap() : undefined;
         const exportedModulesMap = referencedMap ? createManyToManyPathMap() : undefined;
         const useOldState = canReuseOldState(referencedMap, oldState);
+        const getCanonicalFileName = createGetCanonicalFileName(newProgram.useCaseSensitiveFileNames());
 
         // Ensure source files have parent pointers set
         newProgram.getTypeChecker();
@@ -340,16 +337,14 @@ export namespace BuilderState {
         programOfThisState: Program,
         path: Path,
         cancellationToken: CancellationToken | undefined,
-        computeHash: ComputeHash,
-        getCanonicalFileName: GetCanonicalFileName,
+        host: HostForComputeHash,
     ): readonly SourceFile[] {
         const result = getFilesAffectedByWithOldState(
             state,
             programOfThisState,
             path,
             cancellationToken,
-            computeHash,
-            getCanonicalFileName,
+            host,
         );
         state.oldSignatures?.clear();
         state.oldExportedModulesMap?.clear();
@@ -361,19 +356,18 @@ export namespace BuilderState {
         programOfThisState: Program,
         path: Path,
         cancellationToken: CancellationToken | undefined,
-        computeHash: ComputeHash,
-        getCanonicalFileName: GetCanonicalFileName,
+        host: HostForComputeHash,
     ): readonly SourceFile[] {
         const sourceFile = programOfThisState.getSourceFileByPath(path);
         if (!sourceFile) {
             return emptyArray;
         }
 
-        if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName)) {
+        if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host)) {
             return [sourceFile];
         }
 
-        return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName);
+        return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, host);
     }
 
     export function updateSignatureOfFile(state: BuilderState, signature: string | undefined, path: Path) {
@@ -389,9 +383,8 @@ export namespace BuilderState {
         programOfThisState: Program,
         sourceFile: SourceFile,
         cancellationToken: CancellationToken | undefined,
-        computeHash: ComputeHash,
-        getCanonicalFileName: GetCanonicalFileName,
-        useFileVersionAsSignature = state.useFileVersionAsSignature
+        host: HostForComputeHash,
+        useFileVersionAsSignature = state.useFileVersionAsSignature,
     ) {
         // If we have cached the result for this file, that means hence forth we should assume file shape is uptodate
         if (state.hasCalledUpdateShapeSignature?.has(sourceFile.resolvedPath)) return false;
@@ -405,10 +398,10 @@ export namespace BuilderState {
                 (fileName, text, _writeByteOrderMark, _onError, sourceFiles, data) => {
                     Debug.assert(isDeclarationFileName(fileName), `File extension for signature expected to be dts: Got:: ${fileName}`);
                     latestSignature = computeSignatureWithDiagnostics(
+                        programOfThisState,
                         sourceFile,
                         text,
-                        computeHash,
-                        getCanonicalFileName,
+                        host,
                         data,
                     );
                     if (latestSignature !== prevSignature) {
@@ -604,8 +597,7 @@ export namespace BuilderState {
         programOfThisState: Program,
         sourceFileWithUpdatedShape: SourceFile,
         cancellationToken: CancellationToken | undefined,
-        computeHash: ComputeHash,
-        getCanonicalFileName: GetCanonicalFileName,
+        host: HostForComputeHash,
     ) {
         if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
             return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
@@ -629,7 +621,7 @@ export namespace BuilderState {
             if (!seenFileNamesMap.has(currentPath)) {
                 const currentSourceFile = programOfThisState.getSourceFileByPath(currentPath)!;
                 seenFileNamesMap.set(currentPath, currentSourceFile);
-                if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, computeHash, getCanonicalFileName)) {
+                if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, host)) {
                     queue.push(...getReferencedByPaths(state, currentSourceFile.resolvedPath));
                 }
             }

src/compiler/builderState.ts

@@ -637,7 +637,7 @@ export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFi
             if (sourceMapFilePath) {
                 const sourceMap = sourceMapGenerator.toString();
                 writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, /*writeByteOrderMark*/ false, sourceFiles);
-                if (printer.bundleFileInfo) printer.bundleFileInfo.mapHash = computeSignature(sourceMap, maybeBind(host, host.createHash));
+                if (printer.bundleFileInfo) printer.bundleFileInfo.mapHash = computeSignature(sourceMap, host);
             }
         }
         else {
@@ -649,7 +649,7 @@ export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFi
         writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos, diagnostics: transform.diagnostics });
         // We store the hash of the text written in the buildinfo to ensure that text of the referenced d.ts file is same as whats in the buildinfo
         // This is needed because incremental can be toggled between two runs and we might use stale file text to do text manipulation in prepend mode
-        if (printer.bundleFileInfo) printer.bundleFileInfo.hash = computeSignature(text, maybeBind(host, host.createHash));
+        if (printer.bundleFileInfo) printer.bundleFileInfo.hash = computeSignature(text, host);
 
         // Reset state
         writer.clear();
@@ -846,7 +846,6 @@ function emitUsingBuildInfoWorker(
     getCommandLine: (ref: ProjectReference) => ParsedCommandLine | undefined,
     customTransformers?: CustomTransformers
 ): EmitUsingBuildInfoResult {
-    const createHash = maybeBind(host, host.createHash);
     const { buildInfoPath, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath } = getOutputPathsForBundle(config.options, /*forceDtsPaths*/ false);
     // If host directly provides buildinfo we can get it directly. This allows host to cache the buildinfo
     const buildInfo = host.getBuildInfo!(buildInfoPath!, config.options.configFilePath);
@@ -856,20 +855,20 @@ function emitUsingBuildInfoWorker(
     const jsFileText = host.readFile(Debug.checkDefined(jsFilePath));
     if (!jsFileText) return jsFilePath!;
     // If the jsFileText is not same has what it was created with, tsbuildinfo is stale so dont use it
-    if (computeSignature(jsFileText, createHash) !== buildInfo.bundle.js.hash) return jsFilePath!;
+    if (computeSignature(jsFileText, host) !== buildInfo.bundle.js.hash) return jsFilePath!;
     const sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath);
     // error if no source map or for now if inline sourcemap
     if ((sourceMapFilePath && !sourceMapText) || config.options.inlineSourceMap) return sourceMapFilePath || "inline sourcemap decoding";
-    if (sourceMapFilePath && computeSignature(sourceMapText!, createHash) !== buildInfo.bundle.js.mapHash) return sourceMapFilePath;
+    if (sourceMapFilePath && computeSignature(sourceMapText!, host) !== buildInfo.bundle.js.mapHash) return sourceMapFilePath;
 
     // read declaration text
     const declarationText = declarationFilePath && host.readFile(declarationFilePath);
     if (declarationFilePath && !declarationText) return declarationFilePath;
-    if (declarationFilePath && computeSignature(declarationText!, createHash) !== buildInfo.bundle.dts!.hash) return declarationFilePath;
+    if (declarationFilePath && computeSignature(declarationText!, host) !== buildInfo.bundle.dts!.hash) return declarationFilePath;
     const declarationMapText = declarationMapPath && host.readFile(declarationMapPath);
     // error if no source map or for now if inline sourcemap
     if ((declarationMapPath && !declarationMapText) || config.options.inlineSourceMap) return declarationMapPath || "inline sourcemap decoding";
-    if (declarationMapPath && computeSignature(declarationMapText!, createHash) !== buildInfo.bundle.dts!.mapHash) return declarationMapPath;
+    if (declarationMapPath && computeSignature(declarationMapText!, host) !== buildInfo.bundle.dts!.mapHash) return declarationMapPath;
 
     const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath!, host.getCurrentDirectory()));
     const ownPrependInput = createInputFilesWithFileTexts(
@@ -936,7 +935,7 @@ function emitUsingBuildInfoWorker(
             const program = buildInfo.program;
             if (program && changedDtsText !== undefined && config.options.composite) {
                 // Update the output signature
-                (program as ProgramBundleEmitBuildInfo).outSignature = computeSignature(changedDtsText, createHash, changedDtsData);
+                (program as ProgramBundleEmitBuildInfo).outSignature = computeSignature(changedDtsText, host, changedDtsData);
             }
             // Update sourceFileInfo
             const { js, dts, sourceFiles } = buildInfo.bundle!;
@@ -950,7 +949,7 @@ function emitUsingBuildInfoWorker(
         getSourceFileFromReference: returnUndefined,
         redirectTargetsMap: createMultiMap(),
         getFileIncludeReasons: notImplemented,
-        createHash,
+        createHash: maybeBind(host, host.createHash),
     };
     emitFiles(
         notImplementedResolver,

src/compiler/emitter.ts

@@ -332,6 +332,8 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
     autoImportProviderHost: AutoImportProviderProject | false | undefined;
     /** @internal */
     protected typeAcquisition: TypeAcquisition | undefined;
+    /** @internal */
+    createHash = maybeBind(this.projectService.host, this.projectService.host.createHash);
 
     /** @internal */
     constructor(
@@ -740,15 +742,14 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
             return [];
         }
         updateProjectIfDirty(this);
-        this.builderState = BuilderState.create(this.program!, this.projectService.toCanonicalFileName, this.builderState, /*disableUseFileVersionAsSignature*/ true);
+        this.builderState = BuilderState.create(this.program!, this.builderState, /*disableUseFileVersionAsSignature*/ true);
         return mapDefined(
             BuilderState.getFilesAffectedBy(
                 this.builderState,
                 this.program!,
                 scriptInfo.path,
                 this.cancellationToken,
-                maybeBind(this.projectService.host, this.projectService.host.createHash),
-                this.getCanonicalFileName,
+                this.projectService.host,
             ),
             sourceFile => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)) ? sourceFile.fileName : undefined
         );

src/server/project.ts

@@ -1398,6 +1398,7 @@ export function createLanguageService(
             trace: maybeBind(host, host.trace),
             resolveModuleNames: maybeBind(host, host.resolveModuleNames),
             getModuleResolutionCache: maybeBind(host, host.getModuleResolutionCache),
+            createHash: maybeBind(host, host.createHash),
             resolveTypeReferenceDirectives: maybeBind(host, host.resolveTypeReferenceDirectives),
             useSourceOfProjectReferenceRedirect: maybeBind(host, host.useSourceOfProjectReferenceRedirect),
             getParsedCommandLine,

src/services/services.ts

@@ -303,6 +303,7 @@ export interface LanguageServiceHost extends GetEffectiveTypeRootsHost, MinimalR
      */
     readDirectory?(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
     realpath?(path: string): string;
+    /** @internal */ createHash?(data: string): string;
 
     /*
      * Unlike `realpath and `readDirectory`, `readFile` and `fileExists` are now _required_

src/services/types.ts

@@ -74,7 +74,7 @@ describe("unittests:: builder", () => {
 });
 
 function makeAssertChanges(getProgram: () => ts.Program): (fileNames: readonly string[]) => void {
-    const host: ts.BuilderProgramHost = { useCaseSensitiveFileNames: ts.returnTrue };
+    const host: ts.BuilderProgramHost = { };
     let builderProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
     return fileNames => {
         const program = getProgram();
@@ -88,7 +88,7 @@ function makeAssertChanges(getProgram: () => ts.Program): (fileNames: readonly s
 }
 
 function makeAssertChangesWithCancellationToken(getProgram: () => ts.Program): (fileNames: readonly string[], cancelAfterEmitLength?: number) => void {
-    const host: ts.BuilderProgramHost = { useCaseSensitiveFileNames: ts.returnTrue };
+    const host: ts.BuilderProgramHost = { };
     let builderProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
     let cancel = false;
     const cancellationToken: ts.CancellationToken = {

src/testRunner/unittests/builder.ts

@@ -9431,10 +9431,6 @@ declare namespace ts {
         affected: SourceFile | Program;
     } | undefined;
     interface BuilderProgramHost {
-        /**
-         * return true if file names are treated with case sensitivity
-         */
-        useCaseSensitiveFileNames(): boolean;
         /**
          * If provided this would be used this hash instead of actual file shape text for detecting changes
          */

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -5495,10 +5495,6 @@ declare namespace ts {
         affected: SourceFile | Program;
     } | undefined;
     interface BuilderProgramHost {
-        /**
-         * return true if file names are treated with case sensitivity
-         */
-        useCaseSensitiveFileNames(): boolean;
         /**
          * If provided this would be used this hash instead of actual file shape text for detecting changes
          */