/** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */

reportsUnnecessary?: {};

reportDeprecated?: {}

source?: string;

relatedInformation?: ReusableDiagnosticRelatedInformation[];

skippedOn?: keyof CompilerOptions;

category: DiagnosticCategory;

code: number;

file: string | undefined;

start: number | undefined;

length: number | undefined;

messageText: string | ReusableDiagnosticMessageChain;

/**

semanticDiagnosticsPerFile?: ESMap<Path, readonly ReusableDiagnostic[] | readonly Diagnostic[]> | undefined;

/**

changedFilesSet?: Set<Path>;

/**

program?: Program | undefined;

/**

compilerOptions: CompilerOptions;

/**

affectedFilesPendingEmit?: readonly Path[] | undefined;

/**

affectedFilesPendingEmitKind?: ESMap<Path, BuilderFileEmit> | undefined;

/**

affectedFilesPendingEmitIndex?: number | undefined;

/*

hasReusableDiagnostic?: true;

/**

emitSignatures?: ESMap<Path, string>;

/**

outSignature?: string;

/**

latestChangedDtsFile: string | undefined;

/**

semanticDiagnosticsPerFile: ESMap<Path, readonly Diagnostic[]> | undefined;

/**

changedFilesSet: Set<Path>;

/**

affectedFiles?: readonly SourceFile[] | undefined;

/**

affectedFilesIndex: number | undefined;

/**

currentChangedFilePath?: Path | undefined;

/**

seenAffectedFiles: Set<Path> | undefined;

/**

cleanedDiagnosticsOfLibFiles?: boolean;

/**

semanticDiagnosticsFromOldState?: Set<Path>;

/**

hasChangedEmitSignature?: boolean;

/**

affectedFilesPendingEmit: Path[] | undefined;

/**

buildInfoEmitPending: boolean;

/**

seenEmittedFiles: ESMap<Path, BuilderFileEmit> | undefined;

/**

programEmitComplete?: true;

/** Stores list of files that change signature during emit - test only */

filesChangingSignature?: Set<Path>;

"affectedFilesPendingEmit" |

"affectedFilesPendingEmitIndex" |

"affectedFilesPendingEmitKind" |

"seenEmittedFiles" |

"programEmitComplete" |

"emitSignatures" |

"outSignature" |

"latestChangedDtsFile" |

"hasChangedEmitSignature"

const state = BuilderState.create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) as BuilderProgramState;

state.program = newProgram;

const compilerOptions = newProgram.getCompilerOptions();

state.compilerOptions = compilerOptions;

const outFilePath = outFile(compilerOptions);

// With --out or --outFile, any change affects all semantic diagnostics so no need to cache them

if (!outFilePath) {

state.semanticDiagnosticsPerFile = new Map();

}

else if (compilerOptions.composite && oldState?.outSignature && outFilePath === outFile(oldState?.compilerOptions)) {

state.outSignature = oldState?.outSignature;

}

state.changedFilesSet = new Set();

state.latestChangedDtsFile = compilerOptions.composite ? oldState?.latestChangedDtsFile : undefined;

const useOldState = BuilderState.canReuseOldState(state.referencedMap, oldState);

const oldCompilerOptions = useOldState ? oldState!.compilerOptions : undefined;

const canCopySemanticDiagnostics = useOldState && oldState!.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile &&

!compilerOptionsAffectSemanticDiagnostics(compilerOptions, oldCompilerOptions!);

// We can only reuse emit signatures (i.e. .d.ts signatures) if the .d.ts file is unchanged,

// which will eg be depedent on change in options like declarationDir and outDir options are unchanged.

// We need to look in oldState.compilerOptions, rather than oldCompilerOptions (i.e.we need to disregard useOldState) because

// oldCompilerOptions can be undefined if there was change in say module from None to some other option

// which would make useOldState as false since we can now use reference maps that are needed to track what to emit, what to check etc

// but that option change does not affect d.ts file name so emitSignatures should still be reused.

const canCopyEmitSignatures = compilerOptions.composite &&

oldState?.emitSignatures &&

!outFilePath &&

!compilerOptionsAffectDeclarationPath(compilerOptions, oldState.compilerOptions);

