/// <reference path="sys.ts" />

/// <reference path="emitter.ts" />

/// <reference path="core.ts" />

namespace ts {

/** The version of the TypeScript compiler release */

export const version = "2.0.5";

const emptyArray: any[] = [];

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

while (true) {

const fileName = combinePaths(searchPath, configName);

if (fileExists(fileName)) {

return fileName;

}

const parentPath = getDirectoryPath(searchPath);

if (parentPath === searchPath) {

break;

}

searchPath = parentPath;

}

return 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: (fileName: string) => string): string {

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;

}

for (let i = 0, n = Math.min(commonPathComponents.length, sourcePathComponents.length); 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);

}

const typeReferenceExtensions = [".d.ts"];

// @internal

export function getEffectiveTypeRoots(options: CompilerOptions, host: { directoryExists?(directoryName: string): boolean; getCurrentDirectory?(): string; }): string[] | undefined {

if (options.typeRoots) {

return options.typeRoots;

}

let currentDirectory: string;

if (options.configFilePath) {

currentDirectory = getDirectoryPath(options.configFilePath);

}

else if (host.getCurrentDirectory) {

currentDirectory = host.getCurrentDirectory();

}

return currentDirectory && getDefaultTypeRoots(currentDirectory, host);

}

/**

* Returns the path to every node_modules/@types directory from some ancestor directory.

* Returns undefined if there are none.

*/

function getDefaultTypeRoots(currentDirectory: string, host: { directoryExists?(directoryName: string): boolean; getCurrentDirectory?(): string; }): string[] | undefined {

if (!host.directoryExists) {

return [combinePaths(currentDirectory, nodeModulesAtTypes)];

}

let typeRoots: string[];

while (true) {

const atTypes = combinePaths(currentDirectory, nodeModulesAtTypes);

if (host.directoryExists(atTypes)) {

(typeRoots || (typeRoots = [])).push(atTypes);

}

const parent = getDirectoryPath(currentDirectory);

if (parent === currentDirectory) {

break;

}

currentDirectory = parent;

}

return typeRoots;

}

const nodeModulesAtTypes = combinePaths("node_modules", "@types");

/**

* @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.

* This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups

* is assumed to be the same as root directory of the project.

*/

export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost): ResolvedTypeReferenceDirectiveWithFailedLookupLocations {

const traceEnabled = isTraceEnabled(options, host);

const moduleResolutionState: ModuleResolutionState = {

compilerOptions: options,

host: host,

skipTsx: true,

traceEnabled

};

const typeRoots = getEffectiveTypeRoots(options, host);

if (traceEnabled) {

if (containingFile === undefined) {

if (typeRoots === undefined) {

trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);

}

else {

trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);

}

}

else {

if (typeRoots === undefined) {

trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);

}

else {

trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);

}

}

}

const failedLookupLocations: string[] = [];

// Check primary library paths

if (typeRoots && typeRoots.length) {

if (traceEnabled) {

trace(host, Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));

}

const primarySearchPaths = typeRoots;

for (const typeRoot of primarySearchPaths) {

const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);

const candidateDirectory = getDirectoryPath(candidate);

const resolvedFile = loadNodeModuleFromDirectory(typeReferenceExtensions, candidate, failedLookupLocations,

!directoryProbablyExists(candidateDirectory, host), moduleResolutionState);

if (resolvedFile) {

if (traceEnabled) {

trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFile, true);

}

return {

resolvedTypeReferenceDirective: { primary: true, resolvedFileName: resolvedFile },

failedLookupLocations

};

}

}

}

else {

if (traceEnabled) {

trace(host, Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);

}

}

let resolvedFile: string;

let initialLocationForSecondaryLookup: string;

if (containingFile) {

initialLocationForSecondaryLookup = getDirectoryPath(containingFile);

}

if (initialLocationForSecondaryLookup !== undefined) {

// check secondary locations

if (traceEnabled) {

trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);

}

resolvedFile = loadModuleFromNodeModules(typeReferenceDirectiveName, initialLocationForSecondaryLookup, failedLookupLocations, moduleResolutionState, /*checkOneLevel*/ false);

if (traceEnabled) {

if (resolvedFile) {

trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFile, false);

}

