namespace ts {

const minimumDate = new Date(-8640000000000000);

const maximumDate = new Date(8640000000000000);

export interface BuildOptions {

dry?: boolean;

force?: boolean;

verbose?: boolean;

/*@internal*/ clean?: boolean;

/*@internal*/ watch?: boolean;

/*@internal*/ help?: boolean;

/*@internal*/ preserveWatchOutput?: boolean;

/*@internal*/ listEmittedFiles?: boolean;

/*@internal*/ listFiles?: boolean;

/*@internal*/ pretty?: boolean;

incremental?: boolean;

assumeChangesOnlyAffectDirectDependencies?: boolean;

traceResolution?: boolean;

/* @internal */ diagnostics?: boolean;

/* @internal */ extendedDiagnostics?: boolean;

/* @internal */ locale?: string;

/* @internal */ generateCpuProfile?: string;

[option: string]: CompilerOptionsValue | undefined;

}

enum BuildResultFlags {

None = 0,

/**

* No errors of any kind occurred during build

*/

Success = 1 << 0,

/**

* None of the .d.ts files emitted by this build were

* different from the existing files on disk

*/

DeclarationOutputUnchanged = 1 << 1,

ConfigFileErrors = 1 << 2,

SyntaxErrors = 1 << 3,

TypeErrors = 1 << 4,

DeclarationEmitErrors = 1 << 5,

EmitErrors = 1 << 6,

AnyErrors = ConfigFileErrors | SyntaxErrors | TypeErrors | DeclarationEmitErrors | EmitErrors

}

/*@internal*/

export type ResolvedConfigFilePath = ResolvedConfigFileName & Path;

function getOrCreateValueFromConfigFileMap<T>(configFileMap: ESMap<ResolvedConfigFilePath, T>, resolved: ResolvedConfigFilePath, createT: () => T): T {

const existingValue = configFileMap.get(resolved);

let newValue: T | undefined;

if (!existingValue) {

newValue = createT();

configFileMap.set(resolved, newValue);

}

return existingValue || newValue!;

}

function getOrCreateValueMapFromConfigFileMap<T>(configFileMap: ESMap<ResolvedConfigFilePath, ESMap<string, T>>, resolved: ResolvedConfigFilePath): ESMap<string, T> {

return getOrCreateValueFromConfigFileMap<ESMap<string, T>>(configFileMap, resolved, () => new Map());

}

function newer(date1: Date, date2: Date): Date {

return date2 > date1 ? date2 : date1;

}

function isDeclarationFile(fileName: string) {

return fileExtensionIs(fileName, Extension.Dts);

}

export type ReportEmitErrorSummary = (errorCount: number) => void;

export interface SolutionBuilderHostBase<T extends BuilderProgram> extends ProgramHost<T> {

createDirectory?(path: string): void;

/**

* Should provide create directory and writeFile if done of invalidatedProjects is not invoked with

* writeFileCallback

*/

writeFile?(path: string, data: string, writeByteOrderMark?: boolean): void;

getModifiedTime(fileName: string): Date | undefined;

setModifiedTime(fileName: string, date: Date): void;

deleteFile(fileName: string): void;

getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;

reportDiagnostic: DiagnosticReporter; // Technically we want to move it out and allow steps of actions on Solution, but for now just merge stuff in build host here

reportSolutionBuilderStatus: DiagnosticReporter;

// TODO: To do better with watch mode and normal build mode api that creates program and emits files

// This currently helps enable --diagnostics and --extendedDiagnostics

afterProgramEmitAndDiagnostics?(program: T): void;

/*@internal*/ afterEmitBundle?(config: ParsedCommandLine): void;

// For testing

/*@internal*/ now?(): Date;

}

export interface SolutionBuilderHost<T extends BuilderProgram> extends SolutionBuilderHostBase<T> {

reportErrorSummary?: ReportEmitErrorSummary;

}

export interface SolutionBuilderWithWatchHost<T extends BuilderProgram> extends SolutionBuilderHostBase<T>, WatchHost {

}

/*@internal*/

export type BuildOrder = readonly ResolvedConfigFileName[];

/*@internal*/

export interface CircularBuildOrder {

buildOrder: BuildOrder;

circularDiagnostics: readonly Diagnostic[];

}

/*@internal*/

export type AnyBuildOrder = BuildOrder | CircularBuildOrder;

/*@internal*/

export function isCircularBuildOrder(buildOrder: AnyBuildOrder): buildOrder is CircularBuildOrder {

return !!buildOrder && !!(buildOrder as CircularBuildOrder).buildOrder;

}

/*@internal*/

export function getBuildOrderFromAnyBuildOrder(anyBuildOrder: AnyBuildOrder): BuildOrder {

return isCircularBuildOrder(anyBuildOrder) ? anyBuildOrder.buildOrder : anyBuildOrder;

}

export interface SolutionBuilder<T extends BuilderProgram> {

build(project?: string, cancellationToken?: CancellationToken): ExitStatus;

clean(project?: string): ExitStatus;

buildReferences(project: string, cancellationToken?: CancellationToken): ExitStatus;

cleanReferences(project?: string): ExitStatus;

getNextInvalidatedProject(cancellationToken?: CancellationToken): InvalidatedProject<T> | undefined;

// Currently used for testing but can be made public if needed:

/*@internal*/ getBuildOrder(): AnyBuildOrder;

// Testing only

/*@internal*/ getUpToDateStatusOfProject(project: string): UpToDateStatus;

/*@internal*/ invalidateProject(configFilePath: ResolvedConfigFilePath, reloadLevel?: ConfigFileProgramReloadLevel): void;

/*@internal*/ buildNextInvalidatedProject(): void;

/*@internal*/ getAllParsedConfigs(): readonly ParsedCommandLine[];

/*@internal*/ close(): void;

}

/**

* Create a function that reports watch status by writing to the system and handles the formating of the diagnostic

*/

export function createBuilderStatusReporter(system: System, pretty?: boolean): DiagnosticReporter {

return diagnostic => {

let output = pretty ? `[${formatColorAndReset(getLocaleTimeString(system), ForegroundColorEscapeSequences.Grey)}] ` : `${getLocaleTimeString(system)} - `;

output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${system.newLine + system.newLine}`;

system.write(output);

};

}

function createSolutionBuilderHostBase<T extends BuilderProgram>(system: System, createProgram: CreateProgram<T> | undefined, reportDiagnostic?: DiagnosticReporter, reportSolutionBuilderStatus?: DiagnosticReporter) {

const host = createProgramHost(system, createProgram) as SolutionBuilderHostBase<T>;

host.getModifiedTime = system.getModifiedTime ? path => system.getModifiedTime!(path) : returnUndefined;

host.setModifiedTime = system.setModifiedTime ? (path, date) => system.setModifiedTime!(path, date) : noop;

host.deleteFile = system.deleteFile ? path => system.deleteFile!(path) : noop;

host.reportDiagnostic = reportDiagnostic || createDiagnosticReporter(system);

host.reportSolutionBuilderStatus = reportSolutionBuilderStatus || createBuilderStatusReporter(system);

host.now = maybeBind(system, system.now); // For testing

return host;

}

export function createSolutionBuilderHost<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>(system = sys, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportSolutionBuilderStatus?: DiagnosticReporter, reportErrorSummary?: ReportEmitErrorSummary) {

const host = createSolutionBuilderHostBase(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus) as SolutionBuilderHost<T>;

host.reportErrorSummary = reportErrorSummary;

return host;

}

export function createSolutionBuilderWithWatchHost<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>(system = sys, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportSolutionBuilderStatus?: DiagnosticReporter, reportWatchStatus?: WatchStatusReporter) {

const host = createSolutionBuilderHostBase(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus) as SolutionBuilderWithWatchHost<T>;

const watchHost = createWatchHost(system, reportWatchStatus);

copyProperties(host, watchHost);

return host;

}

function getCompilerOptionsOfBuildOptions(buildOptions: BuildOptions): CompilerOptions {

const result = {} as CompilerOptions;

commonOptionsWithBuild.forEach(option => {

if (hasProperty(buildOptions, option.name)) result[option.name] = buildOptions[option.name];

});

return result;

}

export function createSolutionBuilder<T extends BuilderProgram>(host: SolutionBuilderHost<T>, rootNames: readonly string[], defaultOptions: BuildOptions): SolutionBuilder<T> {

return createSolutionBuilderWorker(/*watch*/ false, host, rootNames, defaultOptions);

}

export function createSolutionBuilderWithWatch<T extends BuilderProgram>(host: SolutionBuilderWithWatchHost<T>, rootNames: readonly string[], defaultOptions: BuildOptions, baseWatchOptions?: WatchOptions): SolutionBuilder<T> {

return createSolutionBuilderWorker(/*watch*/ true, host, rootNames, defaultOptions, baseWatchOptions);

}

type ConfigFileCacheEntry = ParsedCommandLine | Diagnostic;

interface SolutionBuilderStateCache {

originalReadFile: CompilerHost["readFile"];

originalFileExists: CompilerHost["fileExists"];

originalDirectoryExists: CompilerHost["directoryExists"];

originalCreateDirectory: CompilerHost["createDirectory"];

originalWriteFile: CompilerHost["writeFile"] | undefined;

originalReadFileWithCache: CompilerHost["readFile"];

originalGetSourceFile: CompilerHost["getSourceFile"];

}

interface SolutionBuilderState<T extends BuilderProgram = BuilderProgram> {

readonly host: SolutionBuilderHost<T>;

readonly hostWithWatch: SolutionBuilderWithWatchHost<T>;

readonly currentDirectory: string;

readonly getCanonicalFileName: GetCanonicalFileName;

readonly parseConfigFileHost: ParseConfigFileHost;

readonly writeFileName: ((s: string) => void) | undefined;

// State of solution

readonly options: BuildOptions;

readonly baseCompilerOptions: CompilerOptions;

readonly rootNames: readonly string[];

readonly baseWatchOptions: WatchOptions | undefined;

readonly resolvedConfigFilePaths: ESMap<string, ResolvedConfigFilePath>;

readonly configFileCache: ESMap<ResolvedConfigFilePath, ConfigFileCacheEntry>;

/** Map from config file name to up-to-date status */

readonly projectStatus: ESMap<ResolvedConfigFilePath, UpToDateStatus>;

readonly buildInfoChecked: ESMap<ResolvedConfigFilePath, true>;

readonly extendedConfigCache: ESMap<string, ExtendedConfigCacheEntry>;

readonly builderPrograms: ESMap<ResolvedConfigFilePath, T>;

readonly diagnostics: ESMap<ResolvedConfigFilePath, readonly Diagnostic[]>;

readonly projectPendingBuild: ESMap<ResolvedConfigFilePath, ConfigFileProgramReloadLevel>;

readonly projectErrorsReported: ESMap<ResolvedConfigFilePath, true>;

readonly compilerHost: CompilerHost;

readonly moduleResolutionCache: ModuleResolutionCache | undefined;

// Mutable state

buildOrder: AnyBuildOrder | undefined;

readFileWithCache: (f: string) => string | undefined;

projectCompilerOptions: CompilerOptions;

cache: SolutionBuilderStateCache | undefined;

allProjectBuildPending: boolean;

needsSummary: boolean;

watchAllProjectsPending: boolean;

currentInvalidatedProject: InvalidatedProject<T> | undefined;

// Watch state

readonly watch: boolean;

readonly allWatchedWildcardDirectories: ESMap<ResolvedConfigFilePath, ESMap<string, WildcardDirectoryWatcher>>;

readonly allWatchedInputFiles: ESMap<ResolvedConfigFilePath, ESMap<Path, FileWatcher>>;

readonly allWatchedConfigFiles: ESMap<ResolvedConfigFilePath, FileWatcher>;

timerToBuildInvalidatedProject: any;

reportFileChangeDetected: boolean;

watchFile: WatchFile<WatchType, ResolvedConfigFileName>;

watchFilePath: WatchFilePath<WatchType, ResolvedConfigFileName>;

watchDirectory: WatchDirectory<WatchType, ResolvedConfigFileName>;

writeLog: (s: string) => void;

}

function createSolutionBuilderState<T extends BuilderProgram>(watch: boolean, hostOrHostWithWatch: SolutionBuilderHost<T> | SolutionBuilderWithWatchHost<T>, rootNames: readonly string[], options: BuildOptions, baseWatchOptions: WatchOptions | undefined): SolutionBuilderState<T> {

const host = hostOrHostWithWatch as SolutionBuilderHost<T>;

const hostWithWatch = hostOrHostWithWatch as SolutionBuilderWithWatchHost<T>;

const currentDirectory = host.getCurrentDirectory();

const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());

// State of the solution

const baseCompilerOptions = getCompilerOptionsOfBuildOptions(options);

const compilerHost = createCompilerHostFromProgramHost(host, () => state.projectCompilerOptions);

setGetSourceFileAsHashVersioned(compilerHost, host);

compilerHost.getParsedCommandLine = fileName => parseConfigFile(state, fileName as ResolvedConfigFileName, toResolvedConfigFilePath(state, fileName as ResolvedConfigFileName));

compilerHost.resolveModuleNames = maybeBind(host, host.resolveModuleNames);

compilerHost.resolveTypeReferenceDirectives = maybeBind(host, host.resolveTypeReferenceDirectives);

const moduleResolutionCache = !compilerHost.resolveModuleNames ? createModuleResolutionCache(currentDirectory, getCanonicalFileName) : undefined;

if (!compilerHost.resolveModuleNames) {

const loader = (moduleName: string, containingFile: string, redirectedReference: ResolvedProjectReference | undefined) => resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference).resolvedModule!;

compilerHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference) =>

loadWithLocalCache<ResolvedModuleFull>(Debug.checkEachDefined(moduleNames), containingFile, redirectedReference, loader);

}

const { watchFile, watchFilePath, watchDirectory, writeLog } = createWatchFactory<ResolvedConfigFileName>(hostWithWatch, options);

const state: SolutionBuilderState<T> = {

host,

hostWithWatch,

currentDirectory,

getCanonicalFileName,

parseConfigFileHost: parseConfigHostFromCompilerHostLike(host),

writeFileName: host.trace ? (s: string) => host.trace!(s) : undefined,

// State of solution

options,

baseCompilerOptions,

rootNames,

baseWatchOptions,

resolvedConfigFilePaths: new Map(),

configFileCache: new Map(),

projectStatus: new Map(),

buildInfoChecked: new Map(),

extendedConfigCache: new Map(),

builderPrograms: new Map(),

diagnostics: new Map(),

projectPendingBuild: new Map(),

projectErrorsReported: new Map(),

compilerHost,

moduleResolutionCache,

// Mutable state

buildOrder: undefined,

readFileWithCache: f => host.readFile(f),

projectCompilerOptions: baseCompilerOptions,

cache: undefined,

allProjectBuildPending: true,

needsSummary: true,

watchAllProjectsPending: watch,

currentInvalidatedProject: undefined,

// Watch state

watch,

allWatchedWildcardDirectories: new Map(),

allWatchedInputFiles: new Map(),

allWatchedConfigFiles: new Map(),

timerToBuildInvalidatedProject: undefined,

reportFileChangeDetected: false,

watchFile,

watchFilePath,

watchDirectory,

writeLog,

};

return state;

}

function toPath(state: SolutionBuilderState, fileName: string) {

return ts.toPath(fileName, state.currentDirectory, state.getCanonicalFileName);

}

function toResolvedConfigFilePath(state: SolutionBuilderState, fileName: ResolvedConfigFileName): ResolvedConfigFilePath {

const { resolvedConfigFilePaths } = state;

const path = resolvedConfigFilePaths.get(fileName);

if (path !== undefined) return path;

const resolvedPath = toPath(state, fileName) as ResolvedConfigFilePath;

resolvedConfigFilePaths.set(fileName, resolvedPath);

return resolvedPath;

}

function isParsedCommandLine(entry: ConfigFileCacheEntry): entry is ParsedCommandLine {

return !!(entry as ParsedCommandLine).options;

}

function parseConfigFile(state: SolutionBuilderState, configFileName: ResolvedConfigFileName, configFilePath: ResolvedConfigFilePath): ParsedCommandLine | undefined {

const { configFileCache } = state;

const value = configFileCache.get(configFilePath);

if (value) {

return isParsedCommandLine(value) ? value : undefined;

}

let diagnostic: Diagnostic | undefined;

const { parseConfigFileHost, baseCompilerOptions, baseWatchOptions, extendedConfigCache, host } = state;

let parsed: ParsedCommandLine | undefined;

if (host.getParsedCommandLine) {

parsed = host.getParsedCommandLine(configFileName);

if (!parsed) diagnostic = createCompilerDiagnostic(Diagnostics.File_0_not_found, configFileName);

}

else {

parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = d => diagnostic = d;

parsed = getParsedCommandLineOfConfigFile(configFileName, baseCompilerOptions, parseConfigFileHost, extendedConfigCache, baseWatchOptions);

parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = noop;

}

configFileCache.set(configFilePath, parsed || diagnostic!);

return parsed;

}

function resolveProjectName(state: SolutionBuilderState, name: string): ResolvedConfigFileName {

return resolveConfigFileProjectName(resolvePath(state.currentDirectory, name));

}

function createBuildOrder(state: SolutionBuilderState, roots: readonly ResolvedConfigFileName[]): AnyBuildOrder {

const temporaryMarks = new Map<ResolvedConfigFilePath, true>();

const permanentMarks = new Map<ResolvedConfigFilePath, true>();

const circularityReportStack: string[] = [];

let buildOrder: ResolvedConfigFileName[] | undefined;

let circularDiagnostics: Diagnostic[] | undefined;

for (const root of roots) {

visit(root);

}

return circularDiagnostics ?

{ buildOrder: buildOrder || emptyArray, circularDiagnostics } :

buildOrder || emptyArray;

function visit(configFileName: ResolvedConfigFileName, inCircularContext?: boolean) {

const projPath = toResolvedConfigFilePath(state, configFileName);

// Already visited

if (permanentMarks.has(projPath)) return;

// Circular

if (temporaryMarks.has(projPath)) {

if (!inCircularContext) {

(circularDiagnostics || (circularDiagnostics = [])).push(

createCompilerDiagnostic(

Diagnostics.Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0,

circularityReportStack.join("\r\n")

)

);

}

return;

}

temporaryMarks.set(projPath, true);

circularityReportStack.push(configFileName);

const parsed = parseConfigFile(state, configFileName, projPath);

if (parsed && parsed.projectReferences) {

for (const ref of parsed.projectReferences) {

const resolvedRefPath = resolveProjectName(state, ref.path);

visit(resolvedRefPath, inCircularContext || ref.circular);

}

}

circularityReportStack.pop();

permanentMarks.set(projPath, true);

(buildOrder || (buildOrder = [])).push(configFileName);

}

}

function getBuildOrder(state: SolutionBuilderState) {

return state.buildOrder || createStateBuildOrder(state);

}

function createStateBuildOrder(state: SolutionBuilderState) {

const buildOrder = createBuildOrder(state, state.rootNames.map(f => resolveProjectName(state, f)));

// Clear all to ResolvedConfigFilePaths cache to start fresh

state.resolvedConfigFilePaths.clear();

// TODO(rbuckton): Should be a `Set`, but that requires changing the code below that uses `mutateMapSkippingNewValues`

const currentProjects = new Map(

getBuildOrderFromAnyBuildOrder(buildOrder).map(

resolved => [toResolvedConfigFilePath(state, resolved), true as true])

);

const noopOnDelete = { onDeleteValue: noop };

// Config file cache

mutateMapSkippingNewValues(state.configFileCache, currentProjects, noopOnDelete);

mutateMapSkippingNewValues(state.projectStatus, currentProjects, noopOnDelete);

mutateMapSkippingNewValues(state.buildInfoChecked, currentProjects, noopOnDelete);

mutateMapSkippingNewValues(state.builderPrograms, currentProjects, noopOnDelete);

mutateMapSkippingNewValues(state.diagnostics, currentProjects, noopOnDelete);

mutateMapSkippingNewValues(state.projectPendingBuild, currentProjects, noopOnDelete);

mutateMapSkippingNewValues(state.projectErrorsReported, currentProjects, noopOnDelete);

// Remove watches for the program no longer in the solution

if (state.watch) {

mutateMapSkippingNewValues(

state.allWatchedConfigFiles,

currentProjects,

{ onDeleteValue: closeFileWatcher }

);

mutateMapSkippingNewValues(

state.allWatchedWildcardDirectories,

currentProjects,

{ onDeleteValue: existingMap => existingMap.forEach(closeFileWatcherOf) }

);

mutateMapSkippingNewValues(

state.allWatchedInputFiles,

currentProjects,

{ onDeleteValue: existingMap => existingMap.forEach(closeFileWatcher) }

);

}

return state.buildOrder = buildOrder;

}

function getBuildOrderFor(state: SolutionBuilderState, project: string | undefined, onlyReferences: boolean | undefined): AnyBuildOrder | undefined {

const resolvedProject = project && resolveProjectName(state, project);

const buildOrderFromState = getBuildOrder(state);

if (isCircularBuildOrder(buildOrderFromState)) return buildOrderFromState;

if (resolvedProject) {

const projectPath = toResolvedConfigFilePath(state, resolvedProject);

const projectIndex = findIndex(

buildOrderFromState,

configFileName => toResolvedConfigFilePath(state, configFileName) === projectPath

);

if (projectIndex === -1) return undefined;

}

const buildOrder = resolvedProject ? createBuildOrder(state, [resolvedProject]) as BuildOrder : buildOrderFromState;

Debug.assert(!isCircularBuildOrder(buildOrder));

Debug.assert(!onlyReferences || resolvedProject !== undefined);

Debug.assert(!onlyReferences || buildOrder[buildOrder.length - 1] === resolvedProject);

return onlyReferences ? buildOrder.slice(0, buildOrder.length - 1) : buildOrder;

}

function enableCache(state: SolutionBuilderState) {

if (state.cache) {

disableCache(state);

}

const { compilerHost, host } = state;

const originalReadFileWithCache = state.readFileWithCache;

const originalGetSourceFile = compilerHost.getSourceFile;

const {

originalReadFile, originalFileExists, originalDirectoryExists,

originalCreateDirectory, originalWriteFile,

getSourceFileWithCache, readFileWithCache

} = changeCompilerHostLikeToUseCache(

host,

fileName => toPath(state, fileName),

(...args) => originalGetSourceFile.call(compilerHost, ...args)

);

state.readFileWithCache = readFileWithCache;

compilerHost.getSourceFile = getSourceFileWithCache!;

state.cache = {

originalReadFile,

originalFileExists,

originalDirectoryExists,

originalCreateDirectory,

originalWriteFile,

originalReadFileWithCache,

originalGetSourceFile,

};

}

function disableCache(state: SolutionBuilderState) {

if (!state.cache) return;

const { cache, host, compilerHost, extendedConfigCache, moduleResolutionCache } = state;

host.readFile = cache.originalReadFile;

host.fileExists = cache.originalFileExists;

host.directoryExists = cache.originalDirectoryExists;

host.createDirectory = cache.originalCreateDirectory;

host.writeFile = cache.originalWriteFile;

compilerHost.getSourceFile = cache.originalGetSourceFile;

state.readFileWithCache = cache.originalReadFileWithCache;

extendedConfigCache.clear();

if (moduleResolutionCache) {

moduleResolutionCache.directoryToModuleNameMap.clear();

moduleResolutionCache.moduleNameToDirectoryMap.clear();

}

state.cache = undefined;

}

function clearProjectStatus(state: SolutionBuilderState, resolved: ResolvedConfigFilePath) {

state.projectStatus.delete(resolved);

state.diagnostics.delete(resolved);

}

function addProjToQueue({ projectPendingBuild }: SolutionBuilderState, proj: ResolvedConfigFilePath, reloadLevel: ConfigFileProgramReloadLevel) {

const value = projectPendingBuild.get(proj);

if (value === undefined) {

projectPendingBuild.set(proj, reloadLevel);

}

else if (value < reloadLevel) {

projectPendingBuild.set(proj, reloadLevel);

}

}

function setupInitialBuild(state: SolutionBuilderState, cancellationToken: CancellationToken | undefined) {

// Set initial build if not already built

if (!state.allProjectBuildPending) return;

state.allProjectBuildPending = false;

if (state.options.watch) { reportWatchStatus(state, Diagnostics.Starting_compilation_in_watch_mode); }

enableCache(state);

const buildOrder = getBuildOrderFromAnyBuildOrder(getBuildOrder(state));

buildOrder.forEach(configFileName =>

state.projectPendingBuild.set(

toResolvedConfigFilePath(state, configFileName),

ConfigFileProgramReloadLevel.None

)

);

if (cancellationToken) {

cancellationToken.throwIfCancellationRequested();

}

}

export enum InvalidatedProjectKind {

Build,

UpdateBundle,

UpdateOutputFileStamps

}

export interface InvalidatedProjectBase {

readonly kind: InvalidatedProjectKind;

readonly project: ResolvedConfigFileName;

/*@internal*/ readonly projectPath: ResolvedConfigFilePath;

/*@internal*/ readonly buildOrder: readonly ResolvedConfigFileName[];

/**

* To dispose this project and ensure that all the necessary actions are taken and state is updated accordingly

*/

done(cancellationToken?: CancellationToken, writeFile?: WriteFileCallback, customTransformers?: CustomTransformers): ExitStatus;

getCompilerOptions(): CompilerOptions;

getCurrentDirectory(): string;

}

export interface UpdateOutputFileStampsProject extends InvalidatedProjectBase {

readonly kind: InvalidatedProjectKind.UpdateOutputFileStamps;

updateOutputFileStatmps(): void;

}

export interface BuildInvalidedProject<T extends BuilderProgram> extends InvalidatedProjectBase {

readonly kind: InvalidatedProjectKind.Build;

/*

* Emitting with this builder program without the api provided for this project

* can result in build system going into invalid state as files written reflect the state of the project

*/

getBuilderProgram(): T | undefined;

getProgram(): Program | undefined;

getSourceFile(fileName: string): SourceFile | undefined;

getSourceFiles(): readonly SourceFile[];

getOptionsDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];

getGlobalDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];

getConfigFileParsingDiagnostics(): readonly Diagnostic[];

getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];

getAllDependencies(sourceFile: SourceFile): readonly string[];

getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];

getSemanticDiagnosticsOfNextAffectedFile(cancellationToken?: CancellationToken, ignoreSourceFile?: (sourceFile: SourceFile) => boolean): AffectedFileResult<readonly Diagnostic[]>;

/*

* Calling emit directly with targetSourceFile and emitOnlyDtsFiles set to true is not advised since

* emit in build system is responsible in updating status of the project

* If called with targetSourceFile and emitOnlyDtsFiles set to true, the emit just passes to underlying builder and

* wont reflect the status of file as being emitted in the builder

* (if that emit of that source file is required it would be emitted again when making sure invalidated project is completed)

* This emit is not considered actual emit (and hence uptodate status is not reflected if

*/

emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult | undefined;

// TODO(shkamat):: investigate later if we can emit even when there are declaration diagnostics

// emitNextAffectedFile(writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, customTransformers?: CustomTransformers): AffectedFileResult<EmitResult>;

}

export interface UpdateBundleProject<T extends BuilderProgram> extends InvalidatedProjectBase {

readonly kind: InvalidatedProjectKind.UpdateBundle;

emit(writeFile?: WriteFileCallback, customTransformers?: CustomTransformers): EmitResult | BuildInvalidedProject<T> | undefined;

}

export type InvalidatedProject<T extends BuilderProgram> = UpdateOutputFileStampsProject | BuildInvalidedProject<T> | UpdateBundleProject<T>;

function doneInvalidatedProject(

state: SolutionBuilderState,

projectPath: ResolvedConfigFilePath

) {

state.projectPendingBuild.delete(projectPath);

state.currentInvalidatedProject = undefined;

return state.diagnostics.has(projectPath) ?

ExitStatus.DiagnosticsPresent_OutputsSkipped :

ExitStatus.Success;

}

function createUpdateOutputFileStampsProject(

state: SolutionBuilderState,

project: ResolvedConfigFileName,

projectPath: ResolvedConfigFilePath,

config: ParsedCommandLine,

buildOrder: readonly ResolvedConfigFileName[]

): UpdateOutputFileStampsProject {

let updateOutputFileStampsPending = true;

return {

kind: InvalidatedProjectKind.UpdateOutputFileStamps,

project,

projectPath,

buildOrder,

getCompilerOptions: () => config.options,

getCurrentDirectory: () => state.currentDirectory,

updateOutputFileStatmps: () => {

updateOutputTimestamps(state, config, projectPath);

updateOutputFileStampsPending = false;

},

done: () => {

if (updateOutputFileStampsPending) {

updateOutputTimestamps(state, config, projectPath);

}

return doneInvalidatedProject(state, projectPath);

}

};

}

enum BuildStep {

CreateProgram,

SyntaxDiagnostics,

SemanticDiagnostics,

Emit,

EmitBundle,

EmitBuildInfo,

BuildInvalidatedProjectOfBundle,

QueueReferencingProjects,

Done

}

function createBuildOrUpdateInvalidedProject<T extends BuilderProgram>(

kind: InvalidatedProjectKind.Build | InvalidatedProjectKind.UpdateBundle,

state: SolutionBuilderState<T>,

project: ResolvedConfigFileName,

projectPath: ResolvedConfigFilePath,

projectIndex: number,

config: ParsedCommandLine,

buildOrder: readonly ResolvedConfigFileName[],

): BuildInvalidedProject<T> | UpdateBundleProject<T> {

let step = kind === InvalidatedProjectKind.Build ? BuildStep.CreateProgram : BuildStep.EmitBundle;

let program: T | undefined;

let buildResult: BuildResultFlags | undefined;

let invalidatedProjectOfBundle: BuildInvalidedProject<T> | undefined;

return kind === InvalidatedProjectKind.Build ?

{

kind,

project,

projectPath,

buildOrder,

getCompilerOptions: () => config.options,

getCurrentDirectory: () => state.currentDirectory,

getBuilderProgram: () => withProgramOrUndefined(identity),

getProgram: () =>

withProgramOrUndefined(

program => program.getProgramOrUndefined()

),

getSourceFile: fileName =>

withProgramOrUndefined(

program => program.getSourceFile(fileName)

),

getSourceFiles: () =>

withProgramOrEmptyArray(

program => program.getSourceFiles()

),

getOptionsDiagnostics: cancellationToken =>

withProgramOrEmptyArray(

program => program.getOptionsDiagnostics(cancellationToken)

),

getGlobalDiagnostics: cancellationToken =>

withProgramOrEmptyArray(

program => program.getGlobalDiagnostics(cancellationToken)

),

getConfigFileParsingDiagnostics: () =>

withProgramOrEmptyArray(

program => program.getConfigFileParsingDiagnostics()

),

getSyntacticDiagnostics: (sourceFile, cancellationToken) =>

withProgramOrEmptyArray(

program => program.getSyntacticDiagnostics(sourceFile, cancellationToken)

),

getAllDependencies: sourceFile =>

withProgramOrEmptyArray(

program => program.getAllDependencies(sourceFile)

),

getSemanticDiagnostics: (sourceFile, cancellationToken) =>

withProgramOrEmptyArray(

program => program.getSemanticDiagnostics(sourceFile, cancellationToken)

),

getSemanticDiagnosticsOfNextAffectedFile: (cancellationToken, ignoreSourceFile) =>

withProgramOrUndefined(

program =>

((program as any as SemanticDiagnosticsBuilderProgram).getSemanticDiagnosticsOfNextAffectedFile) &&

(program as any as SemanticDiagnosticsBuilderProgram).getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile)

),

emit: (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) => {

if (targetSourceFile || emitOnlyDtsFiles) {

return withProgramOrUndefined(

program => program.emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers)

);

}

executeSteps(BuildStep.SemanticDiagnostics, cancellationToken);

if (step === BuildStep.EmitBuildInfo) {

return emitBuildInfo(writeFile, cancellationToken);

}

if (step !== BuildStep.Emit) return undefined;

return emit(writeFile, cancellationToken, customTransformers);

},

done

} :

{

kind,

project,

projectPath,

buildOrder,

getCompilerOptions: () => config.options,

getCurrentDirectory: () => state.currentDirectory,

emit: (writeFile: WriteFileCallback | undefined, customTransformers: CustomTransformers | undefined) => {

if (step !== BuildStep.EmitBundle) return invalidatedProjectOfBundle;

return emitBundle(writeFile, customTransformers);

},

done,

};

function done(cancellationToken?: CancellationToken, writeFile?: WriteFileCallback, customTransformers?: CustomTransformers) {

executeSteps(BuildStep.Done, cancellationToken, writeFile, customTransformers);

return doneInvalidatedProject(state, projectPath);

}

function withProgramOrUndefined<U>(action: (program: T) => U | undefined): U | undefined {

executeSteps(BuildStep.CreateProgram);

return program && action(program);

}

function withProgramOrEmptyArray<U>(action: (program: T) => readonly U[]): readonly U[] {

return withProgramOrUndefined(action) || emptyArray;

}

function createProgram() {

Debug.assert(program === undefined);

if (state.options.dry) {

reportStatus(state, Diagnostics.A_non_dry_build_would_build_project_0, project);

buildResult = BuildResultFlags.Success;

step = BuildStep.QueueReferencingProjects;

return;

}

if (state.options.verbose) reportStatus(state, Diagnostics.Building_project_0, project);

if (config.fileNames.length === 0) {

reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));

// Nothing to build - must be a solution file, basically

buildResult = BuildResultFlags.None;

step = BuildStep.QueueReferencingProjects;

return;

}

const { host, compilerHost } = state;

state.projectCompilerOptions = config.options;

// Update module resolution cache if needed

updateModuleResolutionCache(state, project, config);

// Create program

program = host.createProgram(

config.fileNames,

config.options,

compilerHost,

getOldProgram(state, projectPath, config),

getConfigFileParsingDiagnostics(config),

config.projectReferences

);

if (state.watch) {

state.builderPrograms.set(projectPath, program);

}

step++;

}

function handleDiagnostics(diagnostics: readonly Diagnostic[], errorFlags: BuildResultFlags, errorType: string) {

if (diagnostics.length) {

({ buildResult, step } = buildErrors(

state,

projectPath,

program,

config,

diagnostics,

errorFlags,

errorType

));

}

else {

step++;

}

}

function getSyntaxDiagnostics(cancellationToken?: CancellationToken) {

Debug.assertIsDefined(program);

handleDiagnostics(

[

...program.getConfigFileParsingDiagnostics(),

...program.getOptionsDiagnostics(cancellationToken),

...program.getGlobalDiagnostics(cancellationToken),

...program.getSyntacticDiagnostics(/*sourceFile*/ undefined, cancellationToken)

],

BuildResultFlags.SyntaxErrors,

"Syntactic"

);

}

function getSemanticDiagnostics(cancellationToken?: CancellationToken) {

handleDiagnostics(

Debug.checkDefined(program).getSemanticDiagnostics(/*sourceFile*/ undefined, cancellationToken),

BuildResultFlags.TypeErrors,

"Semantic"

);

}

function emit(writeFileCallback?: WriteFileCallback, cancellationToken?: CancellationToken, customTransformers?: CustomTransformers): EmitResult {

Debug.assertIsDefined(program);

Debug.assert(step === BuildStep.Emit);

// Before emitting lets backup state, so we can revert it back if there are declaration errors to handle emit and declaration errors correctly

program.backupState();

let declDiagnostics: Diagnostic[] | undefined;

const reportDeclarationDiagnostics = (d: Diagnostic) => (declDiagnostics || (declDiagnostics = [])).push(d);

const outputFiles: OutputFile[] = [];

const { emitResult } = emitFilesAndReportErrors(

program,

reportDeclarationDiagnostics,

/*writeFileName*/ undefined,

/*reportSummary*/ undefined,

(name, text, writeByteOrderMark) => outputFiles.push({ name, text, writeByteOrderMark }),

cancellationToken,

/*emitOnlyDts*/ false,

customTransformers

);

// Don't emit .d.ts if there are decl file errors

if (declDiagnostics) {

program.restoreState();

({ buildResult, step } = buildErrors(

state,

projectPath,

program,

config,

declDiagnostics,

BuildResultFlags.DeclarationEmitErrors,

"Declaration file"

));

return {

emitSkipped: true,

diagnostics: emitResult.diagnostics

};

}

// Actual Emit

const { host, compilerHost } = state;

let resultFlags = BuildResultFlags.DeclarationOutputUnchanged;

let newestDeclarationFileContentChangedTime = minimumDate;

let anyDtsChanged = false;

const emitterDiagnostics = createDiagnosticCollection();

const emittedOutputs = new Map<Path, string>();

outputFiles.forEach(({ name, text, writeByteOrderMark }) => {

let priorChangeTime: Date | undefined;

if (!anyDtsChanged && isDeclarationFile(name)) {

// Check for unchanged .d.ts files

if (host.fileExists(name) && state.readFileWithCache(name) === text) {

priorChangeTime = host.getModifiedTime(name);

}

else {

resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged;

anyDtsChanged = true;

}

}

emittedOutputs.set(toPath(state, name), name);

writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);

if (priorChangeTime !== undefined) {

newestDeclarationFileContentChangedTime = newer(priorChangeTime, newestDeclarationFileContentChangedTime);

}

});

finishEmit(

emitterDiagnostics,

emittedOutputs,

newestDeclarationFileContentChangedTime,

/*newestDeclarationFileContentChangedTimeIsMaximumDate*/ anyDtsChanged,

outputFiles.length ? outputFiles[0].name : getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()),

resultFlags

);

return emitResult;

}

function emitBuildInfo(writeFileCallback?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult {

Debug.assertIsDefined(program);

Debug.assert(step === BuildStep.EmitBuildInfo);

const emitResult = program.emitBuildInfo(writeFileCallback, cancellationToken);

if (emitResult.diagnostics.length) {

reportErrors(state, emitResult.diagnostics);

state.diagnostics.set(projectPath, [...state.diagnostics.get(projectPath)!, ...emitResult.diagnostics]);

buildResult = BuildResultFlags.EmitErrors & buildResult!;

}

if (emitResult.emittedFiles && state.writeFileName) {

emitResult.emittedFiles.forEach(name => listEmittedFile(state, config, name));

}

afterProgramDone(state, program, config);

step = BuildStep.QueueReferencingProjects;

return emitResult;

}

function finishEmit(

emitterDiagnostics: DiagnosticCollection,

emittedOutputs: ESMap<Path, string>,

priorNewestUpdateTime: Date,

newestDeclarationFileContentChangedTimeIsMaximumDate: boolean,

oldestOutputFileName: string,

resultFlags: BuildResultFlags

) {

const emitDiagnostics = emitterDiagnostics.getDiagnostics();

if (emitDiagnostics.length) {

({ buildResult, step } = buildErrors(

state,

projectPath,

program,

config,

emitDiagnostics,

BuildResultFlags.EmitErrors,

"Emit"

));

return emitDiagnostics;

}