if (useOldState) {

// Copy old state's changed files set

oldState!.changedFilesSet?.forEach(value => state.changedFilesSet.add(value));

if (!outFilePath && oldState!.affectedFilesPendingEmit) {

state.affectedFilesPendingEmit = oldState!.affectedFilesPendingEmit.slice();

state.affectedFilesPendingEmitKind = oldState!.affectedFilesPendingEmitKind && new Map(oldState!.affectedFilesPendingEmitKind);

state.affectedFilesPendingEmitIndex = oldState!.affectedFilesPendingEmitIndex;

state.seenAffectedFiles = new Set();

}

}

// Update changed files and copy semantic diagnostics if we can

const referencedMap = state.referencedMap;

const oldReferencedMap = useOldState ? oldState!.referencedMap : undefined;

const copyDeclarationFileDiagnostics = canCopySemanticDiagnostics && !compilerOptions.skipLibCheck === !oldCompilerOptions!.skipLibCheck;

const copyLibFileDiagnostics = copyDeclarationFileDiagnostics && !compilerOptions.skipDefaultLibCheck === !oldCompilerOptions!.skipDefaultLibCheck;

state.fileInfos.forEach((info, sourceFilePath) => {

let oldInfo: Readonly<BuilderState.FileInfo> | undefined;

let newReferences: ReadonlySet<Path> | undefined;

// if not using old state, every file is changed

if (!useOldState ||

// File wasn't present in old state

!(oldInfo = oldState!.fileInfos.get(sourceFilePath)) ||

// versions dont match

oldInfo.version !== info.version ||

// Implied formats dont match

oldInfo.impliedFormat !== info.impliedFormat ||

// Referenced files changed

!hasSameKeys(newReferences = referencedMap && referencedMap.getValues(sourceFilePath), oldReferencedMap && oldReferencedMap.getValues(sourceFilePath)) ||

// Referenced file was deleted in the new program

newReferences && forEachKey(newReferences, path => !state.fileInfos.has(path) && oldState!.fileInfos.has(path))) {

// Register file as changed file and do not copy semantic diagnostics, since all changed files need to be re-evaluated

state.changedFilesSet.add(sourceFilePath);

}

else if (canCopySemanticDiagnostics) {

const sourceFile = newProgram.getSourceFileByPath(sourceFilePath)!;

if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics) return;

if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics) return;

// Unchanged file copy diagnostics

const diagnostics = oldState!.semanticDiagnosticsPerFile!.get(sourceFilePath);

if (diagnostics) {

state.semanticDiagnosticsPerFile!.set(sourceFilePath, oldState!.hasReusableDiagnostic ? convertToDiagnostics(diagnostics as readonly ReusableDiagnostic[], newProgram, getCanonicalFileName) : diagnostics as readonly Diagnostic[]);

if (!state.semanticDiagnosticsFromOldState) {

state.semanticDiagnosticsFromOldState = new Set();

}

state.semanticDiagnosticsFromOldState.add(sourceFilePath);

}

}

if (canCopyEmitSignatures) {

const oldEmitSignature = oldState.emitSignatures.get(sourceFilePath);

if (oldEmitSignature) (state.emitSignatures ||= new Map()).set(sourceFilePath, oldEmitSignature);

}

});

// If the global file is removed, add all files as changed

if (useOldState && forEachEntry(oldState!.fileInfos, (info, sourceFilePath) => info.affectsGlobalScope && !state.fileInfos.has(sourceFilePath))) {

BuilderState.getAllFilesExcludingDefaultLibraryFile(state, newProgram, /*firstSourceFile*/ undefined)

.forEach(file => state.changedFilesSet.add(file.resolvedPath));

}

else if (oldCompilerOptions && !outFilePath && compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) {

// Add all files to affectedFilesPendingEmit since emit changed

newProgram.getSourceFiles().forEach(f => addToAffectedFilesPendingEmit(state, f.resolvedPath, BuilderFileEmit.Full));

Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size);

state.seenAffectedFiles = state.seenAffectedFiles || new Set();

}

// Since old states change files set is copied, any additional change means we would need to emit build info

state.buildInfoEmitPending = !useOldState || state.changedFilesSet.size !== (oldState!.changedFilesSet?.size || 0);

return state;

if (!diagnostics.length) return emptyArray;

