// Block scoped definitions work poorly for global variables, temporarily enable var

/* eslint-disable no-var */

// this will work in the browser via browserify

var _chai: typeof chai = require("chai");

var assert: typeof _chai.assert = _chai.assert;

{

// chai's builtin `assert.isFalse` is featureful but slow - we don't use those features,

// so we'll just overwrite it as an alterative to migrating a bunch of code off of chai

assert.isFalse = (expr: any, msg: string) => { if (expr !== false) throw new Error(msg); };

const assertDeepImpl = assert.deepEqual;

assert.deepEqual = (a, b, msg) => {

if (ts.isArray(a) && ts.isArray(b)) {

assertDeepImpl(arrayExtraKeysObject(a), arrayExtraKeysObject(b), "Array extra keys differ");

}

assertDeepImpl(a, b, msg);

function arrayExtraKeysObject(a: readonly ({} | null | undefined)[]): object {

const obj: { [key: string]: {} | null | undefined } = {};

for (const key in a) {

if (Number.isNaN(Number(key))) {

obj[key] = a[key];

}

}

return obj;

}

};

}

var global: NodeJS.Global = Function("return this").call(undefined); // eslint-disable-line no-new-func

declare var window: {};

declare var XMLHttpRequest: new() => XMLHttpRequest;

interface XMLHttpRequest {

readonly readyState: number;

readonly responseText: string;

readonly status: number;

readonly statusText: string;

open(method: string, url: string, async?: boolean, user?: string, password?: string): void;

send(data?: string): void;

setRequestHeader(header: string, value: string): void;

getAllResponseHeaders(): string;

getResponseHeader(header: string): string | null;

overrideMimeType(mime: string): void;

}

/* eslint-enable no-var */

