"symbol": {

type: esSymbolType,

flags: TypeFlags.ESSymbol

}

};

target.constEnumOnlyModule = false;

}

target.flags |= source.flags;

forEach(source.declarations, node => {

target.declarations.push(node);

});

assumeTrue = !assumeTrue;

}

const typeInfo = primitiveTypeInfo[right.text];

// If the type to be narrowed is any and we're checking a primitive with assumeTrue=true, return the primitive

if (!!(type.flags & TypeFlags.Any) && typeInfo && assumeTrue) {

return typeInfo.type;

const errorNode: Node = (<FunctionLikeDeclaration>subsequentNode).name || subsequentNode;

// TODO(jfreeman): These are methods, so handle computed name case

if (node.name && (<FunctionLikeDeclaration>subsequentNode).name && (<Identifier>node.name).text === (<Identifier>(<FunctionLikeDeclaration>subsequentNode).name).text) {

Debug.assert(node.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.MethodSignature);

return;

}

else if (nodeIsPresent((<FunctionLikeDeclaration>subsequentNode).body)) {

increaseIndent();

writeLine();

emitLeadingComments(node.body);

write("return ");

emit(body);

write(";");

emitTrailingComments(node.body);

}

private makeUnitName(name: string, root: string) {

};

public checkTestCodeOutput(fileName: string) {

let program: ts.Program;

let options: ts.CompilerOptions;

// equivalent to the files that will be passed on the command line

// equivalent to other files on the file system not directly passed to the compiler (ie things that are referenced by other files)

before(() => {

justName = fileName.replace(/^.*[\\\/]/, ""); // strips the fileName from the path.

const content = Harness.IO.readFile(fileName);

const testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, fileName);

const units = testCaseContent.testUnitData;

lastUnit = units[units.length - 1];

const rootDir = lastUnit.originalFilePath.indexOf("conformance") === -1 ? "tests/cases/compiler/" : lastUnit.originalFilePath.substring(0, lastUnit.originalFilePath.lastIndexOf("/")) + "/";

// We need to assemble the list of input files for the compiler and other related files on the 'filesystem' (ie in a multi-file test)

// If the last file in a test uses require or a triple slash reference we'll assume all other files will be brought in via references,

// otherwise, assume all files are just meant to be in the same compilation session without explicit references to one another.

});

}

});

after(() => {

// Mocha holds onto the closure environment of the describe callback even after the test is done.

// Therefore we have to clean out large objects after the test is done.

justName = undefined;

lastUnit = undefined;

result = undefined;

program = undefined;

options = undefined;

toBeCompiled = undefined;

otherFiles = undefined;

});

function getByteOrderMarkText(file: Harness.Compiler.GeneratedFile): string {

return file.writeByteOrderMark ? "\u00EF\u00BB\u00BF" : "";

}

return Harness.Compiler.getErrorBaseline(toBeCompiled.concat(otherFiles), result.errors);

}

}

}

if (declFileCompilationResult && declFileCompilationResult.declResult.errors.length) {

jsCode += "\r\n\r\n//// [DtsFileErrors]\r\n";

public initializeTests() {

describe(this.testSuiteName + " tests", () => {

describe("Setup compiler for compiler baselines", () => {

this.parseOptions();

});

}

// Opens a file given its 0-based index or fileName

const fileToOpen: FourSlashFile = this.findFile(indexOrName);

fileToOpen.fileName = ts.normalizeSlashes(fileToOpen.fileName);

this.activeFile = fileToOpen;

const fileName = fileToOpen.fileName.replace(Harness.IO.directoryName(fileToOpen.fileName), "").substr(1);

this.scenarioActions.push(`<OpenFile FileName="" SrcFileId="${fileName}" FileId="${fileName}" />`);

// Let the host know that this file is now open

}

public verifyErrorExistsBetweenMarkers(startMarkerName: string, endMarkerName: string, negative: boolean) {

// here we cache the JS output and reuse it for every test.

let fourslashJsOutput: string;

{

(fn, contents) => fourslashJsOutput = contents,

ts.ScriptTarget.Latest,

const program = ts.createProgram([Harness.Compiler.fourslashFileName], { noResolve: true, target: ts.ScriptTarget.ES3 }, host);

currentTestState = new TestState(basePath, testType, testData);

let result = "";

const host = Harness.Compiler.createCompilerHost(

(fn, contents) => result = contents,

ts.ScriptTarget.Latest,

const program = ts.createProgram([Harness.Compiler.fourslashFileName, fileName], { outFile: "fourslashTestOutput.js", noResolve: true, target: ts.ScriptTarget.ES3 }, host);