const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions())!, newProgram.getCurrentDirectory()));

return diagnostics.map(diagnostic => {

const result: Diagnostic = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath);

result.reportsUnnecessary = diagnostic.reportsUnnecessary;

result.reportsDeprecated = diagnostic.reportDeprecated;

result.source = diagnostic.source;

result.skippedOn = diagnostic.skippedOn;

const { relatedInformation } = diagnostic;

result.relatedInformation = relatedInformation ?

relatedInformation.length ?

relatedInformation.map(r => convertToDiagnosticRelatedInformation(r, newProgram, toPath)) :

[] :

undefined;

return result;

});

function toPath(path: string) {

return ts.toPath(path, buildInfoDirectory, getCanonicalFileName);

}

const { file } = diagnostic;

return {

...diagnostic,

file: file ? newProgram.getSourceFileByPath(toPath(file)) : undefined

};

const outFilePath = outFile(state.compilerOptions);

// Only in --out changeFileSet is kept around till emit

Debug.assert(!state.changedFilesSet.size || outFilePath);

return {

affectedFilesPendingEmit: state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice(),

affectedFilesPendingEmitKind: state.affectedFilesPendingEmitKind && new Map(state.affectedFilesPendingEmitKind),

affectedFilesPendingEmitIndex: state.affectedFilesPendingEmitIndex,

seenEmittedFiles: state.seenEmittedFiles && new Map(state.seenEmittedFiles),

programEmitComplete: state.programEmitComplete,

emitSignatures: state.emitSignatures && new Map(state.emitSignatures),

outSignature: state.outSignature,

latestChangedDtsFile: state.latestChangedDtsFile,

hasChangedEmitSignature: state.hasChangedEmitSignature,

changedFilesSet: outFilePath ? new Set(state.changedFilesSet) : undefined,

};

state.affectedFilesPendingEmit = savedEmitState.affectedFilesPendingEmit;

state.affectedFilesPendingEmitKind = savedEmitState.affectedFilesPendingEmitKind;

state.affectedFilesPendingEmitIndex = savedEmitState.affectedFilesPendingEmitIndex;

state.seenEmittedFiles = savedEmitState.seenEmittedFiles;

state.programEmitComplete = savedEmitState.programEmitComplete;

state.emitSignatures = savedEmitState.emitSignatures;

state.outSignature = savedEmitState.outSignature;

state.latestChangedDtsFile = savedEmitState.latestChangedDtsFile;

state.hasChangedEmitSignature = savedEmitState.hasChangedEmitSignature;

if (savedEmitState.changedFilesSet) state.changedFilesSet = savedEmitState.changedFilesSet;

state: BuilderProgramState,

cancellationToken: CancellationToken | undefined,

computeHash: BuilderState.ComputeHash,

getCanonicalFileName: GetCanonicalFileName,

host: BuilderProgramHost

): SourceFile | Program | undefined {

while (true) {

const { affectedFiles } = state;

if (affectedFiles) {

const seenAffectedFiles = state.seenAffectedFiles!;

let affectedFilesIndex = state.affectedFilesIndex!; // TODO: GH#18217

while (affectedFilesIndex < affectedFiles.length) {

const affectedFile = affectedFiles[affectedFilesIndex];

if (!seenAffectedFiles.has(affectedFile.resolvedPath)) {

// Set the next affected file as seen and remove the cached semantic diagnostics

state.affectedFilesIndex = affectedFilesIndex;

handleDtsMayChangeOfAffectedFile(

state,

affectedFile,

cancellationToken,

computeHash,

getCanonicalFileName,

host

);

return affectedFile;

}

affectedFilesIndex++;

}

// Remove the changed file from the change set

state.changedFilesSet.delete(state.currentChangedFilePath!);

state.currentChangedFilePath = undefined;

// Commit the changes in file signature

state.oldSignatures?.clear();

state.oldExportedModulesMap?.clear();

state.affectedFiles = undefined;

}

// Get next changed file

const nextKey = state.changedFilesSet.keys().next();

if (nextKey.done) {

// Done

return undefined;

}

// With --out or --outFile all outputs go into single file

// so operations are performed directly on program, return program

const program = Debug.checkDefined(state.program);

const compilerOptions = program.getCompilerOptions();

if (outFile(compilerOptions)) {

Debug.assert(!state.semanticDiagnosticsPerFile);

return program;

}

// Get next batch of affected files

state.affectedFiles = BuilderState.getFilesAffectedByWithOldState(

state,

program,

nextKey.value,

cancellationToken,

computeHash,

getCanonicalFileName,

);

state.currentChangedFilePath = nextKey.value;

state.affectedFilesIndex = 0;

if (!state.seenAffectedFiles) state.seenAffectedFiles = new Set();

}

state.affectedFilesPendingEmit = undefined;

state.affectedFilesPendingEmitKind = undefined;

state.affectedFilesPendingEmitIndex = undefined;

const { affectedFilesPendingEmit } = state;

if (affectedFilesPendingEmit) {

const seenEmittedFiles = (state.seenEmittedFiles || (state.seenEmittedFiles = new Map()));

for (let i = state.affectedFilesPendingEmitIndex!; i < affectedFilesPendingEmit.length; i++) {

const affectedFile = Debug.checkDefined(state.program).getSourceFileByPath(affectedFilesPendingEmit[i]);

if (affectedFile) {

const seenKind = seenEmittedFiles.get(affectedFile.resolvedPath);

const emitKind = Debug.checkDefined(Debug.checkDefined(state.affectedFilesPendingEmitKind).get(affectedFile.resolvedPath));

if (seenKind === undefined || seenKind < emitKind) {

// emit this file

state.affectedFilesPendingEmitIndex = i;

return { affectedFile, emitKind };

}

}

}

clearAffectedFilesPendingEmit(state);

}

return undefined;

if (!state.cleanedDiagnosticsOfLibFiles) {

state.cleanedDiagnosticsOfLibFiles = true;

const program = Debug.checkDefined(state.program);

const options = program.getCompilerOptions();

forEach(program.getSourceFiles(), f =>

program.isSourceFileDefaultLibrary(f) &&

!skipTypeChecking(f, options, program) &&

removeSemanticDiagnosticsOf(state, f.resolvedPath)

);

}

state: BuilderProgramState,

affectedFile: SourceFile,

cancellationToken: CancellationToken | undefined,

computeHash: BuilderState.ComputeHash,

getCanonicalFileName: GetCanonicalFileName,

host: BuilderProgramHost,

) {

removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);

// If affected files is everything except default library, then nothing more to do

if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) {

removeDiagnosticsOfLibraryFiles(state);

// When a change affects the global scope, all files are considered to be affected without updating their signature

// That means when affected file is handled, its signature can be out of date

// To avoid this, ensure that we update the signature for any affected file in this scenario.

BuilderState.updateShapeSignature(

state,

Debug.checkDefined(state.program),

affectedFile,

cancellationToken,

computeHash,

getCanonicalFileName,

);

return;

}

if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies) return;

handleDtsMayChangeOfReferencingExportOfAffectedFile(

state,

affectedFile,

cancellationToken,

computeHash,

getCanonicalFileName,

host,

);

state: BuilderProgramState,

path: Path,

cancellationToken: CancellationToken | undefined,

computeHash: BuilderState.ComputeHash,

getCanonicalFileName: GetCanonicalFileName,

