var tslintRules = [

"booleanTriviaRule",

"debugAssertRule",

"nextLineRule",

"noBomRule",

"noDoubleSpaceRule",

"noIncrementDecrementRule",

"noInOperatorRule",

"noTypeAssertionWhitespaceRule",

"objectLiteralSurroundingSpaceRule",

"typeOperatorSpacingRule",

return path.join(tslintRuleDir, p + ".ts");

return path.join(builtLocalDirectory, "tslint/rules", p + ".js");

function getEmitResolver(sourceFile: SourceFile, cancellationToken: CancellationToken) {

getDiagnostics(sourceFile, cancellationToken);

return useCaseSensitiveFileNames

? ((fileName) => fileName)

: ((fileName) => fileName.toLowerCase());

export interface FileAndDirectoryExistence {

fileExists: boolean;

directoryExists: boolean;

}

export interface CachedDirectoryStructureHost extends DirectoryStructureHost {

/** Returns the queried result for the file exists and directory exists if at all it was done */

addOrDeleteFileOrDirectory(fileOrDirectory: string, fileOrDirectoryPath: Path): FileAndDirectoryExistence | undefined;

addOrDeleteFile(fileName: string, filePath: Path, eventKind: FileWatcherEventKind): void;

clearCache(): void;

}

interface MutableFileSystemEntries {

readonly files: string[];

readonly directories: string[];

}

export function createCachedDirectoryStructureHost(host: DirectoryStructureHost): CachedDirectoryStructureHost {

const cachedReadDirectoryResult = createMap<MutableFileSystemEntries>();

const getCurrentDirectory = memoize(() => host.getCurrentDirectory());

const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);

return {

useCaseSensitiveFileNames: host.useCaseSensitiveFileNames,

newLine: host.newLine,

readFile: (path, encoding) => host.readFile(path, encoding),

write: s => host.write(s),

writeFile,

fileExists,

directoryExists,

createDirectory,

getCurrentDirectory,

getDirectories,

readDirectory,

addOrDeleteFileOrDirectory,

addOrDeleteFile,

clearCache,

exit: code => host.exit(code)

};

function toPath(fileName: string) {

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

}

function getCachedFileSystemEntries(rootDirPath: Path): MutableFileSystemEntries | undefined {

return cachedReadDirectoryResult.get(rootDirPath);

}

function getCachedFileSystemEntriesForBaseDir(path: Path): MutableFileSystemEntries | undefined {

return getCachedFileSystemEntries(getDirectoryPath(path));

}

function getBaseNameOfFileName(fileName: string) {

return getBaseFileName(normalizePath(fileName));

}

function createCachedFileSystemEntries(rootDir: string, rootDirPath: Path) {

const resultFromHost: MutableFileSystemEntries = {

files: map(host.readDirectory(rootDir, /*extensions*/ undefined, /*exclude*/ undefined, /*include*/["*.*"]), getBaseNameOfFileName) || [],

directories: host.getDirectories(rootDir) || []

};

cachedReadDirectoryResult.set(rootDirPath, resultFromHost);

return resultFromHost;

}

/**

function tryReadDirectory(rootDir: string, rootDirPath: Path): MutableFileSystemEntries | undefined {

const cachedResult = getCachedFileSystemEntries(rootDirPath);

if (cachedResult) {

return cachedResult;

}

try {

return createCachedFileSystemEntries(rootDir, rootDirPath);

}

catch (_e) {

// If there is exception to read directories, dont cache the result and direct the calls to host

Debug.assert(!cachedReadDirectoryResult.has(rootDirPath));

return undefined;

}

}

function fileNameEqual(name1: string, name2: string) {

return getCanonicalFileName(name1) === getCanonicalFileName(name2);

}

function hasEntry(entries: ReadonlyArray<string>, name: string) {

return some(entries, file => fileNameEqual(file, name));

}

function updateFileSystemEntry(entries: string[], baseName: string, isValid: boolean) {

if (hasEntry(entries, baseName)) {

if (!isValid) {

return filterMutate(entries, entry => !fileNameEqual(entry, baseName));

}

}

else if (isValid) {

return entries.push(baseName);

}

}

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

const path = toPath(fileName);

const result = getCachedFileSystemEntriesForBaseDir(path);

if (result) {

updateFilesOfFileSystemEntry(result, getBaseNameOfFileName(fileName), /*fileExists*/ true);

}

