while (true) {

const fileName = combinePaths(searchPath, configName);

if (fileExists(fileName)) {

return fileName;

}

const parentPath = getDirectoryPath(searchPath);

if (parentPath === searchPath) {

break;

}

searchPath = parentPath;

}

return undefined;

const basePath = getDirectoryPath(containingFile);

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

return normalizePath(referencedFileName);

let commonPathComponents: string[];

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 getNormalizedPathFromPathComponents(commonPathComponents);

hash: string;

byteOrderMark: boolean;

mtime: Date;

const existingDirectories = createMap<boolean>();

function getCanonicalFileName(fileName: string): string {

// if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form.

// otherwise use toLowerCase as a canonical form.

return sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();

}

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

let text: string;

try {

performance.mark("beforeIORead");

text = sys.readFile(fileName, options.charset);

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 (sys.directoryExists(directoryPath)) {

existingDirectories.set(directoryPath, true);

return true;

}

return false;

}

function ensureDirectoriesExist(directoryPath: string) {

if (directoryPath.length > getRootLength(directoryPath) && !directoryExists(directoryPath)) {

const parentDirectory = getDirectoryPath(directoryPath);

ensureDirectoriesExist(parentDirectory);

sys.createDirectory(directoryPath);

}

}

let outputFingerprints: Map<OutputFingerprint>;

function writeFileIfUpdated(fileName: string, data: string, writeByteOrderMark: boolean): void {

if (!outputFingerprints) {

outputFingerprints = createMap<OutputFingerprint>();

}

const hash = sys.createHash(data);

const mtimeBefore = sys.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;

}

}

sys.writeFile(fileName, data, writeByteOrderMark);

const mtimeAfter = sys.getModifiedTime(fileName);

outputFingerprints.set(fileName, {

hash,

byteOrderMark: writeByteOrderMark,

mtime: mtimeAfter

});

}

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

try {

performance.mark("beforeIOWrite");

ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName)));

if (isWatchSet(options) && sys.createHash && sys.getModifiedTime) {

writeFileIfUpdated(fileName, data, writeByteOrderMark);

}

else {

sys.writeFile(fileName, data, writeByteOrderMark);

}

performance.mark("afterIOWrite");

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

}

catch (e) {

if (onError) {

onError(e.message);

}

}

}

function getDefaultLibLocation(): string {

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

}

const newLine = getNewLineCharacter(options);

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

return {

getSourceFile,

getDefaultLibLocation,

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

writeFile,

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

useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames,

getCanonicalFileName,

getNewLine: () => newLine,

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

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

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

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

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

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

realpath

};

let diagnostics = program.getOptionsDiagnostics(cancellationToken).concat(

program.getSyntacticDiagnostics(sourceFile, cancellationToken),

program.getGlobalDiagnostics(cancellationToken),

program.getSemanticDiagnostics(sourceFile, cancellationToken));

if (program.getCompilerOptions().declaration) {

diagnostics = diagnostics.concat(program.getDeclarationDiagnostics(sourceFile, cancellationToken));

}

return sortAndDeduplicateDiagnostics(diagnostics);

getCurrentDirectory(): string;

getCanonicalFileName(fileName: string): string;

getNewLine(): string;

let output = "";

for (const diagnostic of diagnostics) {

if (diagnostic.file) {

const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);

const fileName = diagnostic.file.fileName;

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

output += `${relativeFileName}(${line + 1},${character + 1}): `;

}

const category = DiagnosticCategory[diagnostic.category].toLowerCase();

output += `${category} TS${diagnostic.code}: ${flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine())}${host.getNewLine()}`;

}

return output;

switch (category) {

case DiagnosticCategory.Warning: return yellowForegroundEscapeSequence;

case DiagnosticCategory.Error: return redForegroundEscapeSequence;

case DiagnosticCategory.Message: return blueForegroundEscapeSequence;

}

while (s.length < length) {

s = " " + s;

}

return s;

let output = "";

for (const diagnostic of diagnostics) {

if (diagnostic.file) {

const { start, length, file } = diagnostic;

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 relativeFileName = host ? convertToRelativePath(file.fileName, host.getCurrentDirectory(), fileName => host.getCanonicalFileName(fileName)) : file.fileName;

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

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

if (hasMoreThanFiveLines) {

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

}

output += sys.newLine;

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

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

output += formatAndReset(padLeft(ellipsis, gutterWidth), gutterStyleSequence) + gutterSeparator + sys.newLine;

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.

output += formatAndReset(padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator;

output += lineContent + sys.newLine;

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

output += formatAndReset(padLeft("", gutterWidth), gutterStyleSequence) + gutterSeparator;

output += redForegroundEscapeSequence;

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;

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

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

}

else if (i === lastLine) {

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

}

else {

// Squiggle the entire line.

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

}

output += resetEscapeSequence;

output += sys.newLine;

}

output += sys.newLine;

output += `${ relativeFileName }(${ firstLine + 1 },${ firstLineChar + 1 }): `;

}