else {

trace(host, Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);

}

}

}

else {

if (traceEnabled) {

trace(host, Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);

}

}

return {

resolvedTypeReferenceDirective: resolvedFile

? { primary: false, resolvedFileName: resolvedFile }

: undefined,

failedLookupLocations

};

}

interface OutputFingerprint {

hash: string;

byteOrderMark: boolean;

mtime: Date;

}

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

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

}

// returned by CScript sys environment

const unsupportedFileEncodingErrorCode = -2147024809;

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.number === unsupportedFileEncodingErrorCode

? createCompilerDiagnostic(Diagnostics.Unsupported_file_encoding).messageText

: e.message);

}

text = "";

}

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

}

function directoryExists(directoryPath: string): boolean {

if (directoryPath in existingDirectories) {

return true;

}

if (sys.directoryExists(directoryPath)) {

existingDirectories[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 && fileName in outputFingerprints) {

const fingerprint = outputFingerprints[fileName];

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

if (fingerprint.byteOrderMark === writeByteOrderMark &&

fingerprint.hash === hash &&

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

return;

}

}

sys.writeFile(fileName, data, writeByteOrderMark);

const mtimeAfter = sys.getModifiedTime(fileName);

outputFingerprints[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),

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

realpath

};

}

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

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

}

export interface FormatDiagnosticsHost {

getCurrentDirectory(): string;

getCanonicalFileName(fileName: string): string;

getNewLine(): string;

}

export function formatDiagnostics(diagnostics: Diagnostic[], host: FormatDiagnosticsHost): 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;

}

export function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string {

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;

}

}

function loadWithLocalCache<T>(names: string[], containingFile: string, loader: (name: string, containingFile: string) => T): T[] {

if (names.length === 0) {

return [];

}

const resolutions: T[] = [];

const cache = createMap<T>();

for (const name of names) {

const result = name in cache

? cache[name]

: cache[name] = loader(name, containingFile);

resolutions.push(result);

}

return resolutions;

}

/**

* Given a set of options, returns the set of type directive names

* that should be included for this program automatically.

* This list could either come from the config file,

* or from enumerating the types root + initial secondary types lookup location.

* More type directives might appear in the program later as a result of loading actual source files;

* this list is only the set of defaults that are implicitly included.

*/

export function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[] {

// Use explicit type list from tsconfig.json

if (options.types) {

return options.types;

}

// Walk the primary type lookup locations

const result: string[] = [];

if (host.directoryExists && host.getDirectories) {

const typeRoots = getEffectiveTypeRoots(options, host);

if (typeRoots) {

for (const root of typeRoots) {

if (host.directoryExists(root)) {

for (const typeDirectivePath of host.getDirectories(root)) {

const normalized = normalizePath(typeDirectivePath);

const packageJsonPath = pathToPackageJson(combinePaths(root, normalized));

// tslint:disable-next-line:no-null-keyword

const isNotNeededPackage = host.fileExists(packageJsonPath) && readJson(packageJsonPath, host).typings === null;

if (!isNotNeededPackage) {

// Return just the type directive names

result.push(getBaseFileName(normalized));

}

}

}

}

}

}

return result;

}

export function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program): Program {

let program: Program;

let files: SourceFile[] = [];

let commonSourceDirectory: string;

let diagnosticsProducingTypeChecker: TypeChecker;

let noDiagnosticsTypeChecker: TypeChecker;

let classifiableNames: Map<string>;

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 maxNodeModulesJsDepth = 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 = createFileMap<boolean>(getCanonicalFileName);

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

if (host.resolveModuleNames) {

resolveModuleNamesWorker = (moduleNames, containingFile) => host.resolveModuleNames(moduleNames, containingFile);

}

else {

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

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

}

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

if (host.resolveTypeReferenceDirectives) {

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

}

else {

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

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

}

const filesByName = createFileMap<SourceFile>();

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

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

const filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? createFileMap<SourceFile>(fileName => fileName.toLowerCase()) : undefined;

if (!tryReuseStructureFromOldProgram()) {

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

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

const containingFilename = combinePaths(host.getCurrentDirectory(), "__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);

});

}

}

}

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

oldProgram = undefined;

