/// <reference path="..\harness.ts" />

/// <reference path="..\..\compiler\watch.ts" />

/// <reference path="..\virtualFileSystemWithWatch.ts" />

namespace ts.tscWatch {

import WatchedSystem = ts.TestFSWithWatch.TestServerHost;

type FileOrFolder = ts.TestFSWithWatch.FileOrFolder;

import createWatchedSystem = ts.TestFSWithWatch.createWatchedSystem;

import checkFileNames = ts.TestFSWithWatch.checkFileNames;

import libFile = ts.TestFSWithWatch.libFile;

import checkWatchedFiles = ts.TestFSWithWatch.checkWatchedFiles;

import checkWatchedDirectories = ts.TestFSWithWatch.checkWatchedDirectories;

import checkOutputContains = ts.TestFSWithWatch.checkOutputContains;

import checkOutputDoesNotContain = ts.TestFSWithWatch.checkOutputDoesNotContain;

export function checkProgramActualFiles(program: Program, expectedFiles: string[]) {

checkFileNames(`Program actual files`, program.getSourceFiles().map(file => file.fileName), expectedFiles);

}

export function checkProgramRootFiles(program: Program, expectedFiles: string[]) {

checkFileNames(`Program rootFileNames`, program.getRootFileNames(), expectedFiles);

}

function createWatchOfConfigFile(configFileName: string, host: WatchedSystem, maxNumberOfFilesToIterateForInvalidation?: number) {

const compilerHost = ts.createWatchCompilerHostOfConfigFile(configFileName, {}, host);

compilerHost.maxNumberOfFilesToIterateForInvalidation = maxNumberOfFilesToIterateForInvalidation;

const watch = createWatchProgram(compilerHost);

return () => watch.getCurrentProgram().getProgram();

}

function createWatchOfFilesAndCompilerOptions(rootFiles: string[], host: WatchedSystem, options: CompilerOptions = {}) {

const watch = createWatchProgram(createWatchCompilerHostOfFilesAndCompilerOptions(rootFiles, options, host));

return () => watch.getCurrentProgram().getProgram();

}

function getEmittedLineForMultiFileOutput(file: FileOrFolder, host: WatchedSystem) {

return `TSFILE: ${file.path.replace(".ts", ".js")}${host.newLine}`;

}

function getEmittedLineForSingleFileOutput(filename: string, host: WatchedSystem) {

return `TSFILE: ${filename}${host.newLine}`;

}

interface FileOrFolderEmit extends FileOrFolder {

output?: string;

}

function getFileOrFolderEmit(file: FileOrFolder, getOutput?: (file: FileOrFolder) => string): FileOrFolderEmit {

const result = file as FileOrFolderEmit;

if (getOutput) {

result.output = getOutput(file);

}

return result;

}

function getEmittedLines(files: FileOrFolderEmit[]) {

const seen = createMap<true>();

const result: string[] = [];

for (const { output } of files) {

if (output && !seen.has(output)) {

seen.set(output, true);

result.push(output);

}

}

return result;

}

function checkAffectedLines(host: WatchedSystem, affectedFiles: FileOrFolderEmit[], allEmittedFiles: string[]) {

const expectedAffectedFiles = getEmittedLines(affectedFiles);

const expectedNonAffectedFiles = mapDefined(allEmittedFiles, line => contains(expectedAffectedFiles, line) ? undefined : line);

checkOutputContains(host, expectedAffectedFiles);

checkOutputDoesNotContain(host, expectedNonAffectedFiles);

}

enum ExpectedOutputErrorsPosition {

BeforeCompilationStarts,

AfterCompilationStarting,

AfterFileChangeDetected

}

function checkOutputErrors(

host: WatchedSystem,

errors: ReadonlyArray<Diagnostic>,

errorsPosition: ExpectedOutputErrorsPosition,

skipWaiting?: true

) {

const outputs = host.getOutput();

const expectedOutputCount = errors.length + (skipWaiting ? 0 : 1) + 1;

assert.equal(outputs.length, expectedOutputCount, "Outputs = " + outputs.toString());

let index: number;

switch (errorsPosition) {

case ExpectedOutputErrorsPosition.AfterCompilationStarting:

assertWatchDiagnosticAt(host, 0, Diagnostics.Starting_compilation_in_watch_mode);

index = 1;

break;

case ExpectedOutputErrorsPosition.AfterFileChangeDetected:

assertWatchDiagnosticAt(host, 0, Diagnostics.File_change_detected_Starting_incremental_compilation);

index = 1;

break;

case ExpectedOutputErrorsPosition.BeforeCompilationStarts:

assertWatchDiagnosticAt(host, errors.length, Diagnostics.Starting_compilation_in_watch_mode);

index = 0;

break;

}

forEach(errors, error => {

assertDiagnosticAt(host, index, error);

index++;

});

if (!skipWaiting) {

if (errorsPosition === ExpectedOutputErrorsPosition.BeforeCompilationStarts) {

assertWatchDiagnosticAt(host, index, ts.Diagnostics.Starting_compilation_in_watch_mode);

index += 1;

}

assertWatchDiagnosticAt(host, index, Diagnostics.Compilation_complete_Watching_for_file_changes);

}

host.clearOutput();

}

function assertDiagnosticAt(host: WatchedSystem, outputAt: number, diagnostic: Diagnostic) {

const output = host.getOutput()[outputAt];

assert.equal(output, formatDiagnostic(diagnostic, host), "outputs[" + outputAt + "] is " + output);

}

function assertWatchDiagnosticAt(host: WatchedSystem, outputAt: number, diagnosticMessage: DiagnosticMessage) {

const output = host.getOutput()[outputAt];

assert.isTrue(endsWith(output, getWatchDiagnosticWithoutDate(host, diagnosticMessage)), "outputs[" + outputAt + "] is " + output);

}

function getWatchDiagnosticWithoutDate(host: WatchedSystem, diagnosticMessage: DiagnosticMessage) {

return ` - ${flattenDiagnosticMessageText(getLocaleSpecificMessage(diagnosticMessage), host.newLine)}${host.newLine + host.newLine + host.newLine}`;

}

function getDiagnosticOfFileFrom(file: SourceFile, text: string, start: number, length: number, message: DiagnosticMessage): Diagnostic {

return {

file,

start,

length,

messageText: text,

category: message.category,

code: message.code,

};

}

function getDiagnosticWithoutFile(message: DiagnosticMessage, ..._args: (string | number)[]): Diagnostic {

let text = getLocaleSpecificMessage(message);

if (arguments.length > 1) {

text = formatStringFromArgs(text, arguments, 1);

}

return getDiagnosticOfFileFrom(/*file*/ undefined, text, /*start*/ undefined, /*length*/ undefined, message);

}

function getDiagnosticOfFile(file: SourceFile, start: number, length: number, message: DiagnosticMessage, ..._args: (string | number)[]): Diagnostic {

let text = getLocaleSpecificMessage(message);

if (arguments.length > 4) {

text = formatStringFromArgs(text, arguments, 4);

}

return getDiagnosticOfFileFrom(file, text, start, length, message);

}

function getUnknownCompilerOption(program: Program, configFile: FileOrFolder, option: string) {

const quotedOption = `"${option}"`;

return getDiagnosticOfFile(program.getCompilerOptions().configFile, configFile.content.indexOf(quotedOption), quotedOption.length, Diagnostics.Unknown_compiler_option_0, option);

}

function getDiagnosticOfFileFromProgram(program: Program, filePath: string, start: number, length: number, message: DiagnosticMessage, ..._args: (string | number)[]): Diagnostic {

let text = getLocaleSpecificMessage(message);

if (arguments.length > 5) {

text = formatStringFromArgs(text, arguments, 5);

}

return getDiagnosticOfFileFrom(program.getSourceFileByPath(toPath(filePath, program.getCurrentDirectory(), s => s.toLowerCase())),

text, start, length, message);

}

function getDiagnosticModuleNotFoundOfFile(program: Program, file: FileOrFolder, moduleName: string) {

const quotedModuleName = `"${moduleName}"`;

return getDiagnosticOfFileFromProgram(program, file.path, file.content.indexOf(quotedModuleName), quotedModuleName.length, Diagnostics.Cannot_find_module_0, moduleName);

}

describe("tsc-watch program updates", () => {

const commonFile1: FileOrFolder = {

path: "/a/b/commonFile1.ts",

content: "let x = 1"

};

const commonFile2: FileOrFolder = {

path: "/a/b/commonFile2.ts",

content: "let y = 1"

};

it("create watch without config file", () => {

const appFile: FileOrFolder = {

path: "/a/b/c/app.ts",

content: `

import {f} from "./module"

console.log(f)

`

};

const moduleFile: FileOrFolder = {

path: "/a/b/c/module.d.ts",

content: `export let x: number`

};

const host = createWatchedSystem([appFile, moduleFile, libFile]);

const watch = createWatchOfFilesAndCompilerOptions([appFile.path], host);

checkProgramActualFiles(watch(), [appFile.path, libFile.path, moduleFile.path]);

// TODO: Should we watch creation of config files in the root file's file hierarchy?

// const configFileLocations = ["/a/b/c/", "/a/b/", "/a/", "/"];

// const configFiles = flatMap(configFileLocations, location => [location + "tsconfig.json", location + "jsconfig.json"]);

// checkWatchedFiles(host, configFiles.concat(libFile.path, moduleFile.path));

});

it("can handle tsconfig file name with difference casing", () => {

const f1 = {

path: "/a/b/app.ts",

content: "let x = 1"

};

const config = {

path: "/a/b/tsconfig.json",

content: JSON.stringify({

include: ["app.ts"]

})

};

const host = createWatchedSystem([f1, config], { useCaseSensitiveFileNames: false });

const upperCaseConfigFilePath = combinePaths(getDirectoryPath(config.path).toUpperCase(), getBaseFileName(config.path));

const watch = createWatchOfConfigFile(upperCaseConfigFilePath, host);

checkProgramActualFiles(watch(), [combinePaths(getDirectoryPath(upperCaseConfigFilePath), getBaseFileName(f1.path))]);

});

it("create configured project without file list", () => {

const configFile: FileOrFolder = {

path: "/a/b/tsconfig.json",

content: `

{

"compilerOptions": {},

"exclude": [

"e"

]

}`

};

const file1: FileOrFolder = {

path: "/a/b/c/f1.ts",

content: "let x = 1"

};

const file2: FileOrFolder = {

path: "/a/b/d/f2.ts",

content: "let y = 1"

};

const file3: FileOrFolder = {

path: "/a/b/e/f3.ts",

content: "let z = 1"

};

const host = createWatchedSystem([configFile, libFile, file1, file2, file3]);

const watch = createWatchProgram(createWatchCompilerHostOfConfigFile(configFile.path, {}, host, /*createProgram*/ undefined, notImplemented));

checkProgramActualFiles(watch.getCurrentProgram().getProgram(), [file1.path, libFile.path, file2.path]);

checkProgramRootFiles(watch.getCurrentProgram().getProgram(), [file1.path, file2.path]);

checkWatchedFiles(host, [configFile.path, file1.path, file2.path, libFile.path]);

const configDir = getDirectoryPath(configFile.path);

checkWatchedDirectories(host, [configDir, combinePaths(configDir, projectSystem.nodeModulesAtTypes)], /*recursive*/ true);

});

// TODO: if watching for config file creation

// it("add and then remove a config file in a folder with loose files", () => {

// });

it("add new files to a configured program without file list", () => {

const configFile: FileOrFolder = {

path: "/a/b/tsconfig.json",

content: `{}`

};

const host = createWatchedSystem([commonFile1, libFile, configFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

const configDir = getDirectoryPath(configFile.path);

checkWatchedDirectories(host, [configDir, combinePaths(configDir, projectSystem.nodeModulesAtTypes)], /*recursive*/ true);

checkProgramRootFiles(watch(), [commonFile1.path]);

// add a new ts file

host.reloadFS([commonFile1, commonFile2, libFile, configFile]);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramRootFiles(watch(), [commonFile1.path, commonFile2.path]);

});

it("should ignore non-existing files specified in the config file", () => {

const configFile: FileOrFolder = {

path: "/a/b/tsconfig.json",

content: `{

"compilerOptions": {},

"files": [

"commonFile1.ts",

"commonFile3.ts"

]

}`

};

const host = createWatchedSystem([commonFile1, commonFile2, configFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

const commonFile3 = "/a/b/commonFile3.ts";

checkProgramRootFiles(watch(), [commonFile1.path, commonFile3]);

checkProgramActualFiles(watch(), [commonFile1.path]);

});

it("handle recreated files correctly", () => {

const configFile: FileOrFolder = {

path: "/a/b/tsconfig.json",

content: `{}`

};

const host = createWatchedSystem([commonFile1, commonFile2, configFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkProgramRootFiles(watch(), [commonFile1.path, commonFile2.path]);

// delete commonFile2

host.reloadFS([commonFile1, configFile]);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramRootFiles(watch(), [commonFile1.path]);

// re-add commonFile2

host.reloadFS([commonFile1, commonFile2, configFile]);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramRootFiles(watch(), [commonFile1.path, commonFile2.path]);

});

it("handles the missing files - that were added to program because they were added with ///<ref", () => {

const commonFile2Name = "commonFile2.ts";

const file1: FileOrFolder = {

path: "/a/b/commonFile1.ts",

content: `/// <reference path="${commonFile2Name}"/>

let x = y`

};

const host = createWatchedSystem([file1, libFile]);

const watch = createWatchOfFilesAndCompilerOptions([file1.path], host);

checkProgramRootFiles(watch(), [file1.path]);

checkProgramActualFiles(watch(), [file1.path, libFile.path]);

checkOutputErrors(host, [

getDiagnosticOfFileFromProgram(watch(), file1.path, file1.content.indexOf(commonFile2Name), commonFile2Name.length, Diagnostics.File_0_not_found, commonFile2.path),

getDiagnosticOfFileFromProgram(watch(), file1.path, file1.content.indexOf("y"), 1, Diagnostics.Cannot_find_name_0, "y")

], /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterCompilationStarting);

host.reloadFS([file1, commonFile2, libFile]);

host.runQueuedTimeoutCallbacks();

checkProgramRootFiles(watch(), [file1.path]);

checkProgramActualFiles(watch(), [file1.path, libFile.path, commonFile2.path]);

checkOutputErrors(host, emptyArray, /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterFileChangeDetected);

});

it("should reflect change in config file", () => {

const configFile: FileOrFolder = {

path: "/a/b/tsconfig.json",

content: `{

"compilerOptions": {},

"files": ["${commonFile1.path}", "${commonFile2.path}"]

}`

};

const files = [commonFile1, commonFile2, configFile];

const host = createWatchedSystem(files);

const watch = createWatchOfConfigFile(configFile.path, host);

checkProgramRootFiles(watch(), [commonFile1.path, commonFile2.path]);

configFile.content = `{

"compilerOptions": {},

"files": ["${commonFile1.path}"]

}`;

host.reloadFS(files);

host.checkTimeoutQueueLengthAndRun(1); // reload the configured project

checkProgramRootFiles(watch(), [commonFile1.path]);

});

it("files explicitly excluded in config file", () => {

const configFile: FileOrFolder = {

path: "/a/b/tsconfig.json",

content: `{

"compilerOptions": {},

"exclude": ["/a/c"]

}`

};

const excludedFile1: FileOrFolder = {

path: "/a/c/excluedFile1.ts",

content: `let t = 1;`

};

const host = createWatchedSystem([commonFile1, commonFile2, excludedFile1, configFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkProgramRootFiles(watch(), [commonFile1.path, commonFile2.path]);

});

it("should properly handle module resolution changes in config file", () => {

const file1: FileOrFolder = {

path: "/a/b/file1.ts",

content: `import { T } from "module1";`

};

const nodeModuleFile: FileOrFolder = {

path: "/a/b/node_modules/module1.ts",

content: `export interface T {}`

};

const classicModuleFile: FileOrFolder = {

path: "/a/module1.ts",

content: `export interface T {}`

};

const configFile: FileOrFolder = {

path: "/a/b/tsconfig.json",

content: `{

"compilerOptions": {

"moduleResolution": "node"

},

"files": ["${file1.path}"]

}`

};

const files = [file1, nodeModuleFile, classicModuleFile, configFile];

const host = createWatchedSystem(files);

const watch = createWatchOfConfigFile(configFile.path, host);

checkProgramRootFiles(watch(), [file1.path]);

checkProgramActualFiles(watch(), [file1.path, nodeModuleFile.path]);

configFile.content = `{

"compilerOptions": {

"moduleResolution": "classic"

},

"files": ["${file1.path}"]

}`;

host.reloadFS(files);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramRootFiles(watch(), [file1.path]);

checkProgramActualFiles(watch(), [file1.path, classicModuleFile.path]);

});

it("should tolerate config file errors and still try to build a project", () => {

const configFile: FileOrFolder = {

path: "/a/b/tsconfig.json",

content: `{

"compilerOptions": {

"target": "es6",

"allowAnything": true

},

"someOtherProperty": {}

}`

};

const host = createWatchedSystem([commonFile1, commonFile2, libFile, configFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkProgramRootFiles(watch(), [commonFile1.path, commonFile2.path]);

});

it("changes in files are reflected in project structure", () => {

const file1 = {

path: "/a/b/f1.ts",

content: `export * from "./f2"`

};

const file2 = {

path: "/a/b/f2.ts",

content: `export let x = 1`

};

const file3 = {

path: "/a/c/f3.ts",

content: `export let y = 1;`

};

const host = createWatchedSystem([file1, file2, file3]);

const watch = createWatchOfFilesAndCompilerOptions([file1.path], host);

checkProgramRootFiles(watch(), [file1.path]);

checkProgramActualFiles(watch(), [file1.path, file2.path]);

const modifiedFile2 = {

path: file2.path,

content: `export * from "../c/f3"` // now inferred project should inclule file3

};

host.reloadFS([file1, modifiedFile2, file3]);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramRootFiles(watch(), [file1.path]);

checkProgramActualFiles(watch(), [file1.path, modifiedFile2.path, file3.path]);

});

it("deleted files affect project structure", () => {

const file1 = {

path: "/a/b/f1.ts",

content: `export * from "./f2"`

};

const file2 = {

path: "/a/b/f2.ts",

content: `export * from "../c/f3"`

};

const file3 = {

path: "/a/c/f3.ts",

content: `export let y = 1;`

};

const host = createWatchedSystem([file1, file2, file3]);

const watch = createWatchOfFilesAndCompilerOptions([file1.path], host);

checkProgramActualFiles(watch(), [file1.path, file2.path, file3.path]);

host.reloadFS([file1, file3]);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramActualFiles(watch(), [file1.path]);

});

it("deleted files affect project structure - 2", () => {

const file1 = {

path: "/a/b/f1.ts",

content: `export * from "./f2"`

};

const file2 = {

path: "/a/b/f2.ts",

content: `export * from "../c/f3"`

};

const file3 = {

path: "/a/c/f3.ts",

content: `export let y = 1;`

};

const host = createWatchedSystem([file1, file2, file3]);

const watch = createWatchOfFilesAndCompilerOptions([file1.path, file3.path], host);

checkProgramActualFiles(watch(), [file1.path, file2.path, file3.path]);

host.reloadFS([file1, file3]);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramActualFiles(watch(), [file1.path, file3.path]);

});

it("config file includes the file", () => {

const file1 = {

path: "/a/b/f1.ts",

content: "export let x = 5"

};

const file2 = {

path: "/a/c/f2.ts",

content: `import {x} from "../b/f1"`

};

const file3 = {

path: "/a/c/f3.ts",

content: "export let y = 1"

};

const configFile = {

path: "/a/c/tsconfig.json",

content: JSON.stringify({ compilerOptions: {}, files: ["f2.ts", "f3.ts"] })

};

const host = createWatchedSystem([file1, file2, file3, configFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkProgramRootFiles(watch(), [file2.path, file3.path]);

checkProgramActualFiles(watch(), [file1.path, file2.path, file3.path]);

});

it("correctly migrate files between projects", () => {

const file1 = {

path: "/a/b/f1.ts",

content: `

export * from "../c/f2";

export * from "../d/f3";`

};

const file2 = {

path: "/a/c/f2.ts",

content: "export let x = 1;"

};

const file3 = {

path: "/a/d/f3.ts",

content: "export let y = 1;"

};

const host = createWatchedSystem([file1, file2, file3]);

const watch = createWatchOfFilesAndCompilerOptions([file2.path, file3.path], host);

checkProgramActualFiles(watch(), [file2.path, file3.path]);

const watch2 = createWatchOfFilesAndCompilerOptions([file1.path], host);

checkProgramActualFiles(watch2(), [file1.path, file2.path, file3.path]);

// Previous program shouldnt be updated

checkProgramActualFiles(watch(), [file2.path, file3.path]);

host.checkTimeoutQueueLength(0);

});

it("can correctly update configured project when set of root files has changed (new file on disk)", () => {

const file1 = {

path: "/a/b/f1.ts",

content: "let x = 1"

};

const file2 = {

path: "/a/b/f2.ts",

content: "let y = 1"

};

const configFile = {

path: "/a/b/tsconfig.json",

content: JSON.stringify({ compilerOptions: {} })

};

const host = createWatchedSystem([file1, configFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkProgramActualFiles(watch(), [file1.path]);

host.reloadFS([file1, file2, configFile]);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramActualFiles(watch(), [file1.path, file2.path]);

checkProgramRootFiles(watch(), [file1.path, file2.path]);

});

it("can correctly update configured project when set of root files has changed (new file in list of files)", () => {

const file1 = {

path: "/a/b/f1.ts",

content: "let x = 1"

};

const file2 = {

path: "/a/b/f2.ts",

content: "let y = 1"

};

const configFile = {

path: "/a/b/tsconfig.json",

content: JSON.stringify({ compilerOptions: {}, files: ["f1.ts"] })

};

const host = createWatchedSystem([file1, file2, configFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkProgramActualFiles(watch(), [file1.path]);

const modifiedConfigFile = {

path: configFile.path,

content: JSON.stringify({ compilerOptions: {}, files: ["f1.ts", "f2.ts"] })

};

host.reloadFS([file1, file2, modifiedConfigFile]);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramRootFiles(watch(), [file1.path, file2.path]);

checkProgramActualFiles(watch(), [file1.path, file2.path]);

});

it("can update configured project when set of root files was not changed", () => {

const file1 = {

path: "/a/b/f1.ts",

content: "let x = 1"

};

const file2 = {

path: "/a/b/f2.ts",

content: "let y = 1"

};

const configFile = {

path: "/a/b/tsconfig.json",

content: JSON.stringify({ compilerOptions: {}, files: ["f1.ts", "f2.ts"] })

};

const host = createWatchedSystem([file1, file2, configFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkProgramActualFiles(watch(), [file1.path, file2.path]);

const modifiedConfigFile = {

path: configFile.path,

content: JSON.stringify({ compilerOptions: { outFile: "out.js" }, files: ["f1.ts", "f2.ts"] })

};

host.reloadFS([file1, file2, modifiedConfigFile]);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramRootFiles(watch(), [file1.path, file2.path]);

checkProgramActualFiles(watch(), [file1.path, file2.path]);

});

it("config file is deleted", () => {

const file1 = {

path: "/a/b/f1.ts",

content: "let x = 1;"

};

const file2 = {

path: "/a/b/f2.ts",

content: "let y = 2;"

};

const config = {

path: "/a/b/tsconfig.json",

content: JSON.stringify({ compilerOptions: {} })

};

const host = createWatchedSystem([file1, file2, libFile, config]);

const watch = createWatchOfConfigFile(config.path, host);

checkProgramActualFiles(watch(), [file1.path, file2.path, libFile.path]);

checkOutputErrors(host, emptyArray, /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterCompilationStarting);

host.reloadFS([file1, file2, libFile]);

host.checkTimeoutQueueLengthAndRun(1);

assert.equal(host.exitCode, ExitStatus.DiagnosticsPresent_OutputsSkipped);

checkOutputErrors(host, [

getDiagnosticWithoutFile(Diagnostics.File_0_not_found, config.path)

], /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterFileChangeDetected, /*skipWaiting*/ true);

});

it("Proper errors: document is not contained in project", () => {

const file1 = {

path: "/a/b/app.ts",

content: ""

};

const corruptedConfig = {

path: "/a/b/tsconfig.json",

content: "{"

};

const host = createWatchedSystem([file1, corruptedConfig]);

const watch = createWatchOfConfigFile(corruptedConfig.path, host);

checkProgramActualFiles(watch(), [file1.path]);

});

it("correctly handles changes in lib section of config file", () => {

const libES5 = {

path: "/compiler/lib.es5.d.ts",

content: "declare const eval: any"

};

const libES2015Promise = {

path: "/compiler/lib.es2015.promise.d.ts",

content: "declare class Promise<T> {}"

};

const app = {

path: "/src/app.ts",

content: "var x: Promise<string>;"

};

const config1 = {

path: "/src/tsconfig.json",

content: JSON.stringify(

{

compilerOptions: {

module: "commonjs",

target: "es5",

noImplicitAny: true,

sourceMap: false,

lib: [

"es5"

]

}

})

};

const config2 = {

path: config1.path,

content: JSON.stringify(

{

compilerOptions: {

module: "commonjs",

target: "es5",

noImplicitAny: true,

sourceMap: false,

lib: [

"es5",

"es2015.promise"

]

}

})

};

const host = createWatchedSystem([libES5, libES2015Promise, app, config1], { executingFilePath: "/compiler/tsc.js" });

const watch = createWatchOfConfigFile(config1.path, host);

checkProgramActualFiles(watch(), [libES5.path, app.path]);

host.reloadFS([libES5, libES2015Promise, app, config2]);

host.checkTimeoutQueueLengthAndRun(1);

checkProgramActualFiles(watch(), [libES5.path, libES2015Promise.path, app.path]);

});

it("should handle non-existing directories in config file", () => {

const f = {

path: "/a/src/app.ts",

content: "let x = 1;"

};

const config = {

path: "/a/tsconfig.json",

content: JSON.stringify({

compilerOptions: {},

include: [

"src/**/*",

"notexistingfolder/*"

]

})

};

const host = createWatchedSystem([f, config]);

const watch = createWatchOfConfigFile(config.path, host);

checkProgramActualFiles(watch(), [f.path]);

});

it("rename a module file and rename back should restore the states for inferred projects", () => {

const moduleFile = {

path: "/a/b/moduleFile.ts",

content: "export function bar() { };"

};

const file1 = {

path: "/a/b/file1.ts",

content: 'import * as T from "./moduleFile"; T.bar();'

};

const host = createWatchedSystem([moduleFile, file1, libFile]);

const watch = createWatchOfFilesAndCompilerOptions([file1.path], host);

checkOutputErrors(host, emptyArray, /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterCompilationStarting);

const moduleFileOldPath = moduleFile.path;

const moduleFileNewPath = "/a/b/moduleFile1.ts";

moduleFile.path = moduleFileNewPath;

host.reloadFS([moduleFile, file1, libFile]);

host.runQueuedTimeoutCallbacks();

checkOutputErrors(host, [

getDiagnosticModuleNotFoundOfFile(watch(), file1, "./moduleFile")

], /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterFileChangeDetected);

moduleFile.path = moduleFileOldPath;

host.reloadFS([moduleFile, file1, libFile]);

host.runQueuedTimeoutCallbacks();

checkOutputErrors(host, emptyArray, /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterFileChangeDetected);

});

it("rename a module file and rename back should restore the states for configured projects", () => {

const moduleFile = {

path: "/a/b/moduleFile.ts",

content: "export function bar() { };"

};

const file1 = {

path: "/a/b/file1.ts",

content: 'import * as T from "./moduleFile"; T.bar();'

};

const configFile = {

path: "/a/b/tsconfig.json",

content: `{}`

};

const host = createWatchedSystem([moduleFile, file1, configFile, libFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkOutputErrors(host, emptyArray, /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterCompilationStarting);

const moduleFileOldPath = moduleFile.path;

const moduleFileNewPath = "/a/b/moduleFile1.ts";

moduleFile.path = moduleFileNewPath;

host.reloadFS([moduleFile, file1, configFile, libFile]);

host.runQueuedTimeoutCallbacks();

checkOutputErrors(host, [

getDiagnosticModuleNotFoundOfFile(watch(), file1, "./moduleFile")

], /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterFileChangeDetected);

moduleFile.path = moduleFileOldPath;

host.reloadFS([moduleFile, file1, configFile, libFile]);

host.runQueuedTimeoutCallbacks();

checkOutputErrors(host, emptyArray, /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterFileChangeDetected);

});

it("types should load from config file path if config exists", () => {

const f1 = {

path: "/a/b/app.ts",

content: "let x = 1"

};

const config = {

path: "/a/b/tsconfig.json",

content: JSON.stringify({ compilerOptions: { types: ["node"], typeRoots: [] } })

};

const node = {

path: "/a/b/node_modules/@types/node/index.d.ts",

content: "declare var process: any"

};

const cwd = {

path: "/a/c"

};

const host = createWatchedSystem([f1, config, node, cwd], { currentDirectory: cwd.path });

const watch = createWatchOfConfigFile(config.path, host);

checkProgramActualFiles(watch(), [f1.path, node.path]);

});

it("add the missing module file for inferred project: should remove the `module not found` error", () => {

const moduleFile = {

path: "/a/b/moduleFile.ts",

content: "export function bar() { };"

};

const file1 = {

path: "/a/b/file1.ts",

content: 'import * as T from "./moduleFile"; T.bar();'

};

const host = createWatchedSystem([file1, libFile]);

const watch = createWatchOfFilesAndCompilerOptions([file1.path], host);

checkOutputErrors(host, [

getDiagnosticModuleNotFoundOfFile(watch(), file1, "./moduleFile")

], /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterCompilationStarting);

host.reloadFS([file1, moduleFile, libFile]);

host.runQueuedTimeoutCallbacks();

checkOutputErrors(host, emptyArray, /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterFileChangeDetected);

});

it("Configure file diagnostics events are generated when the config file has errors", () => {

const file = {

path: "/a/b/app.ts",

content: "let x = 10"

};

const configFile = {

path: "/a/b/tsconfig.json",

content: `{

"compilerOptions": {

"foo": "bar",

"allowJS": true

}

}`

};

const host = createWatchedSystem([file, configFile, libFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkOutputErrors(host, [

getUnknownCompilerOption(watch(), configFile, "foo"),

getUnknownCompilerOption(watch(), configFile, "allowJS")

], /*errorsPosition*/ ExpectedOutputErrorsPosition.BeforeCompilationStarts);

});

it("If config file doesnt have errors, they are not reported", () => {

const file = {

path: "/a/b/app.ts",

content: "let x = 10"

};

const configFile = {

path: "/a/b/tsconfig.json",

content: `{

"compilerOptions": {}

}`

};

const host = createWatchedSystem([file, configFile, libFile]);

createWatchOfConfigFile(configFile.path, host);

checkOutputErrors(host, emptyArray, /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterCompilationStarting);

});

it("Reports errors when the config file changes", () => {

const file = {

path: "/a/b/app.ts",

content: "let x = 10"

};

const configFile = {

path: "/a/b/tsconfig.json",

content: `{

"compilerOptions": {}

}`

};

const host = createWatchedSystem([file, configFile, libFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkOutputErrors(host, emptyArray, /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterCompilationStarting);

configFile.content = `{

"compilerOptions": {

"haha": 123

}

}`;

host.reloadFS([file, configFile, libFile]);

host.runQueuedTimeoutCallbacks();

checkOutputErrors(host, [

getUnknownCompilerOption(watch(), configFile, "haha")

], /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterFileChangeDetected);

configFile.content = `{

"compilerOptions": {}

}`;

host.reloadFS([file, configFile, libFile]);

host.runQueuedTimeoutCallbacks();

checkOutputErrors(host, emptyArray, /*errorsPosition*/ ExpectedOutputErrorsPosition.AfterFileChangeDetected);

});

it("non-existing directories listed in config file input array should be tolerated without crashing the server", () => {

const configFile = {

path: "/a/b/tsconfig.json",

content: `{

"compilerOptions": {},

"include": ["app/*", "test/**/*", "something"]

}`

};

const file1 = {

path: "/a/b/file1.ts",

content: "let t = 10;"

};

const host = createWatchedSystem([file1, configFile, libFile]);

const watch = createWatchOfConfigFile(configFile.path, host);

checkProgramActualFiles(watch(), [libFile.path]);

});

it("non-existing directories listed in config file input array should be able to handle @types if input file list is empty", () => {

const f = {

path: "/a/app.ts",

content: "let x = 1"

};

const config = {

path: "/a/tsconfig.json",

content: JSON.stringify({

compiler: {},

files: []

})

};

const t1 = {

path: "/a/node_modules/@types/typings/index.d.ts",

content: `export * from "./lib"`

};

const t2 = {

path: "/a/node_modules/@types/typings/lib.d.ts",