host: BuilderProgramHost

): void {

removeSemanticDiagnosticsOf(state, path);

if (!state.changedFilesSet.has(path)) {

const program = Debug.checkDefined(state.program);

const sourceFile = program.getSourceFileByPath(path);

if (sourceFile) {

// Even though the js emit doesnt change and we are already handling dts emit and semantic diagnostics

// we need to update the signature to reflect correctness of the signature(which is output d.ts emit) of this file

// This ensures that we dont later during incremental builds considering wrong signature.

// Eg where this also is needed to ensure that .tsbuildinfo generated by incremental build should be same as if it was first fresh build

// But we avoid expensive full shape computation, as using file version as shape is enough for correctness.

BuilderState.updateShapeSignature(

state,

program,

sourceFile,

cancellationToken,

computeHash,

getCanonicalFileName,

!host.disableUseFileVersionAsSignature

);

// If not dts emit, nothing more to do

if (getEmitDeclarations(state.compilerOptions)) {

addToAffectedFilesPendingEmit(state, path, BuilderFileEmit.DtsOnly);

}

}

}

if (!state.semanticDiagnosticsFromOldState) {

return true;

}

state.semanticDiagnosticsFromOldState.delete(path);

state.semanticDiagnosticsPerFile!.delete(path);

return !state.semanticDiagnosticsFromOldState.size;

const oldSignature = Debug.checkDefined(state.oldSignatures).get(path) || undefined;

const newSignature = Debug.checkDefined(state.fileInfos.get(path)).signature;

return newSignature !== oldSignature;

state: BuilderProgramState,

filePath: Path,

cancellationToken: CancellationToken | undefined,

computeHash: BuilderState.ComputeHash,

getCanonicalFileName: GetCanonicalFileName,

host: BuilderProgramHost,

): boolean {

if (!state.fileInfos.get(filePath)?.affectsGlobalScope) return false;

// Every file needs to be handled

BuilderState.getAllFilesExcludingDefaultLibraryFile(state, state.program!, /*firstSourceFile*/ undefined)

.forEach(file => handleDtsMayChangeOf(

state,

file.resolvedPath,

cancellationToken,

computeHash,

getCanonicalFileName,

host,

));

removeDiagnosticsOfLibraryFiles(state);

return true;

state: BuilderProgramState,

affectedFile: SourceFile,

cancellationToken: CancellationToken | undefined,

computeHash: BuilderState.ComputeHash,

getCanonicalFileName: GetCanonicalFileName,

host: BuilderProgramHost

) {

// If there was change in signature (dts output) for the changed file,

// then only we need to handle pending file emit

if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath)) return;

if (!isChangedSignature(state, affectedFile.resolvedPath)) return;

// Since isolated modules dont change js files, files affected by change in signature is itself

// But we need to cleanup semantic diagnostics and queue dts emit for affected files

if (state.compilerOptions.isolatedModules) {

const seenFileNamesMap = new Map<Path, true>();

seenFileNamesMap.set(affectedFile.resolvedPath, true);

const queue = BuilderState.getReferencedByPaths(state, affectedFile.resolvedPath);

while (queue.length > 0) {

const currentPath = queue.pop()!;

if (!seenFileNamesMap.has(currentPath)) {

seenFileNamesMap.set(currentPath, true);

if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host)) return;

handleDtsMayChangeOf(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host);

if (isChangedSignature(state, currentPath)) {

const currentSourceFile = Debug.checkDefined(state.program).getSourceFileByPath(currentPath)!;

queue.push(...BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath));

}

}

}

}

const seenFileAndExportsOfFile = new Set<string>();

// Go through exported modules from cache first

// If exported modules has path, all files referencing file exported from are affected

state.exportedModulesMap.getKeys(affectedFile.resolvedPath)?.forEach(exportedFromPath => {

if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, computeHash, getCanonicalFileName, host)) return true;

const references = state.referencedMap!.getKeys(exportedFromPath);

return references && forEachKey(references, filePath =>

handleDtsMayChangeOfFileAndExportsOfFile(

state,

filePath,

seenFileAndExportsOfFile,

cancellationToken,

computeHash,

getCanonicalFileName,

host,

)

);

});

state: BuilderProgramState,

filePath: Path,

seenFileAndExportsOfFile: Set<string>,

cancellationToken: CancellationToken | undefined,

computeHash: BuilderState.ComputeHash,

getCanonicalFileName: GetCanonicalFileName,

host: BuilderProgramHost,

): boolean | undefined {

if (!tryAddToSet(seenFileAndExportsOfFile, filePath)) return undefined;

if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host)) return true;

handleDtsMayChangeOf(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host);

// If exported modules has path, all files referencing file exported from are affected

state.exportedModulesMap!.getKeys(filePath)?.forEach(exportedFromPath =>

handleDtsMayChangeOfFileAndExportsOfFile(

state,

exportedFromPath,

seenFileAndExportsOfFile,

cancellationToken,

computeHash,

getCanonicalFileName,

host,

)

);

// Remove diagnostics of files that import this file (without going to exports of referencing files)

state.referencedMap!.getKeys(filePath)?.forEach(referencingFilePath =>

!seenFileAndExportsOfFile.has(referencingFilePath) && // Not already removed diagnostic file

handleDtsMayChangeOf( // Dont add to seen since this is not yet done with the export removal

state,

referencingFilePath,

cancellationToken,

computeHash,

getCanonicalFileName,

host,

)

);