program = {

getRootFileNames: () => rootNames,

getSourceFile,

getSourceFileByPath,

getSourceFiles: () => files,

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,

dropDiagnosticsProducingTypeChecker

};

verifyCompilerOptions();

performance.mark("afterProgram");

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

return program;

function getCommonSourceDirectory() {

if (typeof commonSourceDirectory === "undefined") {

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

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

commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory);

}

else {

commonSourceDirectory = computeCommonSourceDirectory(files);

}

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 = createMap<string>();

for (const sourceFile of files) {

copyProperties(sourceFile.classifiableNames, classifiableNames);

}

}

return classifiableNames;

}

function tryReuseStructureFromOldProgram(): boolean {

if (!oldProgram) {

return false;

}

// 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 ((oldOptions.module !== options.module) ||

(oldOptions.moduleResolution !== options.moduleResolution) ||

(oldOptions.noResolve !== options.noResolve) ||

(oldOptions.target !== options.target) ||

(oldOptions.noLib !== options.noLib) ||

(oldOptions.jsx !== options.jsx) ||

(oldOptions.allowJs !== options.allowJs) ||

(oldOptions.rootDir !== options.rootDir) ||

(oldOptions.configFilePath !== options.configFilePath) ||

(oldOptions.baseUrl !== options.baseUrl) ||

(oldOptions.maxNodeModuleJsDepth !== options.maxNodeModuleJsDepth) ||

!arrayIsEqualTo(oldOptions.typeRoots, oldOptions.typeRoots) ||

!arrayIsEqualTo(oldOptions.rootDirs, options.rootDirs) ||

!equalOwnProperties(oldOptions.paths, options.paths)) {

return false;

}

Debug.assert(!oldProgram.structureIsReused);

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

const oldRootNames = oldProgram.getRootFileNames();

if (!arrayIsEqualTo(oldRootNames, rootNames)) {

return false;

}

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

return false;

}

// 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: SourceFile[] = [];

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

let newSourceFile = host.getSourceFileByPath

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

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

if (!newSourceFile) {

return false;

}

newSourceFile.path = oldSourceFile.path;

filePaths.push(newSourceFile.path);

if (oldSourceFile !== newSourceFile) {

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

// value of no-default-lib has changed

// this will affect if default library is injected into the list of files

return false;

}

// check tripleslash references

if (!arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) {

// tripleslash references has changed

return false;

}

// check imports and module augmentations

collectExternalModuleReferences(newSourceFile);

if (!arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) {

// imports has changed

return false;

}

if (!arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) {

// moduleAugmentations has changed

return false;

}

if (!arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) {

// 'types' references has changed

return false;

}

const newSourceFilePath = getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory);

if (resolveModuleNamesWorker) {

const moduleNames = map(concatenate(newSourceFile.imports, newSourceFile.moduleAugmentations), getTextOfLiteral);

const resolutions = resolveModuleNamesWorker(moduleNames, newSourceFilePath);

// ensure that module resolution results are still correct

const resolutionsChanged = hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, moduleResolutionIsEqualTo);

if (resolutionsChanged) {

return false;

}

}

if (resolveTypeReferenceDirectiveNamesWorker) {

const typesReferenceDirectives = map(newSourceFile.typeReferenceDirectives, x => x.fileName);

const resolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFilePath);

// ensure that types resolutions are still correct

const resolutionsChanged = hasChangesInResolutions(typesReferenceDirectives, resolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, typeDirectiveIsEqualTo);

if (resolutionsChanged) {

return false;

}

}

// pass the cache of module/types resolutions from the old source file

newSourceFile.resolvedModules = oldSourceFile.resolvedModules;

newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;

modifiedSourceFiles.push(newSourceFile);

}

else {

// file has no changes - use it as is

newSourceFile = oldSourceFile;

}

// if file has passed all checks it should be safe to reuse it

newSourceFiles.push(newSourceFile);

}

// update fileName -> file mapping

for (let i = 0, len = newSourceFiles.length; i < len; i++) {

filesByName.set(filePaths[i], newSourceFiles[i]);

}

files = newSourceFiles;

fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();

for (const modifiedFile of modifiedSourceFiles) {

fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile);

}

resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives();

oldProgram.structureIsReused = true;

return true;

}

function getEmitHost(writeFileCallback?: WriteFileCallback): EmitHost {

return {

getCanonicalFileName,

getCommonSourceDirectory: program.getCommonSourceDirectory,

getCompilerOptions: program.getCompilerOptions,

getCurrentDirectory: () => currentDirectory,

getNewLine: () => host.getNewLine(),

getSourceFile: program.getSourceFile,

getSourceFileByPath: program.getSourceFileByPath,

getSourceFiles: program.getSourceFiles,

isSourceFileFromExternalLibrary: (file: SourceFile) => !!sourceFilesFoundSearchingNodeModules[file.path],

writeFile: writeFileCallback || (

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

isEmitBlocked,

};

}

function getDiagnosticsProducingTypeChecker() {

return diagnosticsProducingTypeChecker || (diagnosticsProducingTypeChecker = createTypeChecker(program, /*produceDiagnostics:*/ true));

}

function dropDiagnosticsProducingTypeChecker() {

diagnosticsProducingTypeChecker = undefined;

}

function getTypeChecker() {

return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = createTypeChecker(program, /*produceDiagnostics:*/ false));

}

function emit(sourceFile?: SourceFile, writeFileCallback?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean): EmitResult {

return runWithCancellationToken(() => emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles));

}

function isEmitBlocked(emitFileName: string): boolean {

return hasEmitBlockingDiagnostics.contains(toPath(emitFileName, currentDirectory, getCanonicalFileName));

}

function emitWorker(program: Program, sourceFile: SourceFile, writeFileCallback: WriteFileCallback, cancellationToken: CancellationToken, emitOnlyDtsFiles?: boolean): EmitResult {

let declarationDiagnostics: Diagnostic[] = [];

if (options.noEmit) {

return { diagnostics: declarationDiagnostics, sourceMaps: undefined, emittedFiles: undefined, emitSkipped: true };

}

// If the noEmitOnError flag is set, then check if we have any errors so far. If so,

// immediately bail out. Note that we pass 'undefined' for 'sourceFile' so that we

// get any preEmit diagnostics, not just the ones

if (options.noEmitOnError) {

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

program.getSyntacticDiagnostics(sourceFile, cancellationToken),

program.getGlobalDiagnostics(cancellationToken),

program.getSemanticDiagnostics(sourceFile, cancellationToken));

if (diagnostics.length === 0 && program.getCompilerOptions().declaration) {

declarationDiagnostics = program.getDeclarationDiagnostics(/*sourceFile*/ undefined, cancellationToken);

}

if (diagnostics.length > 0 || declarationDiagnostics.length > 0) {

return {

diagnostics: concatenate(diagnostics, declarationDiagnostics),

sourceMaps: undefined,

emittedFiles: undefined,

emitSkipped: true

};

}

}

// Create the emit resolver outside of the "emitTime" tracking code below. That way

// any cost associated with it (like type checking) are appropriate associated with

// the type-checking counter.

//

// If the -out option is specified, we should not pass the source file to getEmitResolver.

// This is because in the -out scenario all files need to be emitted, and therefore all

// files need to be type checked. And the way to specify that all files need to be type

// checked is to not pass the file to getEmitResolver.

const emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile);

performance.mark("beforeEmit");

const emitResult = emitFiles(

emitResolver,

getEmitHost(writeFileCallback),

sourceFile,

emitOnlyDtsFiles);

performance.mark("afterEmit");

performance.measure("Emit", "beforeEmit", "afterEmit");

return emitResult;

}

function getSourceFile(fileName: string): SourceFile {

return getSourceFileByPath(toPath(fileName, currentDirectory, getCanonicalFileName));

}

function getSourceFileByPath(path: Path): SourceFile {

return filesByName.get(path);

}

function getDiagnosticsHelper(

sourceFile: SourceFile,

getDiagnostics: (sourceFile: SourceFile, cancellationToken: CancellationToken) => Diagnostic[],

cancellationToken: CancellationToken): Diagnostic[] {

if (sourceFile) {

return getDiagnostics(sourceFile, cancellationToken);

}

const allDiagnostics: Diagnostic[] = [];

forEach(program.getSourceFiles(), sourceFile => {

if (cancellationToken) {

cancellationToken.throwIfCancellationRequested();

}

addRange(allDiagnostics, getDiagnostics(sourceFile, cancellationToken));

});

return sortAndDeduplicateDiagnostics(allDiagnostics);

}

function getSyntacticDiagnostics(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return getDiagnosticsHelper(sourceFile, getSyntacticDiagnosticsForFile, cancellationToken);

}

function getSemanticDiagnostics(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return getDiagnosticsHelper(sourceFile, getSemanticDiagnosticsForFile, cancellationToken);

}

function getDeclarationDiagnostics(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

const options = program.getCompilerOptions();

// collect diagnostics from the program only once if either no source file was specified or out/outFile is set (bundled emit)

if (!sourceFile || options.out || options.outFile) {

return getDeclarationDiagnosticsWorker(sourceFile, cancellationToken);

}

else {

return getDiagnosticsHelper(sourceFile, getDeclarationDiagnosticsForFile, cancellationToken);

}

}

function getSyntacticDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return sourceFile.parseDiagnostics;

}

function runWithCancellationToken<T>(func: () => T): T {

try {

return func();

}

catch (e) {

if (e instanceof OperationCanceledException) {

// We were canceled while performing the operation. Because our type checker

// might be a bad state, we need to throw it away.

//

// Note: we are overly aggressive here. We do not actually *have* to throw away

// the "noDiagnosticsTypeChecker". However, for simplicity, i'd like to keep

// the lifetimes of these two TypeCheckers the same. Also, we generally only

// cancel when the user has made a change anyways. And, in that case, we (the

// program instance) will get thrown away anyways. So trying to keep one of

// these type checkers alive doesn't serve much purpose.

noDiagnosticsTypeChecker = undefined;

diagnosticsProducingTypeChecker = undefined;

}

throw e;

}

}

function getSemanticDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return runWithCancellationToken(() => {

const typeChecker = getDiagnosticsProducingTypeChecker();

Debug.assert(!!sourceFile.bindDiagnostics);

const bindDiagnostics = sourceFile.bindDiagnostics;

// For JavaScript files, we don't want to report the normal typescript semantic errors.

// Instead, we just report errors for using TypeScript-only constructs from within a

// JavaScript file.

const checkDiagnostics = isSourceFileJavaScript(sourceFile) ?

getJavaScriptSemanticDiagnosticsForFile(sourceFile, cancellationToken) :

typeChecker.getDiagnostics(sourceFile, cancellationToken);

const fileProcessingDiagnosticsInFile = fileProcessingDiagnostics.getDiagnostics(sourceFile.fileName);

const programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName);

return bindDiagnostics.concat(checkDiagnostics).concat(fileProcessingDiagnosticsInFile).concat(programDiagnosticsInFile);

});

}

function getJavaScriptSemanticDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return runWithCancellationToken(() => {

const diagnostics: Diagnostic[] = [];

walk(sourceFile);

return diagnostics;

function walk(node: Node): boolean {

if (!node) {

return false;

}

switch (node.kind) {

case SyntaxKind.ImportEqualsDeclaration:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.import_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.ExportAssignment:

if ((<ExportAssignment>node).isExportEquals) {

diagnostics.push(createDiagnosticForNode(node, Diagnostics.export_can_only_be_used_in_a_ts_file));

return true;

}

break;

case SyntaxKind.ClassDeclaration:

let classDeclaration = <ClassDeclaration>node;

if (checkModifiers(classDeclaration.modifiers) ||

checkTypeParameters(classDeclaration.typeParameters)) {

return true;

}

break;

case SyntaxKind.HeritageClause:

let heritageClause = <HeritageClause>node;

if (heritageClause.token === SyntaxKind.ImplementsKeyword) {

diagnostics.push(createDiagnosticForNode(node, Diagnostics.implements_clauses_can_only_be_used_in_a_ts_file));

return true;

}

break;

case SyntaxKind.InterfaceDeclaration:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.interface_declarations_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.ModuleDeclaration:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.module_declarations_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.TypeAliasDeclaration:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.type_aliases_can_only_be_used_in_a_ts_file));

return true;