//

// Copyright (c) Microsoft Corporation. All rights reserved.

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//

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

/// <reference path="..\services\shims.ts" />

/// <reference path="..\server\session.ts" />

/// <reference path="..\server\client.ts" />

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

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

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

/// <reference types="node" />

/// <reference types="mocha" />

/// <reference types="chai" />

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

/* tslint:disable:no-var-keyword */

// 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, msg) => { if (expr as any as boolean !== false) throw new Error(msg); };

declare var __dirname: string; // Node-specific

var global: NodeJS.Global = <any>Function("return this").call(undefined);

declare var window: {};

declare var XMLHttpRequest: {

new(): XMLHttpRequest;

};

interface XMLHttpRequest {

readonly readyState: number;

readonly responseText: string;

readonly status: number;

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

send(data?: string): void;

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

}

/* tslint:enable:no-var-keyword */

namespace Utils {

// Setup some globals based on the current environment

export const enum ExecutionEnvironment {

Node,

Browser,

}

export function getExecutionEnvironment() {

if (typeof window !== "undefined") {

return ExecutionEnvironment.Browser;

}

else {

return ExecutionEnvironment.Node;

}

}

export let currentExecutionEnvironment = getExecutionEnvironment();

// Thanks to browserify, Buffer is always available nowadays

const Buffer: typeof global.Buffer = require("buffer").Buffer;

export function encodeString(s: string): string {

return Buffer.from(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);

}

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

const environment = getExecutionEnvironment();

switch (environment) {

case ExecutionEnvironment.Browser:

eval(fileContents);

break;

case ExecutionEnvironment.Node:

const vm = require("vm");

if (nodeContext) {

vm.runInNewContext(fileContents, nodeContext, fileName);

}

else {

vm.runInThisContext(fileContents, fileName);

}

break;

default:

throw new Error("Unknown context");

}

}

/** 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 Function>(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, parent: ts.Node): 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") {

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: ReadonlyArray<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: (<any>ts).DiagnosticCategory[diagnostic.category],

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;

}

ts.forEach(Object.getOwnPropertyNames(n), propertyName => {

switch (propertyName) {

case "parent":

case "symbol":

case "locals":

case "localSymbol":

case "kind":

case "semanticDiagnostics":

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 "referenceDiagnostics":

case "parseDiagnostics":

o[propertyName] = Utils.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 undefined;

});

return o;

}

}

export function assertDiagnosticsEquals(array1: ReadonlyArray<ts.Diagnostic>, array2: ReadonlyArray<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 {

export interface Io {

newLine(): string;

getCurrentDirectory(): string;

useCaseSensitiveFileNames(): boolean;

resolvePath(path: string): string;

readFile(path: string): string | undefined;

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

directoryName(path: string): string;

getDirectories(path: string): string[];

createDirectory(path: string): void;

fileExists(fileName: string): boolean;

directoryExists(path: string): boolean;

deleteFile(fileName: string): void;

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

log(text: string): void;

getMemoryUsage?(): number;

args(): string[];

getExecutingFilePath(): string;

exit(exitCode?: number): void;

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

tryEnableSourceMapsForHost?(): void;

getEnvironmentVariable?(name: string): string;

}

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 = "/";

namespace IOImpl {

export namespace Node {

declare const require: any;

let fs: any, pathModule: any;

if (require) {

fs = require("fs");

pathModule = require("path");

}

else {

fs = pathModule = {};

}

export const resolvePath = (path: string) => ts.sys.resolvePath(path);

export const getCurrentDirectory = () => ts.sys.getCurrentDirectory();

export const newLine = () => harnessNewLine;

export const useCaseSensitiveFileNames = () => ts.sys.useCaseSensitiveFileNames;

export const args = () => ts.sys.args;

export const getExecutingFilePath = () => ts.sys.getExecutingFilePath();

export const exit = (exitCode: number) => ts.sys.exit(exitCode);

export const getDirectories: typeof IO.getDirectories = path => ts.sys.getDirectories(path);

export const readFile: typeof IO.readFile = path => ts.sys.readFile(path);

export const writeFile: typeof IO.writeFile = (path, content) => ts.sys.writeFile(path, content);

export const fileExists: typeof IO.fileExists = fs.existsSync;

export const log: typeof IO.log = s => console.log(s);

export const getEnvironmentVariable: typeof IO.getEnvironmentVariable = name => ts.sys.getEnvironmentVariable(name);

export function tryEnableSourceMapsForHost() {

if (ts.sys.tryEnableSourceMapsForHost) {

ts.sys.tryEnableSourceMapsForHost();

}

}

export const readDirectory: typeof IO.readDirectory = (path, extension, exclude, include, depth) => ts.sys.readDirectory(path, extension, exclude, include, depth);

export function createDirectory(path: string) {

if (!directoryExists(path)) {

fs.mkdirSync(path);

}

}

export function deleteFile(path: string) {

try {

fs.unlinkSync(path);

}

catch { /*ignore*/ }

}

export function directoryExists(path: string): boolean {

return fs.existsSync(path) && fs.statSync(path).isDirectory();

}

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

}