const categoryColor = getCategoryFormat(diagnostic.category);

const category = DiagnosticCategory[diagnostic.category].toLowerCase();

output += `${ formatAndReset(category, categoryColor) } TS${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }`;

output += sys.newLine;

}

return output;

if (typeof messageText === "string") {

return messageText;

}

else {

let diagnosticChain = messageText;

let result = "";

let indent = 0;

while (diagnosticChain) {

if (indent) {

result += newLine;

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

result += " ";

}

}

result += diagnosticChain.messageText;

indent++;

diagnosticChain = diagnosticChain.next;

}

return result;

}

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

}

resolutions.push(result);

}

return resolutions;

let program: Program;

let files: SourceFile[] = [];

let commonSourceDirectory: string;

let diagnosticsProducingTypeChecker: TypeChecker;

let noDiagnosticsTypeChecker: TypeChecker;

let classifiableNames: UnderscoreEscapedMap<true>;

let modifiedFilePaths: Path[] | undefined;

const cachedSemanticDiagnosticsForFile: DiagnosticCache = {};

const cachedDeclarationDiagnosticsForFile: DiagnosticCache = {};

let resolvedTypeReferenceDirectives = createMap<ResolvedTypeReferenceDirective>();

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

host = host || createCompilerHost(options);

let skipDefaultLib = options.noLib;

const programDiagnostics = createDiagnosticCollection();

const currentDirectory = host.getCurrentDirectory();

const supportedExtensions = getSupportedExtensions(options);

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

const hasEmitBlockingDiagnostics = createMap<boolean>();

let _compilerOptionsObjectLiteralSyntax: ObjectLiteralExpression;

let moduleResolutionCache: ModuleResolutionCache;

let resolveModuleNamesWorker: (moduleNames: string[], containingFile: string) => ResolvedModuleFull[];

if (host.resolveModuleNames) {

resolveModuleNamesWorker = (moduleNames, containingFile) => host.resolveModuleNames(checkAllDefined(moduleNames), containingFile).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));

const loader = (moduleName: string, containingFile: string) => resolveModuleName(moduleName, containingFile, options, host, moduleResolutionCache).resolvedModule;

resolveModuleNamesWorker = (moduleNames, containingFile) => loadWithLocalCache(checkAllDefined(moduleNames), containingFile, loader);

}

let resolveTypeReferenceDirectiveNamesWorker: (typeDirectiveNames: string[], containingFile: string) => ResolvedTypeReferenceDirective[];

if (host.resolveTypeReferenceDirectives) {

resolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile) => host.resolveTypeReferenceDirectives(checkAllDefined(typeDirectiveNames), containingFile);

}

else {

const loader = (typesRef: string, containingFile: string) => resolveTypeReferenceDirective(typesRef, containingFile, options, host).resolvedTypeReferenceDirective;

resolveTypeReferenceDirectiveNamesWorker = (typeReferenceDirectiveNames, containingFile) => loadWithLocalCache(checkAllDefined(typeReferenceDirectiveNames), containingFile, loader);

}

const filesByName = createMap<SourceFile | 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;

const structuralIsReused = tryReuseStructureFromOldProgram();

if (structuralIsReused !== StructureIsReused.Completely) {

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

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

const typeReferences: string[] = getAutomaticTypeDirectiveNames(options, host);

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, "__inferred type names__.ts");

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 (!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

if (!options.lib) {

processRootFile(host.getDefaultLibFileName(options), /*isDefaultLib*/ true);

}

else {

const libDirectory = host.getDefaultLibLocation ? host.getDefaultLibLocation() : getDirectoryPath(host.getDefaultLibFileName(options));

forEach(options.lib, libFileName => {

processRootFile(combinePaths(libDirectory, libFileName), /*isDefaultLib*/ true);

});

}

}

}

const missingFilePaths = arrayFrom(filesByName.keys(), p => <Path>p).filter(p => !filesByName.get(p));