namespace Utils {

export function encodeString(s: string): string {

return ts.sys.bufferFrom!(s).toString("utf8");

}

export function byteLength(s: string, encoding?: string): number {

// stub implementation if Buffer is not available (in-browser case)

return Buffer.byteLength(s, encoding as ts.BufferEncoding | undefined);

}

export function evalFile(fileContents: string, fileName: string, nodeContext?: any) {

const vm = require("vm");

if (nodeContext) {

vm.runInNewContext(fileContents, nodeContext, fileName);

}

else {

vm.runInThisContext(fileContents, fileName);

}

}

/** Splits the given string on \r\n, or on only \n if that fails, or on only \r if *that* fails. */

export function splitContentByNewlines(content: string) {

// Split up the input file by line

// Note: IE JS engine incorrectly handles consecutive delimiters here when using RegExp split, so

// we have to use string-based splitting instead and try to figure out the delimiting chars

let lines = content.split("\r\n");

if (lines.length === 1) {

lines = content.split("\n");

if (lines.length === 1) {

lines = content.split("\r");

}

}

return lines;

}

/** Reads a file under /tests */

export function readTestFile(path: string) {

if (path.indexOf("tests") < 0) {

path = "tests/" + path;

}

let content: string | undefined;

try {

content = Harness.IO.readFile(Harness.userSpecifiedRoot + path);

}

catch (err) {

return undefined;

}

return content;

}

export function memoize<T extends ts.AnyFunction>(f: T, memoKey: (...anything: any[]) => string): T {

const cache = ts.createMap<any>();

return <any>(function(this: any, ...args: any[]) {

const key = memoKey(...args);

if (cache.has(key)) {

return cache.get(key);

}

else {

const value = f.apply(this, args);

cache.set(key, value);

return value;

}

});

}

export const canonicalizeForHarness = ts.createGetCanonicalFileName(/*caseSensitive*/ false); // This is done so tests work on windows _and_ linux

export function assertInvariants(node: ts.Node | undefined, parent: ts.Node | undefined): void {

if (node) {

assert.isFalse(node.pos < 0, "node.pos < 0");

assert.isFalse(node.end < 0, "node.end < 0");

assert.isFalse(node.end < node.pos, "node.end < node.pos");

assert.equal(node.parent, parent, "node.parent !== parent");

if (parent) {

// Make sure each child is contained within the parent.

assert.isFalse(node.pos < parent.pos, "node.pos < parent.pos");

assert.isFalse(node.end > parent.end, "node.end > parent.end");

}

ts.forEachChild(node, child => {

assertInvariants(child, node);

});

// Make sure each of the children is in order.

let currentPos = 0;

ts.forEachChild(node,

child => {

assert.isFalse(child.pos < currentPos, "child.pos < currentPos");

currentPos = child.end;

},

array => {

assert.isFalse(array.pos < node.pos, "array.pos < node.pos");

assert.isFalse(array.end > node.end, "array.end > node.end");

assert.isFalse(array.pos < currentPos, "array.pos < currentPos");

for (const item of array) {

assert.isFalse(item.pos < currentPos, "array[i].pos < currentPos");

currentPos = item.end;

}

currentPos = array.end;

});

const childNodesAndArrays: any[] = [];

ts.forEachChild(node, child => { childNodesAndArrays.push(child); }, array => { childNodesAndArrays.push(array); });

for (const childName in node) {

if (childName === "parent" || childName === "nextContainer" || childName === "modifiers" || childName === "externalModuleIndicator" ||

// for now ignore jsdoc comments

childName === "jsDocComment" || childName === "checkJsDirective" || childName === "commonJsModuleIndicator") {

continue;

}

const child = (<any>node)[childName];

if (isNodeOrArray(child)) {

assert.isFalse(childNodesAndArrays.indexOf(child) < 0,

"Missing child when forEach'ing over node: " + (<any>ts).SyntaxKind[node.kind] + "-" + childName);

}

}

}

}

function isNodeOrArray(a: any): boolean {

return a !== undefined && typeof a.pos === "number";

}

export function convertDiagnostics(diagnostics: readonly ts.Diagnostic[]) {

return diagnostics.map(convertDiagnostic);

}

function convertDiagnostic(diagnostic: ts.Diagnostic) {

return {

start: diagnostic.start,

length: diagnostic.length,

messageText: ts.flattenDiagnosticMessageText(diagnostic.messageText, Harness.IO.newLine()),

category: ts.diagnosticCategoryName(diagnostic, /*lowerCase*/ false),

code: diagnostic.code

};

}

export function sourceFileToJSON(file: ts.Node): string {

return JSON.stringify(file, (_, v) => isNodeOrArray(v) ? serializeNode(v) : v, " ");

function getKindName(k: number | string): string {

if (ts.isString(k)) {

return k;

}

// For some markers in SyntaxKind, we should print its original syntax name instead of

// the marker name in tests.

if (k === (<any>ts).SyntaxKind.FirstJSDocNode ||

k === (<any>ts).SyntaxKind.LastJSDocNode ||

k === (<any>ts).SyntaxKind.FirstJSDocTagNode ||

k === (<any>ts).SyntaxKind.LastJSDocTagNode) {

for (const kindName in (<any>ts).SyntaxKind) {

if ((<any>ts).SyntaxKind[kindName] === k) {

return kindName;

}

}

}

return (<any>ts).SyntaxKind[k];

}

function getFlagName(flags: any, f: number): any {

if (f === 0) {

return 0;

}

let result = "";

ts.forEach(Object.getOwnPropertyNames(flags), (v: any) => {

if (isFinite(v)) {

v = +v;

if (f === +v) {

result = flags[v];

return true;

}

else if ((f & v) > 0) {

if (result.length) {

result += " | ";

}

result += flags[v];

return false;

}

}

});

return result;

}

function getNodeFlagName(f: number) { return getFlagName((<any>ts).NodeFlags, f); }

function serializeNode(n: ts.Node): any {

const o: any = { kind: getKindName(n.kind) };

if (ts.containsParseError(n)) {

o.containsParseError = true;

}

for (const propertyName of Object.getOwnPropertyNames(n) as readonly (keyof ts.SourceFile | keyof ts.Identifier)[]) {

switch (propertyName) {

case "parent":

case "symbol":

case "locals":

case "localSymbol":

case "kind":

case "id":

case "nodeCount":

case "symbolCount":

case "identifierCount":

case "scriptSnapshot":

// Blacklist of items we never put in the baseline file.

break;

case "originalKeywordKind":

o[propertyName] = getKindName((<any>n)[propertyName]);

break;

case "flags":

// Clear the flags that are produced by aggregating child values. That is ephemeral

// data we don't care about in the dump. We only care what the parser set directly

// on the AST.

const flags = n.flags & ~(ts.NodeFlags.JavaScriptFile | ts.NodeFlags.HasAggregatedChildData);

if (flags) {

o[propertyName] = getNodeFlagName(flags);

}

break;

case "parseDiagnostics":

o[propertyName] = convertDiagnostics((<any>n)[propertyName]);

break;

case "nextContainer":

if (n.nextContainer) {

o[propertyName] = { kind: n.nextContainer.kind, pos: n.nextContainer.pos, end: n.nextContainer.end };

}

break;

case "text":

// Include 'text' field for identifiers/literals, but not for source files.

if (n.kind !== ts.SyntaxKind.SourceFile) {

o[propertyName] = (<any>n)[propertyName];

}

break;

default:

o[propertyName] = (<any>n)[propertyName];

}

}

return o;

}

}

export function assertDiagnosticsEquals(array1: readonly ts.Diagnostic[], array2: readonly ts.Diagnostic[]) {

if (array1 === array2) {

return;

}

assert(array1, "array1");

assert(array2, "array2");

assert.equal(array1.length, array2.length, "array1.length !== array2.length");

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

const d1 = array1[i];

const d2 = array2[i];

assert.equal(d1.start, d2.start, "d1.start !== d2.start");

assert.equal(d1.length, d2.length, "d1.length !== d2.length");

assert.equal(

ts.flattenDiagnosticMessageText(d1.messageText, Harness.IO.newLine()),

ts.flattenDiagnosticMessageText(d2.messageText, Harness.IO.newLine()), "d1.messageText !== d2.messageText");

assert.equal(d1.category, d2.category, "d1.category !== d2.category");

assert.equal(d1.code, d2.code, "d1.code !== d2.code");

}

}

export function assertStructuralEquals(node1: ts.Node, node2: ts.Node) {

if (node1 === node2) {

return;

}

assert(node1, "node1");

assert(node2, "node2");

assert.equal(node1.pos, node2.pos, "node1.pos !== node2.pos");

assert.equal(node1.end, node2.end, "node1.end !== node2.end");

assert.equal(node1.kind, node2.kind, "node1.kind !== node2.kind");

// call this on both nodes to ensure all propagated flags have been set (and thus can be

// compared).

assert.equal(ts.containsParseError(node1), ts.containsParseError(node2));

assert.equal(node1.flags & ~ts.NodeFlags.ReachabilityAndEmitFlags, node2.flags & ~ts.NodeFlags.ReachabilityAndEmitFlags, "node1.flags !== node2.flags");

ts.forEachChild(node1,

child1 => {

const childName = findChildName(node1, child1);

const child2: ts.Node = (<any>node2)[childName];

assertStructuralEquals(child1, child2);

},

array1 => {

const childName = findChildName(node1, array1);

const array2: ts.NodeArray<ts.Node> = (<any>node2)[childName];

assertArrayStructuralEquals(array1, array2);

});

}

function assertArrayStructuralEquals(array1: ts.NodeArray<ts.Node>, array2: ts.NodeArray<ts.Node>) {

if (array1 === array2) {

return;

}

assert(array1, "array1");

assert(array2, "array2");

assert.equal(array1.pos, array2.pos, "array1.pos !== array2.pos");

assert.equal(array1.end, array2.end, "array1.end !== array2.end");

assert.equal(array1.length, array2.length, "array1.length !== array2.length");

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

assertStructuralEquals(array1[i], array2[i]);

}

}

function findChildName(parent: any, child: any) {

for (const name in parent) {

if (parent.hasOwnProperty(name) && parent[name] === child) {

return name;

}

}

throw new Error("Could not find child in parent");

}

const maxHarnessFrames = 1;

export function filterStack(error: Error, stackTraceLimit = Infinity) {

const stack = <string>(<any>error).stack;

if (stack) {

const lines = stack.split(/\r\n?|\n/g);

const filtered: string[] = [];

let frameCount = 0;

let harnessFrameCount = 0;

for (let line of lines) {

if (isStackFrame(line)) {

if (frameCount >= stackTraceLimit

|| isMocha(line)

|| isNode(line)) {

continue;

}

if (isHarness(line)) {

if (harnessFrameCount >= maxHarnessFrames) {

continue;

}

harnessFrameCount++;

}

line = line.replace(/\bfile:\/\/\/(.*?)(?=(:\d+)*($|\)))/, (_, path) => ts.sys.resolvePath(path));

frameCount++;

}

filtered.push(line);

}

(<any>error).stack = filtered.join(Harness.IO.newLine());

}