export let listFiles: typeof IO.listFiles = (path, spec?, options?) => {

options = options || {};

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

};

export let getMemoryUsage: typeof IO.getMemoryUsage = () => {

if (global.gc) {

global.gc();

}

return process.memoryUsage().heapUsed;

};

}

export namespace Network {

const serverRoot = "http://localhost:8888/";

export const newLine = () => harnessNewLine;

export const useCaseSensitiveFileNames = () => false;

export const getCurrentDirectory = () => "";

export const args = () => <string[]>[];

export const getExecutingFilePath = () => "";

export const exit = ts.noop;

export const getDirectories = () => <string[]>[];

export let log = (s: string) => console.log(s);

namespace Http {

function waitForXHR(xhr: XMLHttpRequest) {

while (xhr.readyState !== 4) { } // tslint:disable-line no-empty

return { status: xhr.status, responseText: xhr.responseText };

}

/// Ask the server to use node's path.resolve to resolve the given path

export interface XHRResponse {

status: number;

responseText: string;

}

/// Ask the server for the contents of the file at the given URL via a simple GET request

export function getFileFromServerSync(url: string): XHRResponse {

const xhr = new XMLHttpRequest();

try {

xhr.open("GET", url, /*async*/ false);

xhr.send();

}

catch (e) {

return { status: 404, responseText: undefined };

}

return waitForXHR(xhr);

}

/// Submit a POST request to the server to do the given action (ex WRITE, DELETE) on the provided URL

export function writeToServerSync(url: string, action: string, contents?: string): XHRResponse {

const xhr = new XMLHttpRequest();

try {

const actionMsg = "?action=" + action;

xhr.open("POST", url + actionMsg, /*async*/ false);

xhr.setRequestHeader("Access-Control-Allow-Origin", "*");

xhr.send(contents);

}

catch (e) {

log(`XHR Error: ${e}`);

return { status: 500, responseText: undefined };

}

return waitForXHR(xhr);

}

}

export function createDirectory() {

// Do nothing (?)

}

export function deleteFile(path: string) {

Http.writeToServerSync(serverRoot + path, "DELETE");

}

export function directoryExists(): boolean {

return false;

}

function directoryNameImpl(path: string) {

let dirPath = path;

// root of the server

if (dirPath.match(/localhost:\d+$/) || dirPath.match(/localhost:\d+\/$/)) {

dirPath = undefined;

// path + fileName

}

else if (dirPath.indexOf(".") === -1) {

dirPath = dirPath.substring(0, dirPath.lastIndexOf("/"));

// path

}

else {

// strip any trailing slash

if (dirPath.match(/.*\/$/)) {

dirPath = dirPath.substring(0, dirPath.length - 2);

}

dirPath = dirPath.substring(0, dirPath.lastIndexOf("/"));

}

return dirPath;

}

export let directoryName: typeof IO.directoryName = Utils.memoize(directoryNameImpl, path => path);

export function resolvePath(path: string) {

const response = Http.getFileFromServerSync(serverRoot + path + "?resolve=true");

if (response.status === 200) {

return response.responseText;

}

else {

return undefined;

}

}

export function fileExists(path: string): boolean {

const response = Http.getFileFromServerSync(serverRoot + path);

return response.status === 200;

}

export const listFiles = Utils.memoize((path: string, spec?: RegExp, options?: { recursive?: boolean }): string[] => {

const response = Http.getFileFromServerSync(serverRoot + path);

if (response.status === 200) {

let results = response.responseText.split(",");

if (spec) {

results = results.filter(file => spec.test(file));

}

if (options && !options.recursive) {

results = results.filter(file => (ts.getDirectoryPath(ts.normalizeSlashes(file)) === path));

}

return results;

}

else {

return [""];

}

}, (path: string, spec?: RegExp, options?: { recursive?: boolean }) => `${path}|${spec}|${options ? options.recursive : undefined}`);

export function readFile(file: string): string | undefined {

const response = Http.getFileFromServerSync(serverRoot + file);

if (response.status === 200) {

return response.responseText;

}

else {

return undefined;

}

}

export function writeFile(path: string, contents: string) {

Http.writeToServerSync(serverRoot + path, "WRITE", contents);

}

export function readDirectory(path: string, extension?: string[], exclude?: string[], include?: string[], depth?: number) {

const fs = new Utils.VirtualFileSystem(path, useCaseSensitiveFileNames());

for (const file of listFiles(path)) {

fs.addFile(file);

}

return ts.matchFiles(path, extension, exclude, include, useCaseSensitiveFileNames(), getCurrentDirectory(), depth, path => {

const entry = fs.traversePath(path);

if (entry && entry.isDirectory()) {

const directory = <Utils.VirtualDirectory>entry;

return {

files: ts.map(directory.getFiles(), f => f.name),

directories: ts.map(directory.getDirectories(), d => d.name)

};

}

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

});

}

}

}

export function mockHash(s: string): string {

return `hash-${s}`;

}

const environment = Utils.getExecutionEnvironment();

switch (environment) {

case Utils.ExecutionEnvironment.Node:

IO = IOImpl.Node;

break;

case Utils.ExecutionEnvironment.Browser:

IO = IOImpl.Network;

break;

default:

throw new Error(`Unknown value '${environment}' for ExecutionEnvironment.`);

}

}

namespace Harness {

export const libFolder = "built/local/";

const tcServicesFileName = ts.combinePaths(libFolder, Utils.getExecutionEnvironment() === Utils.ExecutionEnvironment.Browser ? "typescriptServicesInBrowserTest.js" : "typescriptServices.js");

export const tcServicesFile = IO.readFile(tcServicesFileName) + (Utils.getExecutionEnvironment() !== Utils.ExecutionEnvironment.Browser

? 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

export let userSpecifiedRoot = "";

export let lightMode = false;

/** 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 = !Harness.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;

}

const carriageReturnLineFeed = "\r\n";

const lineFeed = "\n";

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;

// Cache of lib files from "tests/lib/"

const testLibFileNameSourceFileMap = ts.createMap<ts.SourceFile>();

const es6TestLibFileNameSourceFileMap = ts.createMap<ts.SourceFile>();

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

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;

}

export function createCompilerHost(

inputFiles: TestFile[],

writeFile: (fn: string, contents: string, writeByteOrderMark: boolean) => void,

scriptTarget: ts.ScriptTarget,

useCaseSensitiveFileNames: boolean,

// the currentDirectory is needed for rwcRunner to passed in specified current directory to compiler host

currentDirectory: string,

newLineKind?: ts.NewLineKind,

libFiles?: string): ts.CompilerHost {

// Local get canonical file name function, that depends on passed in parameter for useCaseSensitiveFileNames

const getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);

/** Maps a symlink name to a realpath. Used only for exposing `realpath`. */

const realPathMap = ts.createMap<string>();

/**

* Maps a file name to a source file.

* This will have a different SourceFile for every symlink pointing to that file;

* if the program resolves realpaths then symlink entries will be ignored.

*/

const fileMap = ts.createMap<ts.SourceFile>();

for (const file of inputFiles) {

if (file.content !== undefined) {

const fileName = ts.normalizePath(file.unitName);

const path = ts.toPath(file.unitName, currentDirectory, getCanonicalFileName);

if (file.fileOptions && file.fileOptions.symlink) {

const links = file.fileOptions.symlink.split(",");

for (const link of links) {

const linkPath = ts.toPath(link, currentDirectory, getCanonicalFileName);

realPathMap.set(linkPath, fileName);

// Create a different SourceFile for every symlink.

const sourceFile = createSourceFileAndAssertInvariants(linkPath, file.content, scriptTarget);

fileMap.set(linkPath, sourceFile);

}

}

const sourceFile = createSourceFileAndAssertInvariants(fileName, file.content, scriptTarget);

fileMap.set(path, sourceFile);

}

}

if (libFiles) {

// Because @libFiles don't change between execution. We would cache the result of the files and reuse it to speed help compilation

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

const libFileName = "tests/lib/" + fileName;

if (scriptTarget <= ts.ScriptTarget.ES5) {

if (!testLibFileNameSourceFileMap.get(libFileName)) {

testLibFileNameSourceFileMap.set(libFileName, createSourceFileAndAssertInvariants(libFileName, IO.readFile(libFileName), scriptTarget));

}

}

else {

if (!es6TestLibFileNameSourceFileMap.get(libFileName)) {

es6TestLibFileNameSourceFileMap.set(libFileName, createSourceFileAndAssertInvariants(libFileName, IO.readFile(libFileName), scriptTarget));

}

}

}

}

function getSourceFile(fileName: string) {

fileName = ts.normalizePath(fileName);

const fromFileMap = fileMap.get(toPath(fileName));

if (fromFileMap) {

return fromFileMap;

}

else if (fileName === fourslashFileName) {

const tsFn = "tests/cases/fourslash/" + fourslashFileName;

fourslashSourceFile = fourslashSourceFile || createSourceFileAndAssertInvariants(tsFn, Harness.IO.readFile(tsFn), scriptTarget);

return fourslashSourceFile;

}

else if (ts.startsWith(fileName, "tests/lib/")) {

return scriptTarget <= ts.ScriptTarget.ES5 ? testLibFileNameSourceFileMap.get(fileName) : es6TestLibFileNameSourceFileMap.get(fileName);

}

else {

// Don't throw here -- the compiler might be looking for a test that actually doesn't exist as part of the TC

// Return if it is other library file, otherwise return undefined

return getDefaultLibrarySourceFile(fileName);

}

}

const newLine =

newLineKind === ts.NewLineKind.CarriageReturnLineFeed ? carriageReturnLineFeed :

newLineKind === ts.NewLineKind.LineFeed ? lineFeed :

Harness.IO.newLine();

function toPath(fileName: string): ts.Path {

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

}

return {

getCurrentDirectory: () => currentDirectory,

getSourceFile,

getDefaultLibFileName,

writeFile,

getCanonicalFileName,

useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,

getNewLine: () => newLine,

fileExists: fileName => fileMap.has(toPath(fileName)),

readFile(fileName: string): string | undefined {

const file = fileMap.get(toPath(fileName));

if (ts.endsWith(fileName, "json")) {