/** 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?: Map<Path, readonly ReusableDiagnostic[] | readonly Diagnostic[]> | undefined;

/**

changedFilesSet?: Set<Path>;

/**

program?: Program | undefined;

/**

compilerOptions: CompilerOptions;

/**

affectedFilesPendingEmit?: ReadonlyMap<Path, BuilderFileEmit>;

/**

programEmitPending?: BuilderFileEmit;

/*

hasReusableDiagnostic?: true;

/**

emitSignatures?: Map<Path, EmitSignature>;

/**

outSignature?: EmitSignature;

/**

latestChangedDtsFile: string | undefined;

/**

bundle?: BundleBuildInfo;

None = 0,

Js = 1 << 0, // emit js file

JsMap = 1 << 1, // emit js.map file

JsInlineMap = 1 << 2, // emit inline source map in js file

Dts = 1 << 3, // emit d.ts file

DtsMap = 1 << 4, // emit d.ts.map file

AllJs = Js | JsMap | JsInlineMap,

AllDts = Dts | DtsMap,

All = AllJs | AllDts,

/**

semanticDiagnosticsPerFile: Map<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?: Map<Path, BuilderFileEmit>;

/**

buildInfoEmitPending: boolean;

/**

seenEmittedFiles: Map<Path, BuilderFileEmit> | undefined;

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

filesChangingSignature?: Set<Path>;

"affectedFilesPendingEmit" |

"seenEmittedFiles" |

"programEmitPending" |

"emitSignatures" |

"outSignature" |

"latestChangedDtsFile" |

"hasChangedEmitSignature"

let result = BuilderFileEmit.Js;

if (options.sourceMap) result = result | BuilderFileEmit.JsMap;

if (options.inlineSourceMap) result = result | BuilderFileEmit.JsInlineMap;

if (getEmitDeclarations(options)) result = result | BuilderFileEmit.Dts;

if (options.declarationMap) result = result | BuilderFileEmit.DtsMap;

if (options.emitDeclarationOnly) result = result & BuilderFileEmit.AllDts;

return result;

const oldEmitKind = oldOptionsOrEmitKind && (isNumber(oldOptionsOrEmitKind) ? oldOptionsOrEmitKind : getBuilderFileEmit(oldOptionsOrEmitKind));

const emitKind = isNumber(optionsOrEmitKind) ? optionsOrEmitKind : getBuilderFileEmit(optionsOrEmitKind);

if (oldEmitKind === emitKind) return BuilderFileEmit.None;

if (!oldEmitKind || !emitKind) return emitKind;

const diff = oldEmitKind ^ emitKind;

let result = BuilderFileEmit.None;

// If there is diff in Js emit, pending emit is js emit flags

if (diff & BuilderFileEmit.AllJs) result = emitKind & BuilderFileEmit.AllJs;

// If there is diff in Dts emit, pending emit is dts emit flags

if (diff & BuilderFileEmit.AllDts) result = result | (emitKind & BuilderFileEmit.AllDts);

return result;

const state = BuilderState.create(newProgram, oldState, /*disableUseFileVersionAsSignature*/ false) 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 && getEmitSignatureFromOldSignature(compilerOptions, oldState.compilerOptions, 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?.size) {

state.affectedFilesPendingEmit = new Map(oldState!.affectedFilesPendingEmit);

state.seenAffectedFiles = new Set();

}

state.programEmitPending = oldState!.programEmitPending;

}

else {

// We arent using old state, so atleast emit buildInfo with current information

state.buildInfoEmitPending = true;

}

// 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

addFileToChangeSet(state, 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) : 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, getEmitSignatureFromOldSignature(compilerOptions, oldState.compilerOptions, oldEmitSignature));

}

}

});

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

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

if (state.fileInfos.has(sourceFilePath)) return false;

if (outFilePath || info.affectsGlobalScope) return true;

// if file is deleted we need to write buildInfo again

state.buildInfoEmitPending = true;

return false;

})) {

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

.forEach(file => addFileToChangeSet(state, file.resolvedPath));

}

else if (oldCompilerOptions) {

// If options affect emit, then we need to do complete emit per compiler options

// otherwise only the js or dts that needs to emitted because its different from previously emitted options

const pendingEmitKind = compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions) ?

getBuilderFileEmit(compilerOptions) :

getPendingEmitKind(compilerOptions, oldCompilerOptions);

if (pendingEmitKind !== BuilderFileEmit.None) {

if (!outFilePath) {

// Add all files to affectedFilesPendingEmit since emit changed

newProgram.getSourceFiles().forEach(f => {

// Add to affectedFilesPending emit only if not changed since any changed file will do full emit

if (!state.changedFilesSet.has(f.resolvedPath)) {

addToAffectedFilesPendingEmit(

state,

f.resolvedPath,

pendingEmitKind

);

}

});

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

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

state.buildInfoEmitPending = true;

}

else {

state.programEmitPending = state.programEmitPending ?

state.programEmitPending | pendingEmitKind :

pendingEmitKind;

}

}

}

if (outFilePath && !state.changedFilesSet.size) {

// Copy the bundle information from old state so we can patch it later if we are doing partial emit

if (useOldState) state.bundle = oldState!.bundle;

// If this program has prepend references, always emit since we wont know if files on disk are correct unless we check file hash for correctness

if (some(newProgram.getProjectReferences(), ref => !!ref.prepend)) state.programEmitPending = getBuilderFileEmit(compilerOptions);

}

return state;

state.changedFilesSet.add(path);

state.buildInfoEmitPending = true;

// Setting this to undefined as changed files means full emit so no need to track emit explicitly

state.programEmitPending = undefined;

return !!options.declarationMap === !!oldOptions.declarationMap ?

// Use same format of signature

oldEmitSignature :

// Convert to different format

isString(oldEmitSignature) ? [oldEmitSignature] : oldEmitSignature[0];

if (!diagnostics.length) return emptyArray;

let buildInfoDirectory: string | undefined;

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) {

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

return ts.toPath(path, buildInfoDirectory, newProgram.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 && new Map(state.affectedFilesPendingEmit),

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

programEmitPending: state.programEmitPending,

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.seenEmittedFiles = savedEmitState.seenEmittedFiles;

state.programEmitPending = savedEmitState.programEmitPending;

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,

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;

addToAffectedFilesPendingEmit(state, affectedFile.resolvedPath, getBuilderFileEmit(state.compilerOptions));

handleDtsMayChangeOfAffectedFile(

state,

affectedFile,

cancellationToken,

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,

host,

);

state.currentChangedFilePath = nextKey.value;

state.affectedFilesIndex = 0;

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

}

if (!state.affectedFilesPendingEmit?.size) return;

if (!emitOnlyDtsFiles) return state.affectedFilesPendingEmit = undefined;

state.affectedFilesPendingEmit.forEach((emitKind, path) => {

// Mark the files as pending only if they are pending on js files, remove the dts emit pending flag

const pending = emitKind & BuilderFileEmit.AllJs;

if (!pending) state.affectedFilesPendingEmit!.delete(path);

else state.affectedFilesPendingEmit!.set(path, pending);

});

if (!state.affectedFilesPendingEmit?.size) return undefined;

return forEachEntry(state.affectedFilesPendingEmit, (emitKind, path) => {

const affectedFile = state.program!.getSourceFileByPath(path);

if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program!)) {

state.affectedFilesPendingEmit!.delete(path);

return undefined;

}

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

let pendingKind = getPendingEmitKind(emitKind, seenKind);

if (emitOnlyDtsFiles) pendingKind = pendingKind & BuilderFileEmit.AllDts;

if (pendingKind) return { affectedFile, emitKind: pendingKind };

});

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,

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,

host,

);

return;

}

if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies) return;

handleDtsMayChangeOfReferencingExportOfAffectedFile(

state,

affectedFile,

cancellationToken,

host,

);

state: BuilderProgramState,

path: Path,

cancellationToken: CancellationToken | undefined,

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,

host,

/*useFileVersionAsSignature*/ true

);

// If not dts emit, nothing more to do

if (getEmitDeclarations(state.compilerOptions)) {

addToAffectedFilesPendingEmit(state, path, state.compilerOptions.declarationMap ? BuilderFileEmit.AllDts : BuilderFileEmit.Dts);

}

}

}

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,

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,

host,

));

removeDiagnosticsOfLibraryFiles(state);

return true;

state: BuilderProgramState,

affectedFile: SourceFile,

cancellationToken: CancellationToken | undefined,

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, host)) return;

handleDtsMayChangeOf(state, currentPath, cancellationToken, 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, host)) return true;

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

return references && forEachKey(references, filePath =>

handleDtsMayChangeOfFileAndExportsOfFile(

state,

filePath,

seenFileAndExportsOfFile,

cancellationToken,

host,

)

);

});

state: BuilderProgramState,

filePath: Path,

seenFileAndExportsOfFile: Set<string>,

cancellationToken: CancellationToken | undefined,

host: BuilderProgramHost,

): boolean | undefined {

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

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

handleDtsMayChangeOf(state, filePath, cancellationToken, 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,

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,

host,

)

);

return undefined;

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);