return error;

}

function isStackFrame(line: string) {

return /^\s+at\s/.test(line);

}

function isMocha(line: string) {

return /[\\/](node_modules|components)[\\/]mocha(js)?[\\/]|[\\/]mocha\.js/.test(line);

}

function isNode(line: string) {

return /\((timers|events|node|module)\.js:/.test(line);

}

function isHarness(line: string) {

return /[\\/]src[\\/]harness[\\/]|[\\/]run\.js/.test(line);

}

}

namespace Harness {

// eslint-disable-next-line @typescript-eslint/interface-name-prefix

export interface IO {

newLine(): string;

getCurrentDirectory(): string;

useCaseSensitiveFileNames(): boolean;

resolvePath(path: string): string | undefined;

getFileSize(path: string): number;

readFile(path: string): string | undefined;

writeFile(path: string, contents: string): void;

directoryName(path: string): string | undefined;

getDirectories(path: string): string[];

createDirectory(path: string): void;

fileExists(fileName: string): boolean;

directoryExists(path: string): boolean;

deleteFile(fileName: string): void;

enumerateTestFiles(runner: RunnerBase): (string | FileBasedTest)[];

listFiles(path: string, filter?: RegExp, options?: { recursive?: boolean }): string[];

log(text: string): void;

args(): string[];

getExecutingFilePath(): string;

getWorkspaceRoot(): string;

exit(exitCode?: number): void;

readDirectory(path: string, extension?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): readonly string[];

getAccessibleFileSystemEntries(dirname: string): ts.FileSystemEntries;

tryEnableSourceMapsForHost?(): void;

getEnvironmentVariable?(name: string): string;

getMemoryUsage?(): number | undefined;

}

export let IO: IO;

// harness always uses one kind of new line

// But note that `parseTestData` in `fourslash.ts` uses "\n"

export const harnessNewLine = "\r\n";

// Root for file paths that are stored in a virtual file system

export const virtualFileSystemRoot = "/";

function createNodeIO(): IO {

let fs: any, pathModule: any;

if (require) {

fs = require("fs");

pathModule = require("path");

}

else {

fs = pathModule = {};

}

function deleteFile(path: string) {

try {

fs.unlinkSync(path);

}

catch { /*ignore*/ }

}

function directoryName(path: string) {

const dirPath = pathModule.dirname(path);

// Node will just continue to repeat the root path, rather than return null

return dirPath === path ? undefined : dirPath;

}

function enumerateTestFiles(runner: RunnerBase) {

return runner.getTestFiles();

}

function listFiles(path: string, spec: RegExp, options: { recursive?: boolean } = {}) {

function filesInFolder(folder: string): string[] {

let paths: string[] = [];

for (const file of fs.readdirSync(folder)) {

const pathToFile = pathModule.join(folder, file);

const stat = fs.statSync(pathToFile);

if (options.recursive && stat.isDirectory()) {

paths = paths.concat(filesInFolder(pathToFile));

}

else if (stat.isFile() && (!spec || file.match(spec))) {

paths.push(pathToFile);

}

}

return paths;

}

return filesInFolder(path);

}

function getAccessibleFileSystemEntries(dirname: string): ts.FileSystemEntries {

try {

const entries: string[] = fs.readdirSync(dirname || ".").sort(ts.sys.useCaseSensitiveFileNames ? ts.compareStringsCaseSensitive : ts.compareStringsCaseInsensitive);

const files: string[] = [];

const directories: string[] = [];

for (const entry of entries) {

if (entry === "." || entry === "..") continue;

const name = vpath.combine(dirname, entry);

try {

const stat = fs.statSync(name);

if (!stat) continue;

if (stat.isFile()) {

files.push(entry);

}

else if (stat.isDirectory()) {

directories.push(entry);

}

}

catch { /*ignore*/ }

}

return { files, directories };

}

catch (e) {

return { files: [], directories: [] };

}

}

function createDirectory(path: string) {

try {

fs.mkdirSync(path);

}

catch (e) {

if (e.code === "ENOENT") {

createDirectory(vpath.dirname(path));

createDirectory(path);

}

else if (!ts.sys.directoryExists(path)) {

throw e;

}

}

}

return {

newLine: () => harnessNewLine,

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

useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,

resolvePath: (path: string) => ts.sys.resolvePath(path),

getFileSize: (path: string) => ts.sys.getFileSize!(path),

readFile: path => ts.sys.readFile(path),

writeFile: (path, content) => ts.sys.writeFile(path, content),

directoryName,

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

createDirectory,

fileExists: path => ts.sys.fileExists(path),

directoryExists: path => ts.sys.directoryExists(path),

deleteFile,

listFiles,

enumerateTestFiles,

log: s => console.log(s),

args: () => ts.sys.args,

getExecutingFilePath: () => ts.sys.getExecutingFilePath(),

getWorkspaceRoot: () => vpath.resolve(__dirname, "../.."),

exit: exitCode => ts.sys.exit(exitCode),

readDirectory: (path, extension, exclude, include, depth) => ts.sys.readDirectory(path, extension, exclude, include, depth),

getAccessibleFileSystemEntries,

tryEnableSourceMapsForHost: () => ts.sys.tryEnableSourceMapsForHost && ts.sys.tryEnableSourceMapsForHost(),

getMemoryUsage: () => ts.sys.getMemoryUsage && ts.sys.getMemoryUsage(),

getEnvironmentVariable: name => ts.sys.getEnvironmentVariable(name),

};

}

export function mockHash(s: string): string {

return `hash-${s}`;

}

IO = createNodeIO();

}

if (Harness.IO.tryEnableSourceMapsForHost && /^development$/i.test(Harness.IO.getEnvironmentVariable!("NODE_ENV"))) {

Harness.IO.tryEnableSourceMapsForHost();

}

namespace Harness {

export const libFolder = "built/local/";

const tcServicesFileName = ts.combinePaths(libFolder, "typescriptServices.js");

export const tcServicesFile = IO.readFile(tcServicesFileName) + IO.newLine() + `//# sourceURL=${IO.resolvePath(tcServicesFileName)}`;

export type SourceMapEmitterCallback = (

emittedFile: string,

emittedLine: number,

emittedColumn: number,

sourceFile: string,

sourceLine: number,

sourceColumn: number,

sourceName: string,

) => void;

// Settings

/* eslint-disable prefer-const */

export let userSpecifiedRoot = "";

export let lightMode = false;

/* eslint-enable prefer-const */

/** Functionality for compiling TypeScript code */

export namespace Compiler {

/** Aggregate various writes into a single array of lines. Useful for passing to the

* TypeScript compiler to fill with source code or errors.

*/

export class WriterAggregator {

public lines: string[] = [];

public currentLine: string = undefined!;

public Write(str: string) {

// out of memory usage concerns avoid using + or += if we're going to do any manipulation of this string later

this.currentLine = [(this.currentLine || ""), str].join("");

}

public WriteLine(str: string) {

// out of memory usage concerns avoid using + or += if we're going to do any manipulation of this string later

this.lines.push([(this.currentLine || ""), str].join(""));

this.currentLine = undefined!;

}

public Close() {

if (this.currentLine !== undefined) { this.lines.push(this.currentLine); }

this.currentLine = undefined!;

}

public reset() {

this.lines = [];

this.currentLine = undefined!;

}

}

export function createSourceFileAndAssertInvariants(

fileName: string,

sourceText: string,

languageVersion: ts.ScriptTarget) {

// We'll only assert invariants outside of light mode.

const shouldAssertInvariants = !lightMode;

// Only set the parent nodes if we're asserting invariants. We don't need them otherwise.

const result = ts.createSourceFile(fileName, sourceText, languageVersion, /*setParentNodes:*/ shouldAssertInvariants);

if (shouldAssertInvariants) {

Utils.assertInvariants(result, /*parent:*/ undefined);

}

return result;

}

export const defaultLibFileName = "lib.d.ts";

export const es2015DefaultLibFileName = "lib.es2015.d.ts";

// Cache of lib files from "built/local"

let libFileNameSourceFileMap: ts.Map<ts.SourceFile> | undefined;

export function getDefaultLibrarySourceFile(fileName = defaultLibFileName): ts.SourceFile | undefined {

if (!isDefaultLibraryFile(fileName)) {

return undefined;

}

if (!libFileNameSourceFileMap) {

libFileNameSourceFileMap = ts.createMapFromTemplate({

[defaultLibFileName]: createSourceFileAndAssertInvariants(defaultLibFileName, IO.readFile(libFolder + "lib.es5.d.ts")!, /*languageVersion*/ ts.ScriptTarget.Latest)

});

}

let sourceFile = libFileNameSourceFileMap.get(fileName);

if (!sourceFile) {

libFileNameSourceFileMap.set(fileName, sourceFile = createSourceFileAndAssertInvariants(fileName, IO.readFile(libFolder + fileName)!, ts.ScriptTarget.Latest));

}

return sourceFile;

}

export function getDefaultLibFileName(options: ts.CompilerOptions): string {

switch (options.target) {

case ts.ScriptTarget.ESNext:

case ts.ScriptTarget.ES2017:

return "lib.es2017.d.ts";

case ts.ScriptTarget.ES2016:

return "lib.es2016.d.ts";

case ts.ScriptTarget.ES2015:

return es2015DefaultLibFileName;

default:

return defaultLibFileName;

}

}

// Cache these between executions so we don't have to re-parse them for every test

export const fourslashFileName = "fourslash.ts";

export let fourslashSourceFile: ts.SourceFile;

export function getCanonicalFileName(fileName: string): string {

return fileName;

}

interface HarnessOptions {

useCaseSensitiveFileNames?: boolean;

includeBuiltFile?: string;

baselineFile?: string;

libFiles?: string;

noTypesAndSymbols?: boolean;

}

// Additional options not already in ts.optionDeclarations

const harnessOptionDeclarations: ts.CommandLineOption[] = [

{ name: "allowNonTsExtensions", type: "boolean" },

{ name: "useCaseSensitiveFileNames", type: "boolean" },

{ name: "baselineFile", type: "string" },

{ name: "includeBuiltFile", type: "string" },

{ name: "fileName", type: "string" },

{ name: "libFiles", type: "string" },

{ name: "noErrorTruncation", type: "boolean" },

{ name: "suppressOutputPathCheck", type: "boolean" },

{ name: "noImplicitReferences", type: "boolean" },

{ name: "currentDirectory", type: "string" },

{ name: "symlink", type: "string" },

{ name: "link", type: "string" },

{ name: "noTypesAndSymbols", type: "boolean" },

// Emitted js baseline will print full paths for every output file

{ name: "fullEmitPaths", type: "boolean" }

];

let optionsIndex: ts.Map<ts.CommandLineOption>;

function getCommandLineOption(name: string): ts.CommandLineOption | undefined {

if (!optionsIndex) {

optionsIndex = ts.createMap<ts.CommandLineOption>();

const optionDeclarations = harnessOptionDeclarations.concat(ts.optionDeclarations);

for (const option of optionDeclarations) {

optionsIndex.set(option.name.toLowerCase(), option);

}

}

return optionsIndex.get(name.toLowerCase());

}

export function setCompilerOptionsFromHarnessSetting(settings: TestCaseParser.CompilerSettings, options: ts.CompilerOptions & HarnessOptions): void {

for (const name in settings) {

if (settings.hasOwnProperty(name)) {

const value = settings[name];

if (value === undefined) {

throw new Error(`Cannot have undefined value for compiler option '${name}'.`);

}

const option = getCommandLineOption(name);

if (option) {

const errors: ts.Diagnostic[] = [];

options[option.name] = optionValue(option, value, errors);

if (errors.length > 0) {

throw new Error(`Unknown value '${value}' for compiler option '${name}'.`);

}

}

else {

throw new Error(`Unknown compiler option '${name}'.`);

}

}

}

}

function optionValue(option: ts.CommandLineOption, value: string, errors: ts.Diagnostic[]): any {

switch (option.type) {

case "boolean":

return value.toLowerCase() === "true";

case "string":

return value;

case "number": {

const numverValue = parseInt(value, 10);

if (isNaN(numverValue)) {

throw new Error(`Value must be a number, got: ${JSON.stringify(value)}`);

}

return numverValue;

}

// If not a primitive, the possible types are specified in what is effectively a map of options.

case "list":

return ts.parseListTypeOption(option, value, errors);

default:

return ts.parseCustomTypeOption(<ts.CommandLineOptionOfCustomType>option, value, errors);

}

}

export interface TestFile {

unitName: string;

content: string;

fileOptions?: any;

}

export function compileFiles(

inputFiles: TestFile[],

otherFiles: TestFile[],

harnessSettings: TestCaseParser.CompilerSettings | undefined,

compilerOptions: ts.CompilerOptions | undefined,

// Current directory is needed for rwcRunner to be able to use currentDirectory defined in json file

currentDirectory: string | undefined,

symlinks?: vfs.FileSet

): compiler.CompilationResult {

const options: ts.CompilerOptions & HarnessOptions = compilerOptions ? ts.cloneCompilerOptions(compilerOptions) : { noResolve: false };

options.target = options.target || ts.ScriptTarget.ES3;

options.newLine = options.newLine || ts.NewLineKind.CarriageReturnLineFeed;

options.noErrorTruncation = true;

options.skipDefaultLibCheck = typeof options.skipDefaultLibCheck === "undefined" ? true : options.skipDefaultLibCheck;

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

currentDirectory = vfs.srcFolder;

}

// Parse settings

if (harnessSettings) {

setCompilerOptionsFromHarnessSetting(harnessSettings, options);

}

if (options.rootDirs) {

options.rootDirs = ts.map(options.rootDirs, d => ts.getNormalizedAbsolutePath(d, currentDirectory));

}

const useCaseSensitiveFileNames = options.useCaseSensitiveFileNames !== undefined ? options.useCaseSensitiveFileNames : true;

const programFileNames = inputFiles.map(file => file.unitName).filter(fileName => !ts.fileExtensionIs(fileName, ts.Extension.Json));

// Files from built\local that are requested by test "@includeBuiltFiles" to be in the context.

// Treat them as library files, so include them in build, but not in baselines.

if (options.includeBuiltFile) {

programFileNames.push(vpath.combine(vfs.builtFolder, options.includeBuiltFile));

}

// Files from tests\lib that are requested by "@libFiles"

if (options.libFiles) {

for (const fileName of options.libFiles.split(",")) {

programFileNames.push(vpath.combine(vfs.testLibFolder, fileName));

}

}

const docs = inputFiles.concat(otherFiles).map(documents.TextDocument.fromTestFile);

const fs = vfs.createFromFileSystem(IO, !useCaseSensitiveFileNames, { documents: docs, cwd: currentDirectory });

if (symlinks) {

fs.apply(symlinks);

}

const host = new fakes.CompilerHost(fs, options);

const result = compiler.compileFiles(host, programFileNames, options);

result.symlinks = symlinks;

return result;

}

export interface DeclarationCompilationContext {

declInputFiles: TestFile[];

declOtherFiles: TestFile[];

harnessSettings: TestCaseParser.CompilerSettings & HarnessOptions | undefined;

options: ts.CompilerOptions;

currentDirectory: string;

}

export function prepareDeclarationCompilationContext(inputFiles: readonly TestFile[],

otherFiles: readonly TestFile[],

result: compiler.CompilationResult,

harnessSettings: TestCaseParser.CompilerSettings & HarnessOptions,

options: ts.CompilerOptions,

// Current directory is needed for rwcRunner to be able to use currentDirectory defined in json file

currentDirectory: string | undefined): DeclarationCompilationContext | undefined {

if (options.declaration && result.diagnostics.length === 0) {

if (options.emitDeclarationOnly) {

if (result.js.size > 0 || result.dts.size === 0) {

throw new Error("Only declaration files should be generated when emitDeclarationOnly:true");

}

}

else if (result.dts.size !== result.getNumberOfJsFiles(/*includeJson*/ true)) {

throw new Error("There were no errors and declFiles generated did not match number of js files generated");

}

}

const declInputFiles: TestFile[] = [];

const declOtherFiles: TestFile[] = [];

// if the .d.ts is non-empty, confirm it compiles correctly as well

if (options.declaration && result.diagnostics.length === 0 && result.dts.size > 0) {

ts.forEach(inputFiles, file => addDtsFile(file, declInputFiles));

ts.forEach(otherFiles, file => addDtsFile(file, declOtherFiles));

return { declInputFiles, declOtherFiles, harnessSettings, options, currentDirectory: currentDirectory || harnessSettings.currentDirectory };

}

function addDtsFile(file: TestFile, dtsFiles: TestFile[]) {

if (vpath.isDeclaration(file.unitName) || vpath.isJson(file.unitName)) {

dtsFiles.push(file);

}

else if (vpath.isTypeScript(file.unitName) || (vpath.isJavaScript(file.unitName) && options.allowJs)) {

const declFile = findResultCodeFile(file.unitName);

if (declFile && !findUnit(declFile.file, declInputFiles) && !findUnit(declFile.file, declOtherFiles)) {

dtsFiles.push({ unitName: declFile.file, content: utils.removeByteOrderMark(declFile.text) });

}

}

}

function findResultCodeFile(fileName: string) {

const sourceFile = result.program!.getSourceFile(fileName)!;

assert(sourceFile, "Program has no source file with name '" + fileName + "'");

// Is this file going to be emitted separately

let sourceFileName: string;

const outFile = options.outFile || options.out;

if (!outFile) {

if (options.outDir) {

let sourceFilePath = ts.getNormalizedAbsolutePath(sourceFile.fileName, result.vfs.cwd());

sourceFilePath = sourceFilePath.replace(result.program!.getCommonSourceDirectory(), "");

sourceFileName = ts.combinePaths(options.outDir, sourceFilePath);

}

else {

sourceFileName = sourceFile.fileName;

}

}

else {

// Goes to single --out file

sourceFileName = outFile;

}

const dTsFileName = ts.removeFileExtension(sourceFileName) + ts.Extension.Dts;

return result.dts.get(dTsFileName);

}

function findUnit(fileName: string, units: TestFile[]) {

return ts.forEach(units, unit => unit.unitName === fileName ? unit : undefined);

}

}

export function compileDeclarationFiles(context: DeclarationCompilationContext | undefined, symlinks: vfs.FileSet | undefined) {

if (!context) {

return;

}

const { declInputFiles, declOtherFiles, harnessSettings, options, currentDirectory } = context;

const output = compileFiles(declInputFiles, declOtherFiles, harnessSettings, options, currentDirectory, symlinks);

return { declInputFiles, declOtherFiles, declResult: output };

}

export function minimalDiagnosticsToString(diagnostics: readonly ts.Diagnostic[], pretty?: boolean) {

const host = { getCanonicalFileName, getCurrentDirectory: () => "", getNewLine: () => IO.newLine() };

return (pretty ? ts.formatDiagnosticsWithColorAndContext : ts.formatDiagnostics)(diagnostics, host);

}

export function getErrorBaseline(inputFiles: readonly TestFile[], diagnostics: readonly ts.Diagnostic[], pretty?: boolean) {

let outputLines = "";

const gen = iterateErrorBaseline(inputFiles, diagnostics, { pretty });

for (let {done, value} = gen.next(); !done; { done, value } = gen.next()) {

const [, content] = value;

outputLines += content;

}

if (pretty) {

outputLines += ts.getErrorSummaryText(ts.getErrorCountForSummary(diagnostics), IO.newLine());

}

return outputLines;

}

export const diagnosticSummaryMarker = "__diagnosticSummary";

export const globalErrorsMarker = "__globalErrors";

export function *iterateErrorBaseline(inputFiles: readonly TestFile[], diagnostics: readonly ts.Diagnostic[], options?: { pretty?: boolean, caseSensitive?: boolean, currentDirectory?: string }): IterableIterator<[string, string, number]> {

diagnostics = ts.sort(diagnostics, ts.compareDiagnostics);

let outputLines = "";

// Count up all errors that were found in files other than lib.d.ts so we don't miss any

let totalErrorsReportedInNonLibraryFiles = 0;

let errorsReported = 0;

let firstLine = true;

function newLine() {

if (firstLine) {

firstLine = false;

return "";

}

return "\r\n";

}

const formatDiagnsoticHost = {

getCurrentDirectory: () => options && options.currentDirectory ? options.currentDirectory : "",

getNewLine: () => IO.newLine(),

getCanonicalFileName: ts.createGetCanonicalFileName(options && options.caseSensitive !== undefined ? options.caseSensitive : true),

};

function outputErrorText(error: ts.Diagnostic) {