// unconditionally set moduleResolutionCache to undefined to avoid unnecessary leaks

moduleResolutionCache = undefined;

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

oldProgram = undefined;

program = {

getRootFileNames: () => rootNames,

getSourceFile,

getSourceFileByPath,

getSourceFiles: () => files,

getMissingFilePaths: () => missingFilePaths,

getCompilerOptions: () => options,

getSyntacticDiagnostics,

getOptionsDiagnostics,

getGlobalDiagnostics,

getSemanticDiagnostics,

getDeclarationDiagnostics,

getTypeChecker,

getClassifiableNames,

getDiagnosticsProducingTypeChecker,

getCommonSourceDirectory,

emit,

getCurrentDirectory: () => currentDirectory,

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

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

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

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

getFileProcessingDiagnostics: () => fileProcessingDiagnostics,

getResolvedTypeReferenceDirectives: () => resolvedTypeReferenceDirectives,

isSourceFileFromExternalLibrary,

dropDiagnosticsProducingTypeChecker,

getSourceFileFromReference,

};

verifyCompilerOptions();

performance.mark("afterProgram");

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

return program;

function toPath(fileName: string): Path {

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

}

function getCommonSourceDirectory() {

if (commonSourceDirectory === undefined) {

const emittedFiles = filter(files, file => sourceFileMayBeEmitted(file, options, isSourceFileFromExternalLibrary));

if (options.rootDir && checkSourceFilesBelongToPath(emittedFiles, options.rootDir)) {

// If a rootDir is specified and is valid use it as the commonSourceDirectory

commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory);

}

else {

commonSourceDirectory = computeCommonSourceDirectory(emittedFiles);

}

if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) {

// Make sure directory path ends with directory separator so this string can directly

// used to replace with "" to get the relative path of the source file and the relative path doesn't

// start with / making it rooted path

commonSourceDirectory += directorySeparator;

}

}

return commonSourceDirectory;

}

function getClassifiableNames() {

if (!classifiableNames) {

// Initialize a checker so that all our files are bound.

getTypeChecker();

classifiableNames = createUnderscoreEscapedMap<true>();

for (const sourceFile of files) {

copyEntries(sourceFile.classifiableNames, classifiableNames);

}

}

return classifiableNames;

}

interface OldProgramState {

program: Program | undefined;

file: SourceFile;

/** The collection of paths modified *since* the old program. */

modifiedFilePaths: Path[];

}

function resolveModuleNamesReusingOldState(moduleNames: string[], containingFile: string, file: SourceFile, oldProgramState: OldProgramState) {

if (structuralIsReused === StructureIsReused.Not && !file.ambientModuleNames.length) {

// If the old program state does not permit reusing resolutions and `file` does not contain locally defined ambient modules,

// the best we can do is fallback to the default logic.

return resolveModuleNamesWorker(moduleNames, containingFile);

}

const oldSourceFile = oldProgramState.program && oldProgramState.program.getSourceFile(containingFile);

if (oldSourceFile !== file && file.resolvedModules) {

// `file` was created for the new program.

//

// We only set `file.resolvedModules` via work from the current function,

// so it is defined iff we already called the current function on `file`.

// That call happened no later than the creation of the `file` object,

// which per above occured during the current program creation.

// Since we assume the filesystem does not change during program creation,

// it is safe to reuse resolutions from the earlier call.

const result: ResolvedModuleFull[] = [];

for (const moduleName of moduleNames) {

const resolvedModule = file.resolvedModules.get(moduleName);

result.push(resolvedModule);

}

return result;

}

// At this point, we know at least one of the following hold:

// - file has local declarations for ambient modules

// - old program state is available

// With this information, we can infer some module resolutions without performing resolution.

/** An ordered list of module names for which we cannot recover the resolution. */

let unknownModuleNames: string[];

/**

let result: ResolvedModuleFull[];

/** A transient placeholder used to mark predicted resolution in the result list. */

const predictedToResolveToAmbientModuleMarker: ResolvedModuleFull = <any>{};

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

const moduleName = moduleNames[i];

// If we want to reuse resolutions more aggressively, we can refine this to check for whether the

// text of the corresponding modulenames has changed.

if (file === oldSourceFile) {

const oldResolvedModule = oldSourceFile && oldSourceFile.resolvedModules.get(moduleName);

if (oldResolvedModule) {

if (isTraceEnabled(options, host)) {

trace(host, Diagnostics.Reusing_resolution_of_module_0_to_file_1_from_old_program, moduleName, containingFile);

}

(result || (result = new Array(moduleNames.length)))[i] = oldResolvedModule;

continue;

}

}

// We know moduleName resolves to an ambient module provided that moduleName:

// - is in the list of ambient modules locally declared in the current source file.

// - resolved to an ambient module in the old program whose declaration is in an unmodified file

// (so the same module declaration will land in the new program)

let resolvesToAmbientModuleInNonModifiedFile = false;

if (contains(file.ambientModuleNames, moduleName)) {

resolvesToAmbientModuleInNonModifiedFile = true;

if (isTraceEnabled(options, host)) {

trace(host, Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName, containingFile);

}

}

else {

resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, oldProgramState);

}

if (resolvesToAmbientModuleInNonModifiedFile) {

(result || (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker;

}

else {

// Resolution failed in the old program, or resolved to an ambient module for which we can't reuse the result.

(unknownModuleNames || (unknownModuleNames = [])).push(moduleName);

}

}

const resolutions = unknownModuleNames && unknownModuleNames.length

? resolveModuleNamesWorker(unknownModuleNames, containingFile)

: emptyArray;

// Combine results of resolutions and predicted results

if (!result) {

// There were no unresolved/ambient resolutions.

Debug.assert(resolutions.length === moduleNames.length);

return <ResolvedModuleFull[]>resolutions;

}

let j = 0;

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

if (result[i]) {

// `result[i]` is either a `ResolvedModuleFull` or a marker.

// If it is the former, we can leave it as is.

if (result[i] === predictedToResolveToAmbientModuleMarker) {

result[i] = undefined;

}

}

else {

result[i] = resolutions[j];

j++;

}

}

Debug.assert(j === resolutions.length);

return result;

// If we change our policy of rechecking failed lookups on each program create,

// we should adjust the value returned here.

function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName: string, oldProgramState: OldProgramState): boolean {

const resolutionToFile = getResolvedModule(oldProgramState.file, moduleName);

if (resolutionToFile) {

// module used to be resolved to file - ignore it

return false;

}

const ambientModule = oldProgramState.program && oldProgramState.program.getTypeChecker().tryFindAmbientModuleWithoutAugmentations(moduleName);

if (!(ambientModule && ambientModule.declarations)) {

return false;

}

// at least one of declarations should come from non-modified source file

const firstUnmodifiedFile = forEach(ambientModule.declarations, d => {

const f = getSourceFileOfNode(d);

return !contains(oldProgramState.modifiedFilePaths, f.path) && f;

});

if (!firstUnmodifiedFile) {

return false;

}

if (isTraceEnabled(options, host)) {

trace(host, Diagnostics.Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified, moduleName, firstUnmodifiedFile.fileName);

}

return true;

}

}

function tryReuseStructureFromOldProgram(): StructureIsReused {

if (!oldProgram) {

return StructureIsReused.Not;

}

// check properties that can affect structure of the program or module resolution strategy

// if any of these properties has changed - structure cannot be reused

const oldOptions = oldProgram.getCompilerOptions();

if (changesAffectModuleResolution(oldOptions, options)) {

return oldProgram.structureIsReused = StructureIsReused.Not;

}

Debug.assert(!(oldProgram.structureIsReused & (StructureIsReused.Completely | StructureIsReused.SafeModules)));

// there is an old program, check if we can reuse its structure

const oldRootNames = oldProgram.getRootFileNames();

if (!arrayIsEqualTo(oldRootNames, rootNames)) {

return oldProgram.structureIsReused = StructureIsReused.Not;

}

if (!arrayIsEqualTo(options.types, oldOptions.types)) {

return oldProgram.structureIsReused = StructureIsReused.Not;

}

// check if program source files has changed in the way that can affect structure of the program

const newSourceFiles: SourceFile[] = [];

const filePaths: Path[] = [];

const modifiedSourceFiles: { oldFile: SourceFile, newFile: SourceFile }[] = [];

oldProgram.structureIsReused = StructureIsReused.Completely;

for (const oldSourceFile of oldProgram.getSourceFiles()) {

const newSourceFile = host.getSourceFileByPath

? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.path, options.target)

: host.getSourceFile(oldSourceFile.fileName, options.target);

if (!newSourceFile) {

return oldProgram.structureIsReused = StructureIsReused.Not;

}

newSourceFile.path = oldSourceFile.path;

filePaths.push(newSourceFile.path);

if (oldSourceFile !== newSourceFile) {

// The `newSourceFile` object was created for the new program.

if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {