namespace ts {

const ignoreDiagnosticCommentRegEx = /(^\s*$)|(^\s*\/\/\/?\s*(@ts-ignore)?)/;

export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName = "tsconfig.json"): string | undefined {

return forEachAncestorDirectory(searchPath, ancestor => {

const fileName = combinePaths(ancestor, configName);

return fileExists(fileName) ? fileName : undefined;

});

}

export function resolveTripleslashReference(moduleName: string, containingFile: string): string {

const basePath = getDirectoryPath(containingFile);

const referencedFileName = isRootedDiskPath(moduleName) ? moduleName : combinePaths(basePath, moduleName);

return normalizePath(referencedFileName);

}

/* @internal */

export function computeCommonSourceDirectoryOfFilenames(fileNames: string[], currentDirectory: string, getCanonicalFileName: GetCanonicalFileName): string {

let commonPathComponents: string[] | undefined;

const failed = forEach(fileNames, sourceFile => {

// Each file contributes into common source file path

const sourcePathComponents = getNormalizedPathComponents(sourceFile, currentDirectory);

sourcePathComponents.pop(); // The base file name is not part of the common directory path

if (!commonPathComponents) {

// first file

commonPathComponents = sourcePathComponents;

return;

}

const n = Math.min(commonPathComponents.length, sourcePathComponents.length);

for (let i = 0; i < n; i++) {

if (getCanonicalFileName(commonPathComponents[i]) !== getCanonicalFileName(sourcePathComponents[i])) {

if (i === 0) {

// Failed to find any common path component

return true;

}

// New common path found that is 0 -> i-1

commonPathComponents.length = i;

break;

}

}

// If the sourcePathComponents was shorter than the commonPathComponents, truncate to the sourcePathComponents

if (sourcePathComponents.length < commonPathComponents.length) {

commonPathComponents.length = sourcePathComponents.length;

}

});

// A common path can not be found when paths span multiple drives on windows, for example

if (failed) {

return "";

}

if (!commonPathComponents) { // Can happen when all input files are .d.ts files

return currentDirectory;

}

return getPathFromPathComponents(commonPathComponents);

}

interface OutputFingerprint {

hash: string;

byteOrderMark: boolean;

mtime: Date;

}

export function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost {

return createCompilerHostWorker(options, setParentNodes);

}

/*@internal*/

// TODO(shkamat): update this after reworking ts build API

export function createCompilerHostWorker(options: CompilerOptions, setParentNodes?: boolean, system = sys): CompilerHost {

const existingDirectories = createMap<boolean>();

const getCanonicalFileName = createGetCanonicalFileName(system.useCaseSensitiveFileNames);

function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile | undefined {

let text: string | undefined;

try {

performance.mark("beforeIORead");

text = compilerHost.readFile(fileName);

performance.mark("afterIORead");

performance.measure("I/O Read", "beforeIORead", "afterIORead");

}

catch (e) {

if (onError) {

onError(e.message);

}

text = "";

}

return text !== undefined ? createSourceFile(fileName, text, languageVersion, setParentNodes) : undefined;

}

function directoryExists(directoryPath: string): boolean {

if (existingDirectories.has(directoryPath)) {

return true;

}

if ((compilerHost.directoryExists || system.directoryExists)(directoryPath)) {

existingDirectories.set(directoryPath, true);

return true;

}

return false;

}

function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) {

try {

performance.mark("beforeIOWrite");

// NOTE: If patchWriteFileEnsuringDirectory has been called,

// the system.writeFile will do its own directory creation and

// the ensureDirectoriesExist call will always be redundant.

writeFileEnsuringDirectories(

fileName,

data,

writeByteOrderMark,

(path, data, writeByteOrderMark) => writeFileWorker(path, data, writeByteOrderMark),

path => (compilerHost.createDirectory || system.createDirectory)(path),

path => directoryExists(path));

performance.mark("afterIOWrite");

performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite");

}

catch (e) {

if (onError) {

onError(e.message);

}

}

}

let outputFingerprints: Map<OutputFingerprint>;

function writeFileWorker(fileName: string, data: string, writeByteOrderMark: boolean) {

if (!isWatchSet(options) || !system.createHash || !system.getModifiedTime) {

system.writeFile(fileName, data, writeByteOrderMark);

return;

}

if (!outputFingerprints) {

outputFingerprints = createMap<OutputFingerprint>();

}

const hash = system.createHash(data);

const mtimeBefore = system.getModifiedTime(fileName);

if (mtimeBefore) {

const fingerprint = outputFingerprints.get(fileName);

// If output has not been changed, and the file has no external modification

if (fingerprint &&

fingerprint.byteOrderMark === writeByteOrderMark &&

fingerprint.hash === hash &&

fingerprint.mtime.getTime() === mtimeBefore.getTime()) {

return;

}

}

system.writeFile(fileName, data, writeByteOrderMark);

const mtimeAfter = system.getModifiedTime(fileName) || missingFileModifiedTime;

outputFingerprints.set(fileName, {

hash,

byteOrderMark: writeByteOrderMark,

mtime: mtimeAfter

});

}

function getDefaultLibLocation(): string {

return getDirectoryPath(normalizePath(system.getExecutingFilePath()));

}

const newLine = getNewLineCharacter(options, () => system.newLine);

const realpath = system.realpath && ((path: string) => system.realpath!(path));

const compilerHost: CompilerHost = {

getSourceFile,

getDefaultLibLocation,

getDefaultLibFileName: options => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),

writeFile,

getCurrentDirectory: memoize(() => system.getCurrentDirectory()),

useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,

getCanonicalFileName,

getNewLine: () => newLine,

fileExists: fileName => system.fileExists(fileName),

readFile: fileName => system.readFile(fileName),

trace: (s: string) => system.write(s + newLine),

directoryExists: directoryName => system.directoryExists(directoryName),

getEnvironmentVariable: name => system.getEnvironmentVariable ? system.getEnvironmentVariable(name) : "",

getDirectories: (path: string) => system.getDirectories(path),

realpath,

readDirectory: (path, extensions, include, exclude, depth) => system.readDirectory(path, extensions, include, exclude, depth),

createDirectory: d => system.createDirectory(d),

createHash: maybeBind(system, system.createHash)

};

return compilerHost;

}

/*@internal*/

interface CompilerHostLikeForCache {

fileExists(fileName: string): boolean;

readFile(fileName: string, encoding?: string): string | undefined;

directoryExists?(directory: string): boolean;

createDirectory?(directory: string): void;

writeFile?: WriteFileCallback;

}

/*@internal*/

export function changeCompilerHostLikeToUseCache(

host: CompilerHostLikeForCache,

toPath: (fileName: string) => Path,

getSourceFile?: CompilerHost["getSourceFile"]

) {

const originalReadFile = host.readFile;

const originalFileExists = host.fileExists;

const originalDirectoryExists = host.directoryExists;

const originalCreateDirectory = host.createDirectory;

const originalWriteFile = host.writeFile;

const readFileCache = createMap<string | false>();

const fileExistsCache = createMap<boolean>();

const directoryExistsCache = createMap<boolean>();

const sourceFileCache = createMap<SourceFile>();

const readFileWithCache = (fileName: string): string | undefined => {

const key = toPath(fileName);

const value = readFileCache.get(key);

if (value !== undefined) return value !== false ? value : undefined;

return setReadFileCache(key, fileName);

};

const setReadFileCache = (key: Path, fileName: string) => {

const newValue = originalReadFile.call(host, fileName);

readFileCache.set(key, newValue !== undefined ? newValue : false);

return newValue;

};

host.readFile = fileName => {

const key = toPath(fileName);

const value = readFileCache.get(key);

if (value !== undefined) return value !== false ? value : undefined; // could be .d.ts from output

// Cache json or buildInfo

if (!fileExtensionIs(fileName, Extension.Json) && !isBuildInfoFile(fileName)) {

return originalReadFile.call(host, fileName);

}

return setReadFileCache(key, fileName);

};

const getSourceFileWithCache: CompilerHost["getSourceFile"] | undefined = getSourceFile ? (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {

const key = toPath(fileName);

const value = sourceFileCache.get(key);

if (value) return value;

const sourceFile = getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);

if (sourceFile && (isDeclarationFileName(fileName) || fileExtensionIs(fileName, Extension.Json))) {

sourceFileCache.set(key, sourceFile);

}

return sourceFile;

} : undefined;

// fileExists for any kind of extension

host.fileExists = fileName => {

const key = toPath(fileName);

const value = fileExistsCache.get(key);

if (value !== undefined) return value;

const newValue = originalFileExists.call(host, fileName);

fileExistsCache.set(key, !!newValue);

return newValue;

};

if (originalWriteFile) {

host.writeFile = (fileName, data, writeByteOrderMark, onError, sourceFiles) => {

const key = toPath(fileName);

fileExistsCache.delete(key);

const value = readFileCache.get(key);

if (value !== undefined && value !== data) {

readFileCache.delete(key);

sourceFileCache.delete(key);

}

else if (getSourceFileWithCache) {

const sourceFile = sourceFileCache.get(key);

if (sourceFile && sourceFile.text !== data) {

sourceFileCache.delete(key);

}

}

originalWriteFile.call(host, fileName, data, writeByteOrderMark, onError, sourceFiles);

};

}

// directoryExists

if (originalDirectoryExists && originalCreateDirectory) {

host.directoryExists = directory => {

const key = toPath(directory);

const value = directoryExistsCache.get(key);

if (value !== undefined) return value;

const newValue = originalDirectoryExists.call(host, directory);

directoryExistsCache.set(key, !!newValue);

return newValue;

};

host.createDirectory = directory => {

const key = toPath(directory);

directoryExistsCache.delete(key);

originalCreateDirectory.call(host, directory);

};

}

return {

originalReadFile,

originalFileExists,

originalDirectoryExists,

originalCreateDirectory,

originalWriteFile,

getSourceFileWithCache,

readFileWithCache

};

}

export function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];

/*@internal*/ export function getPreEmitDiagnostics(program: BuilderProgram, sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[]; // eslint-disable-line @typescript-eslint/unified-signatures

export function getPreEmitDiagnostics(program: Program | BuilderProgram, sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[] {

const diagnostics = [

...program.getConfigFileParsingDiagnostics(),

...program.getOptionsDiagnostics(cancellationToken),

...program.getSyntacticDiagnostics(sourceFile, cancellationToken),

...program.getGlobalDiagnostics(cancellationToken),

...program.getSemanticDiagnostics(sourceFile, cancellationToken)

];

if (getEmitDeclarations(program.getCompilerOptions())) {

addRange(diagnostics, program.getDeclarationDiagnostics(sourceFile, cancellationToken));

}

return sortAndDeduplicateDiagnostics(diagnostics);

}

export interface FormatDiagnosticsHost {

getCurrentDirectory(): string;

getCanonicalFileName(fileName: string): string;

getNewLine(): string;

}

export function formatDiagnostics(diagnostics: readonly Diagnostic[], host: FormatDiagnosticsHost): string {

let output = "";

for (const diagnostic of diagnostics) {

output += formatDiagnostic(diagnostic, host);

}

return output;

}

export function formatDiagnostic(diagnostic: Diagnostic, host: FormatDiagnosticsHost): string {

const errorMessage = `${diagnosticCategoryName(diagnostic)} TS${diagnostic.code}: ${flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine())}${host.getNewLine()}`;

if (diagnostic.file) {

const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start!); // TODO: GH#18217

const fileName = diagnostic.file.fileName;

const relativeFileName = convertToRelativePath(fileName, host.getCurrentDirectory(), fileName => host.getCanonicalFileName(fileName));

return `${relativeFileName}(${line + 1},${character + 1}): ` + errorMessage;

}

return errorMessage;

}

/** @internal */

export enum ForegroundColorEscapeSequences {

Grey = "\u001b[90m",

Red = "\u001b[91m",

Yellow = "\u001b[93m",

Blue = "\u001b[94m",

Cyan = "\u001b[96m"

}

const gutterStyleSequence = "\u001b[7m";

const gutterSeparator = " ";

const resetEscapeSequence = "\u001b[0m";

const ellipsis = "...";

const halfIndent = " ";

const indent = " ";

function getCategoryFormat(category: DiagnosticCategory): ForegroundColorEscapeSequences {

switch (category) {

case DiagnosticCategory.Error: return ForegroundColorEscapeSequences.Red;

case DiagnosticCategory.Warning: return ForegroundColorEscapeSequences.Yellow;

case DiagnosticCategory.Suggestion: return Debug.fail("Should never get an Info diagnostic on the command line.");

case DiagnosticCategory.Message: return ForegroundColorEscapeSequences.Blue;

}

}

/** @internal */

export function formatColorAndReset(text: string, formatStyle: string) {

return formatStyle + text + resetEscapeSequence;

}

function padLeft(s: string, length: number) {

while (s.length < length) {

s = " " + s;

}

return s;

}

function formatCodeSpan(file: SourceFile, start: number, length: number, indent: string, squiggleColor: ForegroundColorEscapeSequences, host: FormatDiagnosticsHost) {

const { line: firstLine, character: firstLineChar } = getLineAndCharacterOfPosition(file, start);

const { line: lastLine, character: lastLineChar } = getLineAndCharacterOfPosition(file, start + length);

const lastLineInFile = getLineAndCharacterOfPosition(file, file.text.length).line;

const hasMoreThanFiveLines = (lastLine - firstLine) >= 4;

let gutterWidth = (lastLine + 1 + "").length;

if (hasMoreThanFiveLines) {

gutterWidth = Math.max(ellipsis.length, gutterWidth);

}

let context = "";

for (let i = firstLine; i <= lastLine; i++) {

context += host.getNewLine();

// If the error spans over 5 lines, we'll only show the first 2 and last 2 lines,

// so we'll skip ahead to the second-to-last line.

if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) {

context += indent + formatColorAndReset(padLeft(ellipsis, gutterWidth), gutterStyleSequence) + gutterSeparator + host.getNewLine();

i = lastLine - 1;

}

const lineStart = getPositionOfLineAndCharacter(file, i, 0);

const lineEnd = i < lastLineInFile ? getPositionOfLineAndCharacter(file, i + 1, 0) : file.text.length;

let lineContent = file.text.slice(lineStart, lineEnd);

lineContent = lineContent.replace(/\s+$/g, ""); // trim from end

lineContent = lineContent.replace("\t", " "); // convert tabs to single spaces

// Output the gutter and the actual contents of the line.

context += indent + formatColorAndReset(padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator;

context += lineContent + host.getNewLine();

// Output the gutter and the error span for the line using tildes.

context += indent + formatColorAndReset(padLeft("", gutterWidth), gutterStyleSequence) + gutterSeparator;

context += squiggleColor;

if (i === firstLine) {

// If we're on the last line, then limit it to the last character of the last line.

// Otherwise, we'll just squiggle the rest of the line, giving 'slice' no end position.

const lastCharForLine = i === lastLine ? lastLineChar : undefined;

context += lineContent.slice(0, firstLineChar).replace(/\S/g, " ");

context += lineContent.slice(firstLineChar, lastCharForLine).replace(/./g, "~");

}

else if (i === lastLine) {

context += lineContent.slice(0, lastLineChar).replace(/./g, "~");

}

else {

// Squiggle the entire line.

context += lineContent.replace(/./g, "~");

}

context += resetEscapeSequence;

}

return context;

}

/* @internal */

export function formatLocation(file: SourceFile, start: number, host: FormatDiagnosticsHost, color = formatColorAndReset) {

const { line: firstLine, character: firstLineChar } = getLineAndCharacterOfPosition(file, start); // TODO: GH#18217

const relativeFileName = host ? convertToRelativePath(file.fileName, host.getCurrentDirectory(), fileName => host.getCanonicalFileName(fileName)) : file.fileName;

let output = "";

output += color(relativeFileName, ForegroundColorEscapeSequences.Cyan);

output += ":";

output += color(`${firstLine + 1}`, ForegroundColorEscapeSequences.Yellow);

output += ":";

output += color(`${firstLineChar + 1}`, ForegroundColorEscapeSequences.Yellow);

return output;

}

export function formatDiagnosticsWithColorAndContext(diagnostics: readonly Diagnostic[], host: FormatDiagnosticsHost): string {

let output = "";

for (const diagnostic of diagnostics) {

if (diagnostic.file) {

const { file, start } = diagnostic;

output += formatLocation(file, start!, host); // TODO: GH#18217

output += " - ";

}

output += formatColorAndReset(diagnosticCategoryName(diagnostic), getCategoryFormat(diagnostic.category));

output += formatColorAndReset(` TS${diagnostic.code}: `, ForegroundColorEscapeSequences.Grey);

output += flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine());

if (diagnostic.file) {

output += host.getNewLine();

output += formatCodeSpan(diagnostic.file, diagnostic.start!, diagnostic.length!, "", getCategoryFormat(diagnostic.category), host); // TODO: GH#18217

if (diagnostic.relatedInformation) {

output += host.getNewLine();

for (const { file, start, length, messageText } of diagnostic.relatedInformation) {

if (file) {

output += host.getNewLine();

output += halfIndent + formatLocation(file, start!, host); // TODO: GH#18217

output += formatCodeSpan(file, start!, length!, indent, ForegroundColorEscapeSequences.Cyan, host); // TODO: GH#18217

}

output += host.getNewLine();

output += indent + flattenDiagnosticMessageText(messageText, host.getNewLine());

}

}

}

output += host.getNewLine();

}

return output;

}