return undefined;

state: BuilderProgramState,

affected: SourceFile | Program,

emitKind?: BuilderFileEmit,

isPendingEmit?: boolean,

isBuildInfoEmit?: boolean

) {

if (isBuildInfoEmit) {

state.buildInfoEmitPending = false;

}

else if (affected === state.program) {

state.changedFilesSet.clear();

state.programEmitComplete = true;

}

else {

state.seenAffectedFiles!.add((affected as SourceFile).resolvedPath);

// Change in changeSet/affectedFilesPendingEmit, buildInfo needs to be emitted

state.buildInfoEmitPending = true;

if (emitKind !== undefined) {

(state.seenEmittedFiles || (state.seenEmittedFiles = new Map())).set((affected as SourceFile).resolvedPath, emitKind);

}

if (isPendingEmit) {

state.affectedFilesPendingEmitIndex!++;

}

else {

state.affectedFilesIndex!++;

}

}

state: BuilderProgramState,

result: EmitResult,

affected: SourceFile | Program,

emitKind: BuilderFileEmit,

isPendingEmit?: boolean,

isBuildInfoEmit?: boolean

): AffectedFileResult<EmitResult> {

doneWithAffectedFile(state, affected, emitKind, isPendingEmit, isBuildInfoEmit);

return { result, affected };

return concatenate(

getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken),

Debug.checkDefined(state.program).getProgramDiagnostics(sourceFile)

);

const path = sourceFile.resolvedPath;

if (state.semanticDiagnosticsPerFile) {

const cachedDiagnostics = state.semanticDiagnosticsPerFile.get(path);

// Report the bind and check diagnostics from the cache if we already have those diagnostics present

if (cachedDiagnostics) {

return filterSemanticDiagnostics(cachedDiagnostics, state.compilerOptions);

}

}

// Diagnostics werent cached, get them from program, and cache the result

const diagnostics = Debug.checkDefined(state.program).getBindAndCheckDiagnostics(sourceFile, cancellationToken);

if (state.semanticDiagnosticsPerFile) {

state.semanticDiagnosticsPerFile.set(path, diagnostics);

}

return filterSemanticDiagnostics(diagnostics, state.compilerOptions);

/**

signature: string | false | undefined;

fileNames: readonly string[];

fileInfos: readonly ProgramBuildInfoFileInfo[];

options: CompilerOptions | undefined;

fileIdsList?: readonly (readonly ProgramBuildInfoFileId[])[];

referencedMap?: ProgramBuildInfoReferencedMap;

exportedModulesMap?: ProgramBuildInfoReferencedMap;

semanticDiagnosticsPerFile?: ProgramBuildInfoDiagnostic[];

affectedFilesPendingEmit?: ProgramBuilderInfoFilePendingEmit[];

changeFileSet?: readonly ProgramBuildInfoFileId[];

emitSignatures?: readonly ProgramBuildInfoEmitSignature[];

// Because this is only output file in the program, we dont need fileId to deduplicate name

latestChangedDtsFile?: string;

fileNames: readonly string[];

fileInfos: readonly string[];

options: CompilerOptions | undefined;

outSignature?: string;

latestChangedDtsFile?: string;

const outFilePath = outFile(state.compilerOptions);

if (outFilePath && !state.compilerOptions.composite) return;

const currentDirectory = Debug.checkDefined(state.program).getCurrentDirectory();

const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(state.compilerOptions)!, currentDirectory));

// Convert the file name to Path here if we set the fileName instead to optimize multiple d.ts file emits and having to compute Canonical path

const latestChangedDtsFile = state.latestChangedDtsFile ? relativeToBuildInfoEnsuringAbsolutePath(state.latestChangedDtsFile) : undefined;

if (outFilePath) {

const fileNames: string[] = [];

const fileInfos: string[] = [];

state.program!.getRootFileNames().forEach(f => {

const sourceFile = state.program!.getSourceFile(f);

if (!sourceFile) return;

fileNames.push(relativeToBuildInfo(sourceFile.resolvedPath));

fileInfos.push(sourceFile.version);