return host.writeFile(fileName, data, writeByteOrderMark);

}

function fileExists(fileName: string): boolean {

const path = toPath(fileName);

const result = getCachedFileSystemEntriesForBaseDir(path);

return result && hasEntry(result.files, getBaseNameOfFileName(fileName)) ||

host.fileExists(fileName);

}

function directoryExists(dirPath: string): boolean {

const path = toPath(dirPath);

return cachedReadDirectoryResult.has(path) || host.directoryExists(dirPath);

}

function createDirectory(dirPath: string) {

const path = toPath(dirPath);

const result = getCachedFileSystemEntriesForBaseDir(path);

const baseFileName = getBaseNameOfFileName(dirPath);

if (result) {

updateFileSystemEntry(result.directories, baseFileName, /*isValid*/ true);

}

host.createDirectory(dirPath);

}

function getDirectories(rootDir: string): string[] {

const rootDirPath = toPath(rootDir);

const result = tryReadDirectory(rootDir, rootDirPath);

if (result) {

return result.directories.slice();

}

return host.getDirectories(rootDir);

}

function readDirectory(rootDir: string, extensions?: ReadonlyArray<string>, excludes?: ReadonlyArray<string>, includes?: ReadonlyArray<string>, depth?: number): string[] {

const rootDirPath = toPath(rootDir);

const result = tryReadDirectory(rootDir, rootDirPath);

if (result) {

return matchFiles(rootDir, extensions, excludes, includes, host.useCaseSensitiveFileNames, getCurrentDirectory(), depth, getFileSystemEntries);

}

return host.readDirectory(rootDir, extensions, excludes, includes, depth);

function getFileSystemEntries(dir: string) {

const path = toPath(dir);

if (path === rootDirPath) {

return result;

}

return tryReadDirectory(dir, path) || emptyFileSystemEntries;

}

}

function addOrDeleteFileOrDirectory(fileOrDirectory: string, fileOrDirectoryPath: Path) {

const existingResult = getCachedFileSystemEntries(fileOrDirectoryPath);

if (existingResult) {

// Just clear the cache for now

// For now just clear the cache, since this could mean that multiple level entries might need to be re-evaluated

clearCache();

}

else {

// This was earlier a file (hence not in cached directory contents)

// or we never cached the directory containing it

const parentResult = getCachedFileSystemEntriesForBaseDir(fileOrDirectoryPath);

if (parentResult) {

const baseName = getBaseNameOfFileName(fileOrDirectory);

if (parentResult) {

const fsQueryResult: FileAndDirectoryExistence = {

fileExists: host.fileExists(fileOrDirectoryPath),

directoryExists: host.directoryExists(fileOrDirectoryPath)

};

if (fsQueryResult.directoryExists || hasEntry(parentResult.directories, baseName)) {

// Folder added or removed, clear the cache instead of updating the folder and its structure

clearCache();

}

else {

// No need to update the directory structure, just files

updateFilesOfFileSystemEntry(parentResult, baseName, fsQueryResult.fileExists);

}

return fsQueryResult;

}

}

}

}

function addOrDeleteFile(fileName: string, filePath: Path, eventKind: FileWatcherEventKind) {

if (eventKind === FileWatcherEventKind.Changed) {

return;

}

const parentResult = getCachedFileSystemEntriesForBaseDir(filePath);

if (parentResult) {

updateFilesOfFileSystemEntry(parentResult, getBaseNameOfFileName(fileName), eventKind === FileWatcherEventKind.Created);

}

}

function updateFilesOfFileSystemEntry(parentResult: MutableFileSystemEntries, baseName: string, fileExists: boolean) {

updateFileSystemEntry(parentResult.files, baseName, fileExists);

}

function clearCache() {

cachedReadDirectoryResult.clear();

}

}

if (!emitSkipped) {

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

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

};

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