export function flattenDiagnosticMessageText(diag: string | DiagnosticMessageChain | undefined, newLine: string, indent = 0): string {

if (isString(diag)) {

return diag;

}

else if (diag === undefined) {

return "";

}

let result = "";

if (indent) {

result += newLine;

for (let i = 0; i < indent; i++) {

result += " ";

}

}

result += diag.messageText;

indent++;

if (diag.next) {

for (const kid of diag.next) {

result += flattenDiagnosticMessageText(kid, newLine, indent);

}

}

return result;

}

/* @internal */

export function loadWithLocalCache<T>(names: string[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, loader: (name: string, containingFile: string, redirectedReference: ResolvedProjectReference | undefined) => T): T[] {

if (names.length === 0) {

return [];

}

const resolutions: T[] = [];

const cache = createMap<T>();

for (const name of names) {

let result: T;

if (cache.has(name)) {

result = cache.get(name)!;

}

else {

cache.set(name, result = loader(name, containingFile, redirectedReference));

}

resolutions.push(result);

}

return resolutions;

}

/* @internal */

export const inferredTypesContainingFile = "__inferred type names__.ts";

interface DiagnosticCache<T extends Diagnostic> {

perFile?: Map<T[]>;

allDiagnostics?: Diagnostic[];

}

interface RefFile extends TextRange {

kind: RefFileKind;

index: number;

file: SourceFile;

}

/**

* Determines if program structure is upto date or needs to be recreated

*/

/* @internal */

export function isProgramUptoDate(

program: Program | undefined,

rootFileNames: string[],

newOptions: CompilerOptions,

getSourceVersion: (path: Path) => string | undefined,

fileExists: (fileName: string) => boolean,

hasInvalidatedResolution: HasInvalidatedResolution,

hasChangedAutomaticTypeDirectiveNames: boolean,

projectReferences: readonly ProjectReference[] | undefined

): boolean {

// If we haven't created a program yet or have changed automatic type directives, then it is not up-to-date

if (!program || hasChangedAutomaticTypeDirectiveNames) {

return false;

}

// If number of files in the program do not match, it is not up-to-date

if (program.getRootFileNames().length !== rootFileNames.length) {

return false;

}

let seenResolvedRefs: ResolvedProjectReference[] | undefined;

// If project references dont match

if (!arrayIsEqualTo(program.getProjectReferences(), projectReferences, projectReferenceUptoDate)) {

return false;

}

// If any file is not up-to-date, then the whole program is not up-to-date

if (program.getSourceFiles().some(sourceFileNotUptoDate)) {

return false;

}

// If any of the missing file paths are now created

if (program.getMissingFilePaths().some(fileExists)) {

return false;

}

const currentOptions = program.getCompilerOptions();

// If the compilation settings do no match, then the program is not up-to-date

if (!compareDataObjects(currentOptions, newOptions)) {

return false;

}

// If everything matches but the text of config file is changed,

// error locations can change for program options, so update the program

if (currentOptions.configFile && newOptions.configFile) {

return currentOptions.configFile.text === newOptions.configFile.text;

}

return true;

function sourceFileNotUptoDate(sourceFile: SourceFile) {

return !sourceFileVersionUptoDate(sourceFile) ||

hasInvalidatedResolution(sourceFile.path);

}

function sourceFileVersionUptoDate(sourceFile: SourceFile) {

return sourceFile.version === getSourceVersion(sourceFile.resolvedPath);

}

function projectReferenceUptoDate(oldRef: ProjectReference, newRef: ProjectReference, index: number) {

if (!projectReferenceIsEqualTo(oldRef, newRef)) {

return false;

}

return resolvedProjectReferenceUptoDate(program!.getResolvedProjectReferences()![index], oldRef);

}

function resolvedProjectReferenceUptoDate(oldResolvedRef: ResolvedProjectReference | undefined, oldRef: ProjectReference): boolean {

if (oldResolvedRef) {

if (contains(seenResolvedRefs, oldResolvedRef)) {

// Assume true

return true;

}

// If sourceFile for the oldResolvedRef existed, check the version for uptodate

if (!sourceFileVersionUptoDate(oldResolvedRef.sourceFile)) {

return false;

}

// Add to seen before checking the referenced paths of this config file

(seenResolvedRefs || (seenResolvedRefs = [])).push(oldResolvedRef);

// If child project references are upto date, this project reference is uptodate

return !forEach(oldResolvedRef.references, (childResolvedRef, index) =>

!resolvedProjectReferenceUptoDate(childResolvedRef, oldResolvedRef.commandLine.projectReferences![index]));

}

// In old program, not able to resolve project reference path,

// so if config file doesnt exist, it is uptodate.

return !fileExists(resolveProjectReferencePath(oldRef));

}

}

export function getConfigFileParsingDiagnostics(configFileParseResult: ParsedCommandLine): readonly Diagnostic[] {

return configFileParseResult.options.configFile ?

[...configFileParseResult.options.configFile.parseDiagnostics, ...configFileParseResult.errors] :

configFileParseResult.errors;

}

/**

* Determine if source file needs to be re-created even if its text hasn't changed

*/

function shouldProgramCreateNewSourceFiles(program: Program | undefined, newOptions: CompilerOptions): boolean {

if (!program) return false;

// If any compiler options change, we can't reuse old source file even if version match

// The change in options like these could result in change in syntax tree or `sourceFile.bindDiagnostics`.

const oldOptions = program.getCompilerOptions();

return !!sourceFileAffectingCompilerOptions.some(option =>

!isJsonEqual(getCompilerOptionValue(oldOptions, option), getCompilerOptionValue(newOptions, option)));

}

function createCreateProgramOptions(rootNames: readonly string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program, configFileParsingDiagnostics?: readonly Diagnostic[]): CreateProgramOptions {

return {

rootNames,

options,

host,

oldProgram,

configFileParsingDiagnostics

};

}

/**

* Create a new 'Program' instance. A Program is an immutable collection of 'SourceFile's and a 'CompilerOptions'

* that represent a compilation unit.

*

* Creating a program proceeds from a set of root files, expanding the set of inputs by following imports and

* triple-slash-reference-path directives transitively. '@types' and triple-slash-reference-types are also pulled in.

*

* @param createProgramOptions - The options for creating a program.

* @returns A 'Program' object.

*/

export function createProgram(createProgramOptions: CreateProgramOptions): Program;

/**

* Create a new 'Program' instance. A Program is an immutable collection of 'SourceFile's and a 'CompilerOptions'

* that represent a compilation unit.

*

* Creating a program proceeds from a set of root files, expanding the set of inputs by following imports and

* triple-slash-reference-path directives transitively. '@types' and triple-slash-reference-types are also pulled in.

*

* @param rootNames - A set of root files.

* @param options - The compiler options which should be used.

* @param host - The host interacts with the underlying file system.

* @param oldProgram - Reuses an old program structure.

* @param configFileParsingDiagnostics - error during config file parsing

* @returns A 'Program' object.

*/

export function createProgram(rootNames: readonly string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program, configFileParsingDiagnostics?: readonly Diagnostic[]): Program;

export function createProgram(rootNamesOrOptions: readonly string[] | CreateProgramOptions, _options?: CompilerOptions, _host?: CompilerHost, _oldProgram?: Program, _configFileParsingDiagnostics?: readonly Diagnostic[]): Program {

const createProgramOptions = isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options!, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions; // TODO: GH#18217

const { rootNames, options, configFileParsingDiagnostics, projectReferences } = createProgramOptions;

let { oldProgram } = createProgramOptions;

let processingDefaultLibFiles: SourceFile[] | undefined;

let processingOtherFiles: SourceFile[] | undefined;

let files: SourceFile[];

let symlinks: ReadonlyMap<string> | undefined;

let commonSourceDirectory: string;

let diagnosticsProducingTypeChecker: TypeChecker;

let noDiagnosticsTypeChecker: TypeChecker;

let classifiableNames: UnderscoreEscapedMap<true>;

const ambientModuleNameToUnmodifiedFileName = createMap<string>();

// Todo:: Use this to report why file was included in --extendedDiagnostics

let refFileMap: MultiMap<ts.RefFile> | undefined;

const cachedSemanticDiagnosticsForFile: DiagnosticCache<Diagnostic> = {};

const cachedDeclarationDiagnosticsForFile: DiagnosticCache<DiagnosticWithLocation> = {};

let resolvedTypeReferenceDirectives = createMap<ResolvedTypeReferenceDirective | undefined>();

let fileProcessingDiagnostics = createDiagnosticCollection();

// The below settings are to track if a .js file should be add to the program if loaded via searching under node_modules.

// This works as imported modules are discovered recursively in a depth first manner, specifically:

// - For each root file, findSourceFile is called.

// - This calls processImportedModules for each module imported in the source file.

// - This calls resolveModuleNames, and then calls findSourceFile for each resolved module.

// As all these operations happen - and are nested - within the createProgram call, they close over the below variables.

// The current resolution depth is tracked by incrementing/decrementing as the depth first search progresses.

const maxNodeModuleJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0;

let currentNodeModulesDepth = 0;

// If a module has some of its imports skipped due to being at the depth limit under node_modules, then track

// this, as it may be imported at a shallower depth later, and then it will need its skipped imports processed.

const modulesWithElidedImports = createMap<boolean>();

// Track source files that are source files found by searching under node_modules, as these shouldn't be compiled.

const sourceFilesFoundSearchingNodeModules = createMap<boolean>();

performance.mark("beforeProgram");

const host = createProgramOptions.host || createCompilerHost(options);

const configParsingHost = parseConfigHostFromCompilerHostLike(host);

let skipDefaultLib = options.noLib;

const getDefaultLibraryFileName = memoize(() => host.getDefaultLibFileName(options));

const defaultLibraryPath = host.getDefaultLibLocation ? host.getDefaultLibLocation() : getDirectoryPath(getDefaultLibraryFileName());

const programDiagnostics = createDiagnosticCollection();

const currentDirectory = host.getCurrentDirectory();

const supportedExtensions = getSupportedExtensions(options);

const supportedExtensionsWithJsonIfResolveJsonModule = getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);

// Map storing if there is emit blocking diagnostics for given input

const hasEmitBlockingDiagnostics = createMap<boolean>();

let _compilerOptionsObjectLiteralSyntax: ObjectLiteralExpression | null | undefined;

let moduleResolutionCache: ModuleResolutionCache | undefined;

let resolveModuleNamesWorker: (moduleNames: string[], containingFile: string, reusedNames?: string[], redirectedReference?: ResolvedProjectReference) => ResolvedModuleFull[];

const hasInvalidatedResolution = host.hasInvalidatedResolution || returnFalse;

if (host.resolveModuleNames) {

resolveModuleNamesWorker = (moduleNames, containingFile, reusedNames, redirectedReference) => host.resolveModuleNames!(Debug.assertEachDefined(moduleNames), containingFile, reusedNames, redirectedReference, options).map(resolved => {

// An older host may have omitted extension, in which case we should infer it from the file extension of resolvedFileName.

if (!resolved || (resolved as ResolvedModuleFull).extension !== undefined) {

return resolved as ResolvedModuleFull;

}

const withExtension = clone(resolved) as ResolvedModuleFull;

withExtension.extension = extensionFromPath(resolved.resolvedFileName);

return withExtension;

});

}

else {

moduleResolutionCache = createModuleResolutionCache(currentDirectory, x => host.getCanonicalFileName(x), options);

const loader = (moduleName: string, containingFile: string, redirectedReference: ResolvedProjectReference | undefined) => resolveModuleName(moduleName, containingFile, options, host, moduleResolutionCache, redirectedReference).resolvedModule!; // TODO: GH#18217

resolveModuleNamesWorker = (moduleNames, containingFile, _reusedNames, redirectedReference) => loadWithLocalCache<ResolvedModuleFull>(Debug.assertEachDefined(moduleNames), containingFile, redirectedReference, loader);

}

let resolveTypeReferenceDirectiveNamesWorker: (typeDirectiveNames: string[], containingFile: string, redirectedReference?: ResolvedProjectReference) => (ResolvedTypeReferenceDirective | undefined)[];

if (host.resolveTypeReferenceDirectives) {

resolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference) => host.resolveTypeReferenceDirectives!(Debug.assertEachDefined(typeDirectiveNames), containingFile, redirectedReference, options);

}

else {

const loader = (typesRef: string, containingFile: string, redirectedReference: ResolvedProjectReference | undefined) => resolveTypeReferenceDirective(typesRef, containingFile, options, host, redirectedReference).resolvedTypeReferenceDirective!; // TODO: GH#18217

resolveTypeReferenceDirectiveNamesWorker = (typeReferenceDirectiveNames, containingFile, redirectedReference) => loadWithLocalCache<ResolvedTypeReferenceDirective>(Debug.assertEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, loader);

}

// Map from a stringified PackageId to the source file with that id.

// Only one source file may have a given packageId. Others become redirects (see createRedirectSourceFile).

// `packageIdToSourceFile` is only used while building the program, while `sourceFileToPackageName` and `isSourceFileTargetOfRedirect` are kept around.

const packageIdToSourceFile = createMap<SourceFile>();

// Maps from a SourceFile's `.path` to the name of the package it was imported with.

let sourceFileToPackageName = createMap<string>();

// Key is a file name. Value is the (non-empty, or undefined) list of files that redirect to it.

let redirectTargetsMap = createMultiMap<string>();

/**

* map with

* - SourceFile if present

* - false if sourceFile missing for source of project reference redirect

* - undefined otherwise

*/

const filesByName = createMap<SourceFile | false | undefined>();

let missingFilePaths: readonly Path[] | undefined;

// stores 'filename -> file association' ignoring case

// used to track cases when two file names differ only in casing

const filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? createMap<SourceFile>() : undefined;

// A parallel array to projectReferences storing the results of reading in the referenced tsconfig files

let resolvedProjectReferences: readonly (ResolvedProjectReference | undefined)[] | undefined;

let projectReferenceRedirects: Map<ResolvedProjectReference | false> | undefined;

let mapFromFileToProjectReferenceRedirects: Map<Path> | undefined;

let mapFromToProjectReferenceRedirectSource: Map<SourceOfProjectReferenceRedirect> | undefined;

const useSourceOfProjectReferenceRedirect = !!host.useSourceOfProjectReferenceRedirect && host.useSourceOfProjectReferenceRedirect();

const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);

// We set `structuralIsReused` to `undefined` because `tryReuseStructureFromOldProgram` calls `tryReuseStructureFromOldProgram` which checks

// `structuralIsReused`, which would be a TDZ violation if it was not set in advance to `undefined`.

let structuralIsReused: StructureIsReused | undefined;

structuralIsReused = tryReuseStructureFromOldProgram(); // eslint-disable-line prefer-const

if (structuralIsReused !== StructureIsReused.Completely) {

processingDefaultLibFiles = [];

processingOtherFiles = [];

if (projectReferences) {

if (!resolvedProjectReferences) {

resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile);

}

if (host.setResolvedProjectReferenceCallbacks) {

host.setResolvedProjectReferenceCallbacks({

getSourceOfProjectReferenceRedirect,

forEachResolvedProjectReference

});

}

if (rootNames.length) {

for (const parsedRef of resolvedProjectReferences) {

if (!parsedRef) continue;

const out = parsedRef.commandLine.options.outFile || parsedRef.commandLine.options.out;

if (useSourceOfProjectReferenceRedirect) {

if (out || getEmitModuleKind(parsedRef.commandLine.options) === ModuleKind.None) {

for (const fileName of parsedRef.commandLine.fileNames) {

processSourceFile(fileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined);

}

}

}

else {

if (out) {

processSourceFile(changeExtension(out, ".d.ts"), /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined);

}

else if (getEmitModuleKind(parsedRef.commandLine.options) === ModuleKind.None) {

for (const fileName of parsedRef.commandLine.fileNames) {

if (!fileExtensionIs(fileName, Extension.Dts)) {

processSourceFile(getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames()), /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined);

}

}

}

}

}

}

}

forEach(rootNames, name => processRootFile(name, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false));

// load type declarations specified via 'types' argument or implicitly from types/ and node_modules/@types folders

const typeReferences: string[] = rootNames.length ? getAutomaticTypeDirectiveNames(options, host) : emptyArray;

if (typeReferences.length) {

// This containingFilename needs to match with the one used in managed-side

const containingDirectory = options.configFilePath ? getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();

const containingFilename = combinePaths(containingDirectory, inferredTypesContainingFile);

const resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename);

for (let i = 0; i < typeReferences.length; i++) {

processTypeReferenceDirective(typeReferences[i], resolutions[i]);

}

}

// Do not process the default library if:

// - The '--noLib' flag is used.

// - A 'no-default-lib' reference comment is encountered in

// processing the root files.

if (rootNames.length && !skipDefaultLib) {

// If '--lib' is not specified, include default library file according to '--target'

// otherwise, using options specified in '--lib' instead of '--target' default library file

const defaultLibraryFileName = getDefaultLibraryFileName();

if (!options.lib && defaultLibraryFileName) {

processRootFile(defaultLibraryFileName, /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ false);

}

else {

forEach(options.lib, libFileName => {

processRootFile(combinePaths(defaultLibraryPath, libFileName), /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ false);

});

}

}

missingFilePaths = arrayFrom(mapDefinedIterator(filesByName.entries(), ([path, file]) => file === undefined ? path as Path : undefined));

files = stableSort(processingDefaultLibFiles, compareDefaultLibFiles).concat(processingOtherFiles);

processingDefaultLibFiles = undefined;

processingOtherFiles = undefined;

}

Debug.assert(!!missingFilePaths);

// Release any files we have acquired in the old program but are

// not part of the new program.

if (oldProgram && host.onReleaseOldSourceFile) {

const oldSourceFiles = oldProgram.getSourceFiles();

for (const oldSourceFile of oldSourceFiles) {

const newFile = getSourceFileByPath(oldSourceFile.resolvedPath);

if (shouldCreateNewSourceFile || !newFile ||

// old file wasnt redirect but new file is

(oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path)) {

host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path));

}

}

oldProgram.forEachResolvedProjectReference((resolvedProjectReference, resolvedProjectReferencePath) => {

if (resolvedProjectReference && !getResolvedProjectReferenceByPath(resolvedProjectReferencePath)) {

host.onReleaseOldSourceFile!(resolvedProjectReference.sourceFile, oldProgram!.getCompilerOptions(), /*hasSourceFileByPath*/ false);

}

});

}

// unconditionally set oldProgram to undefined to prevent it from being captured in closure

oldProgram = undefined;

const program: Program = {

getRootFileNames: () => rootNames,

getSourceFile,

getSourceFileByPath,

getSourceFiles: () => files,

getMissingFilePaths: () => missingFilePaths!, // TODO: GH#18217

getRefFileMap: () => refFileMap,

getCompilerOptions: () => options,

getSyntacticDiagnostics,

getOptionsDiagnostics,

getGlobalDiagnostics,

getSemanticDiagnostics,

getSuggestionDiagnostics,

getDeclarationDiagnostics,

getTypeChecker,

getClassifiableNames,

getDiagnosticsProducingTypeChecker,

getCommonSourceDirectory,

emit,

getCurrentDirectory: () => currentDirectory,

getNodeCount: () => getDiagnosticsProducingTypeChecker().getNodeCount(),

getIdentifierCount: () => getDiagnosticsProducingTypeChecker().getIdentifierCount(),

getSymbolCount: () => getDiagnosticsProducingTypeChecker().getSymbolCount(),

getTypeCount: () => getDiagnosticsProducingTypeChecker().getTypeCount(),

getRelationCacheSizes: () => getDiagnosticsProducingTypeChecker().getRelationCacheSizes(),

getFileProcessingDiagnostics: () => fileProcessingDiagnostics,

getResolvedTypeReferenceDirectives: () => resolvedTypeReferenceDirectives,

isSourceFileFromExternalLibrary,

isSourceFileDefaultLibrary,

dropDiagnosticsProducingTypeChecker,

getSourceFileFromReference,

getLibFileFromReference,

sourceFileToPackageName,

redirectTargetsMap,

isEmittedFile,

getConfigFileParsingDiagnostics,

getResolvedModuleWithFailedLookupLocationsFromCache,

getProjectReferences,

getResolvedProjectReferences,

getProjectReferenceRedirect,

getResolvedProjectReferenceToRedirect,

getResolvedProjectReferenceByPath,

forEachResolvedProjectReference,

isSourceOfProjectReferenceRedirect,

emitBuildInfo,

getProbableSymlinks

};

verifyCompilerOptions();

performance.mark("afterProgram");

performance.measure("Program", "beforeProgram", "afterProgram");

return program;

function compareDefaultLibFiles(a: SourceFile, b: SourceFile) {

return compareValues(getDefaultLibFilePriority(a), getDefaultLibFilePriority(b));

}

function getDefaultLibFilePriority(a: SourceFile) {

if (containsPath(defaultLibraryPath, a.fileName, /*ignoreCase*/ false)) {

const basename = getBaseFileName(a.fileName);

if (basename === "lib.d.ts" || basename === "lib.es6.d.ts") return 0;

const name = removeSuffix(removePrefix(basename, "lib."), ".d.ts");

const index = libs.indexOf(name);

if (index !== -1) return index + 1;

}

return libs.length + 2;

}

function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName: string, containingFile: string): ResolvedModuleWithFailedLookupLocations | undefined {

return moduleResolutionCache && resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache);