// represents one LexicalEnvironment frame to store unique generated names

interface ScopeFrame {

names: Map<string>;

previous: ScopeFrame;

}

export function isExternalModuleOrDeclarationFile(sourceFile: SourceFile) {

return isExternalModule(sourceFile) || isDeclarationFile(sourceFile);

}

// Flags enum to track count of temp variables and a few dedicated names

const enum TempFlags {

Auto = 0x00000000, // No preferred name

CountMask = 0x0FFFFFFF, // Temp variable counter

_i = 0x10000000, // Use/preference flag for '_i'

_n = 0x20000000, // Use/preference flag for '_n'

}

// targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature

export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFile: SourceFile): EmitResult {

// emit output for the __extends helper function

const extendsHelper = `

// emit output for the __decorate helper function

const decorateHelper = `

// emit output for the __metadata helper function

const metadataHelper = `

// emit output for the __param helper function

const paramHelper = `

let compilerOptions = host.getCompilerOptions();

let languageVersion = compilerOptions.target || ScriptTarget.ES3;

let sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap ? [] : undefined;

let diagnostics: Diagnostic[] = [];

let newLine = host.getNewLine();

if (targetSourceFile === undefined) {

forEach(host.getSourceFiles(), sourceFile => {

if (shouldEmitToOwnFile(sourceFile, compilerOptions)) {

let jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, ".js");

emitFile(jsFilePath, sourceFile);

}

});

if (compilerOptions.out) {

emitFile(compilerOptions.out);

}

}

else {

// targetSourceFile is specified (e.g calling emitter from language service or calling getSemanticDiagnostic from language service)

if (shouldEmitToOwnFile(targetSourceFile, compilerOptions)) {

let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, ".js");

emitFile(jsFilePath, targetSourceFile);

}

else if (!isDeclarationFile(targetSourceFile) && compilerOptions.out) {

emitFile(compilerOptions.out);

}

}

// Sort and make the unique list of diagnostics

diagnostics = sortAndDeduplicateDiagnostics(diagnostics);

return {

emitSkipped: false,

diagnostics,

sourceMaps: sourceMapDataList

};

function isNodeDescendentOf(node: Node, ancestor: Node): boolean {

while (node) {

if (node === ancestor) return true;

node = node.parent;

}

return false;

}

function isUniqueLocalName(name: string, container: Node): boolean {

for (let node = container; isNodeDescendentOf(node, container); node = node.nextContainer) {

if (node.locals && hasProperty(node.locals, name)) {

// We conservatively include alias symbols to cover cases where they're emitted as locals

if (node.locals[name].flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) {

return false;

}

}

}

return true;

}

function emitJavaScript(jsFilePath: string, root?: SourceFile) {

let writer = createTextWriter(newLine);

let write = writer.write;

let writeTextOfNode = writer.writeTextOfNode;

let writeLine = writer.writeLine;

let increaseIndent = writer.increaseIndent;

let decreaseIndent = writer.decreaseIndent;

let currentSourceFile: SourceFile;

let generatedNameSet: Map<string> = {};

let nodeToGeneratedName: string[] = [];

let blockScopedVariableToGeneratedName: string[];

let computedPropertyNamesToGeneratedNames: string[];

let extendsEmitted = false;

let decorateEmitted = false;

let paramEmitted = false;

let tempFlags = 0;

let tempVariables: Identifier[];

let tempParameters: Identifier[];

let externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[];

let exportSpecifiers: Map<ExportSpecifier[]>;

let exportEquals: ExportAssignment;

let hasExportStars: boolean;

/** write emitted output to disk*/

let writeEmittedFiles = writeJavaScriptFile;

let detachedCommentsInfo: { nodePos: number; detachedCommentEndPos: number }[];

let writeComment = writeCommentRange;

/** Emit a node */

let emit = emitNodeWithoutSourceMap;

/** Called just before starting emit of a node */

let emitStart = function (node: Node) { };

/** Called once the emit of the node is done */

let emitEnd = function (node: Node) { };

/** Emit the text for the given token that comes after startPos

let emitToken = emitTokenText;

/** Called to before starting the lexical scopes as in function/class in the emitted code because of node

let scopeEmitStart = function (scopeDeclaration: Node, scopeName?: string) { }

/** Called after coming out of the scope */

let scopeEmitEnd = function () { }

/** Sourcemap data that will get encoded */

let sourceMapData: SourceMapData;

if (compilerOptions.sourceMap) {

initializeEmitterWithSourceMaps();

}

if (root) {

// Do not call emit directly. It does not set the currentSourceFile.

emitSourceFile(root);

}

else {

forEach(host.getSourceFiles(), sourceFile => {

if (!isExternalModuleOrDeclarationFile(sourceFile)) {

emitSourceFile(sourceFile);

}

});

}

writeLine();

writeEmittedFiles(writer.getText(), /*writeByteOrderMark*/ compilerOptions.emitBOM);

return;

function emitSourceFile(sourceFile: SourceFile): void {

currentSourceFile = sourceFile;

emit(sourceFile);

}

function isUniqueName(name: string): boolean {

return !resolver.hasGlobalName(name) &&

!hasProperty(currentSourceFile.identifiers, name) &&

!hasProperty(generatedNameSet, name);

}

// Return the next available name in the pattern _a ... _z, _0, _1, ...

// TempFlags._i or TempFlags._n may be used to express a preference for that dedicated name.

// Note that names generated by makeTempVariableName and makeUniqueName will never conflict.

function makeTempVariableName(flags: TempFlags): string {

if (flags && !(tempFlags & flags)) {

var name = flags === TempFlags._i ? "_i" : "_n"

if (isUniqueName(name)) {

tempFlags |= flags;

return name;

}

}

while (true) {

let count = tempFlags & TempFlags.CountMask;

tempFlags++;

// Skip over 'i' and 'n'

if (count !== 8 && count !== 13) {

let name = count < 26 ? "_" + String.fromCharCode(CharacterCodes.a + count) : "_" + (count - 26);

if (isUniqueName(name)) {

return name;

}

}

}

}

// Generate a name that is unique within the current file and doesn't conflict with any names

// in global scope. The name is formed by adding an '_n' suffix to the specified base name,

// where n is a positive integer. Note that names generated by makeTempVariableName and

// makeUniqueName are guaranteed to never conflict.

function makeUniqueName(baseName: string): string {

// Find the first unique 'name_n', where n is a positive number

if (baseName.charCodeAt(baseName.length - 1) !== CharacterCodes._) {

baseName += "_";

}

let i = 1;

while (true) {

let generatedName = baseName + i;

if (isUniqueName(generatedName)) {

return generatedNameSet[generatedName] = generatedName;

}

i++;

}

}

function assignGeneratedName(node: Node, name: string) {

nodeToGeneratedName[getNodeId(node)] = unescapeIdentifier(name);

}

function generateNameForFunctionOrClassDeclaration(node: Declaration) {

if (!node.name) {

assignGeneratedName(node, makeUniqueName("default"));

}

}

function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration) {

if (node.name.kind === SyntaxKind.Identifier) {

let name = node.name.text;

// Use module/enum name itself if it is unique, otherwise make a unique variation

assignGeneratedName(node, isUniqueLocalName(name, node) ? name : makeUniqueName(name));

}

}

function generateNameForImportOrExportDeclaration(node: ImportDeclaration | ExportDeclaration) {

let expr = getExternalModuleName(node);

let baseName = expr.kind === SyntaxKind.StringLiteral ?

escapeIdentifier(makeIdentifierFromModuleName((<LiteralExpression>expr).text)) : "module";

assignGeneratedName(node, makeUniqueName(baseName));

}

function generateNameForImportDeclaration(node: ImportDeclaration) {

if (node.importClause) {

generateNameForImportOrExportDeclaration(node);

}

}

function generateNameForExportDeclaration(node: ExportDeclaration) {

if (node.moduleSpecifier) {

generateNameForImportOrExportDeclaration(node);

}

}

function generateNameForExportAssignment(node: ExportAssignment) {

if (node.expression && node.expression.kind !== SyntaxKind.Identifier) {

assignGeneratedName(node, makeUniqueName("default"));

}

}

function generateNameForNode(node: Node) {

switch (node.kind) {

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.ClassExpression:

generateNameForFunctionOrClassDeclaration(<Declaration>node);

break;

case SyntaxKind.ModuleDeclaration:

generateNameForModuleOrEnum(<ModuleDeclaration>node);

generateNameForNode((<ModuleDeclaration>node).body);

break;

case SyntaxKind.EnumDeclaration:

generateNameForModuleOrEnum(<EnumDeclaration>node);

break;

case SyntaxKind.ImportDeclaration:

generateNameForImportDeclaration(<ImportDeclaration>node);

break;

case SyntaxKind.ExportDeclaration:

generateNameForExportDeclaration(<ExportDeclaration>node);

break;

case SyntaxKind.ExportAssignment:

generateNameForExportAssignment(<ExportAssignment>node);

break;

}

}

function getGeneratedNameForNode(node: Node) {

let nodeId = getNodeId(node);

if (!nodeToGeneratedName[nodeId]) {

generateNameForNode(node);

}

return nodeToGeneratedName[nodeId];

}

function initializeEmitterWithSourceMaps() {

let sourceMapDir: string; // The directory in which sourcemap will be

// Current source map file and its index in the sources list

let sourceMapSourceIndex = -1;

// Names and its index map

let sourceMapNameIndexMap: Map<number> = {};

let sourceMapNameIndices: number[] = [];

function getSourceMapNameIndex() {

return sourceMapNameIndices.length ? sourceMapNameIndices[sourceMapNameIndices.length - 1] : -1;

}

// Last recorded and encoded spans

let lastRecordedSourceMapSpan: SourceMapSpan;

let lastEncodedSourceMapSpan: SourceMapSpan = {

emittedLine: 1,

emittedColumn: 1,

sourceLine: 1,

sourceColumn: 1,

sourceIndex: 0

};

let lastEncodedNameIndex = 0;

// Encoding for sourcemap span

function encodeLastRecordedSourceMapSpan() {

if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan === lastEncodedSourceMapSpan) {

return;

}

let prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn;

// Line/Comma delimiters

if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) {

// Emit comma to separate the entry

if (sourceMapData.sourceMapMappings) {

sourceMapData.sourceMapMappings += ",";

}

}

else {

// Emit line delimiters

for (let encodedLine = lastEncodedSourceMapSpan.emittedLine; encodedLine < lastRecordedSourceMapSpan.emittedLine; encodedLine++) {

sourceMapData.sourceMapMappings += ";";

}

prevEncodedEmittedColumn = 1;

}

// 1. Relative Column 0 based

sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.emittedColumn - prevEncodedEmittedColumn);

// 2. Relative sourceIndex

sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceIndex - lastEncodedSourceMapSpan.sourceIndex);

// 3. Relative sourceLine 0 based

sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceLine - lastEncodedSourceMapSpan.sourceLine);

// 4. Relative sourceColumn 0 based

sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceColumn - lastEncodedSourceMapSpan.sourceColumn);

// 5. Relative namePosition 0 based

if (lastRecordedSourceMapSpan.nameIndex >= 0) {

sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.nameIndex - lastEncodedNameIndex);

lastEncodedNameIndex = lastRecordedSourceMapSpan.nameIndex;

}

lastEncodedSourceMapSpan = lastRecordedSourceMapSpan;

sourceMapData.sourceMapDecodedMappings.push(lastEncodedSourceMapSpan);

function base64VLQFormatEncode(inValue: number) {

function base64FormatEncode(inValue: number) {

if (inValue < 64) {

return 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(inValue);

}

throw TypeError(inValue + ": not a 64 based value");

}

// Add a new least significant bit that has the sign of the value.

// if negative number the least significant bit that gets added to the number has value 1

// else least significant bit value that gets added is 0

// eg. -1 changes to binary : 01 [1] => 3

// +1 changes to binary : 01 [0] => 2

if (inValue < 0) {

inValue = ((-inValue) << 1) + 1;

}

else {

inValue = inValue << 1;

}

// Encode 5 bits at a time starting from least significant bits

let encodedStr = "";

do {

let currentDigit = inValue & 31; // 11111

inValue = inValue >> 5;

if (inValue > 0) {

// There are still more digits to decode, set the msb (6th bit)

currentDigit = currentDigit | 32;

}

encodedStr = encodedStr + base64FormatEncode(currentDigit);

} while (inValue > 0);

return encodedStr;

}

}

function recordSourceMapSpan(pos: number) {

let sourceLinePos = getLineAndCharacterOfPosition(currentSourceFile, pos);

// Convert the location to be one-based.

sourceLinePos.line++;

sourceLinePos.character++;

let emittedLine = writer.getLine();

let emittedColumn = writer.getColumn();

// If this location wasn't recorded or the location in source is going backwards, record the span

if (!lastRecordedSourceMapSpan ||

lastRecordedSourceMapSpan.emittedLine != emittedLine ||

lastRecordedSourceMapSpan.emittedColumn != emittedColumn ||

(lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex &&

(lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line ||

(lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) {

// Encode the last recordedSpan before assigning new

encodeLastRecordedSourceMapSpan();

// New span

lastRecordedSourceMapSpan = {

emittedLine: emittedLine,

emittedColumn: emittedColumn,

sourceLine: sourceLinePos.line,

sourceColumn: sourceLinePos.character,

nameIndex: getSourceMapNameIndex(),

sourceIndex: sourceMapSourceIndex

};

}

else {

// Take the new pos instead since there is no change in emittedLine and column since last location

lastRecordedSourceMapSpan.sourceLine = sourceLinePos.line;

lastRecordedSourceMapSpan.sourceColumn = sourceLinePos.character;

lastRecordedSourceMapSpan.sourceIndex = sourceMapSourceIndex;

}

}

function recordEmitNodeStartSpan(node: Node) {

// Get the token pos after skipping to the token (ignoring the leading trivia)

recordSourceMapSpan(skipTrivia(currentSourceFile.text, node.pos));

}

function recordEmitNodeEndSpan(node: Node) {

recordSourceMapSpan(node.end);

}

function writeTextWithSpanRecord(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) {

let tokenStartPos = ts.skipTrivia(currentSourceFile.text, startPos);

recordSourceMapSpan(tokenStartPos);

let tokenEndPos = emitTokenText(tokenKind, tokenStartPos, emitFn);

recordSourceMapSpan(tokenEndPos);

return tokenEndPos;

}

function recordNewSourceFileStart(node: SourceFile) {

// Add the file to tsFilePaths

// If sourceroot option: Use the relative path corresponding to the common directory path

// otherwise source locations relative to map file location

let sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir;

sourceMapData.sourceMapSources.push(getRelativePathToDirectoryOrUrl(sourcesDirectoryPath,

node.fileName,

host.getCurrentDirectory(),

host.getCanonicalFileName,

/*isAbsolutePathAnUrl*/ true));

sourceMapSourceIndex = sourceMapData.sourceMapSources.length - 1;

// The one that can be used from program to get the actual source file

sourceMapData.inputSourceFileNames.push(node.fileName);

}

function recordScopeNameOfNode(node: Node, scopeName?: string) {

function recordScopeNameIndex(scopeNameIndex: number) {

sourceMapNameIndices.push(scopeNameIndex);

}

function recordScopeNameStart(scopeName: string) {

let scopeNameIndex = -1;

if (scopeName) {

let parentIndex = getSourceMapNameIndex();

if (parentIndex !== -1) {

// Child scopes are always shown with a dot (even if they have no name),

// unless it is a computed property. Then it is shown with brackets,

// but the brackets are included in the name.

let name = (<Declaration>node).name;

if (!name || name.kind !== SyntaxKind.ComputedPropertyName) {

scopeName = "." + scopeName;

}

scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName;

}

scopeNameIndex = getProperty(sourceMapNameIndexMap, scopeName);

if (scopeNameIndex === undefined) {

scopeNameIndex = sourceMapData.sourceMapNames.length;

sourceMapData.sourceMapNames.push(scopeName);

sourceMapNameIndexMap[scopeName] = scopeNameIndex;

}

}

recordScopeNameIndex(scopeNameIndex);

}

if (scopeName) {

// The scope was already given a name use it

recordScopeNameStart(scopeName);

}

else if (node.kind === SyntaxKind.FunctionDeclaration ||

node.kind === SyntaxKind.FunctionExpression ||

node.kind === SyntaxKind.MethodDeclaration ||

node.kind === SyntaxKind.MethodSignature ||

node.kind === SyntaxKind.GetAccessor ||

node.kind === SyntaxKind.SetAccessor ||

node.kind === SyntaxKind.ModuleDeclaration ||

node.kind === SyntaxKind.ClassDeclaration ||

node.kind === SyntaxKind.EnumDeclaration) {

// Declaration and has associated name use it

if ((<Declaration>node).name) {

let name = (<Declaration>node).name;

// For computed property names, the text will include the brackets

scopeName = name.kind === SyntaxKind.ComputedPropertyName

? getTextOfNode(name)

: (<Identifier>(<Declaration>node).name).text;

}

recordScopeNameStart(scopeName);

}

else {

// Block just use the name from upper level scope

recordScopeNameIndex(getSourceMapNameIndex());

}

}

function recordScopeNameEnd() {

sourceMapNameIndices.pop();

};

function writeCommentRangeWithMap(curentSourceFile: SourceFile, writer: EmitTextWriter, comment: CommentRange, newLine: string) {

recordSourceMapSpan(comment.pos);

writeCommentRange(currentSourceFile, writer, comment, newLine);

recordSourceMapSpan(comment.end);

}

function serializeSourceMapContents(version: number, file: string, sourceRoot: string, sources: string[], names: string[], mappings: string) {

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

return JSON.stringify({

version: version,

file: file,

sourceRoot: sourceRoot,

sources: sources,

names: names,

mappings: mappings

});

}

return "{\"version\":" + version + ",\"file\":\"" + escapeString(file) + "\",\"sourceRoot\":\"" + escapeString(sourceRoot) + "\",\"sources\":[" + serializeStringArray(sources) + "],\"names\":[" + serializeStringArray(names) + "],\"mappings\":\"" + escapeString(mappings) + "\"}";

function serializeStringArray(list: string[]): string {

let output = "";

for (let i = 0, n = list.length; i < n; i++) {

if (i) {

output += ",";

}

output += "\"" + escapeString(list[i]) + "\"";

}

return output;

}

}

function writeJavaScriptAndSourceMapFile(emitOutput: string, writeByteOrderMark: boolean) {

// Write source map file

encodeLastRecordedSourceMapSpan();

writeFile(host, diagnostics, sourceMapData.sourceMapFilePath, serializeSourceMapContents(

3,

sourceMapData.sourceMapFile,

sourceMapData.sourceMapSourceRoot,

sourceMapData.sourceMapSources,

sourceMapData.sourceMapNames,

sourceMapData.sourceMapMappings), /*writeByteOrderMark*/ false);

sourceMapDataList.push(sourceMapData);

// Write sourcemap url to the js file and write the js file

writeJavaScriptFile(emitOutput + "//# sourceMappingURL=" + sourceMapData.jsSourceMappingURL, writeByteOrderMark);

}

// Initialize source map data

let sourceMapJsFile = getBaseFileName(normalizeSlashes(jsFilePath));

sourceMapData = {

sourceMapFilePath: jsFilePath + ".map",

jsSourceMappingURL: sourceMapJsFile + ".map",

sourceMapFile: sourceMapJsFile,

sourceMapSourceRoot: compilerOptions.sourceRoot || "",

sourceMapSources: [],

inputSourceFileNames: [],

sourceMapNames: [],

sourceMapMappings: "",

sourceMapDecodedMappings: []

};

// Normalize source root and make sure it has trailing "/" so that it can be used to combine paths with the

// relative paths of the sources list in the sourcemap

sourceMapData.sourceMapSourceRoot = ts.normalizeSlashes(sourceMapData.sourceMapSourceRoot);

if (sourceMapData.sourceMapSourceRoot.length && sourceMapData.sourceMapSourceRoot.charCodeAt(sourceMapData.sourceMapSourceRoot.length - 1) !== CharacterCodes.slash) {

sourceMapData.sourceMapSourceRoot += directorySeparator;

}

if (compilerOptions.mapRoot) {

sourceMapDir = normalizeSlashes(compilerOptions.mapRoot);

if (root) { // emitting single module file

// For modules or multiple emit files the mapRoot will have directory structure like the sources

// So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map

sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(root, host, sourceMapDir));

}

if (!isRootedDiskPath(sourceMapDir) && !isUrl(sourceMapDir)) {

// The relative paths are relative to the common directory

sourceMapDir = combinePaths(host.getCommonSourceDirectory(), sourceMapDir);

sourceMapData.jsSourceMappingURL = getRelativePathToDirectoryOrUrl(

getDirectoryPath(normalizePath(jsFilePath)), // get the relative sourceMapDir path based on jsFilePath

combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), // this is where user expects to see sourceMap

host.getCurrentDirectory(),

host.getCanonicalFileName,

/*isAbsolutePathAnUrl*/ true);

}

else {

sourceMapData.jsSourceMappingURL = combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL);

}

}

else {

sourceMapDir = getDirectoryPath(normalizePath(jsFilePath));

}

function emitNodeWithSourceMap(node: Node, allowGeneratedIdentifiers?: boolean) {

if (node) {

if (nodeIsSynthesized(node)) {

return emitNodeWithoutSourceMap(node, /*allowGeneratedIdentifiers*/ false);

}

if (node.kind != SyntaxKind.SourceFile) {

recordEmitNodeStartSpan(node);

emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers);

recordEmitNodeEndSpan(node);

}

else {

recordNewSourceFileStart(<SourceFile>node);

emitNodeWithoutSourceMap(node, /*allowGeneratedIdentifiers*/ false);

}

}

}

writeEmittedFiles = writeJavaScriptAndSourceMapFile;

emit = emitNodeWithSourceMap;

emitStart = recordEmitNodeStartSpan;

emitEnd = recordEmitNodeEndSpan;

emitToken = writeTextWithSpanRecord;

scopeEmitStart = recordScopeNameOfNode;

scopeEmitEnd = recordScopeNameEnd;

writeComment = writeCommentRangeWithMap;

}

function writeJavaScriptFile(emitOutput: string, writeByteOrderMark: boolean) {

writeFile(host, diagnostics, jsFilePath, emitOutput, writeByteOrderMark);

}

// Create a temporary variable with a unique unused name.

function createTempVariable(flags: TempFlags): Identifier {

let result = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);

result.text = makeTempVariableName(flags);

return result;

}

function recordTempDeclaration(name: Identifier): void {

if (!tempVariables) {

tempVariables = [];

}

tempVariables.push(name);

}

function createAndRecordTempVariable(flags: TempFlags): Identifier {

let temp = createTempVariable(flags);

recordTempDeclaration(temp);

return temp;

}

function emitTempDeclarations(newLine: boolean) {

if (tempVariables) {

if (newLine) {

writeLine();

}

else {

write(" ");

}

write("var ");

emitCommaList(tempVariables);

write(";");

}

}

function emitTokenText(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) {

let tokenString = tokenToString(tokenKind);

if (emitFn) {

emitFn();

}

else {

write(tokenString);

}

return startPos + tokenString.length;

}

function emitOptional(prefix: string, node: Node) {

if (node) {

write(prefix);

emit(node);

}

}

function emitParenthesizedIf(node: Node, parenthesized: boolean) {

if (parenthesized) {

write("(");

}

emit(node);

if (parenthesized) {

write(")");

}

}

function emitTrailingCommaIfPresent(nodeList: NodeArray<Node>): void {

if (nodeList.hasTrailingComma) {

write(",");

}

}

function emitLinePreservingList(parent: Node, nodes: NodeArray<Node>, allowTrailingComma: boolean, spacesBetweenBraces: boolean) {

Debug.assert(nodes.length > 0);

increaseIndent();

if (nodeStartPositionsAreOnSameLine(parent, nodes[0])) {

if (spacesBetweenBraces) {

write(" ");

}

}

else {

writeLine();

}

for (let i = 0, n = nodes.length; i < n; i++) {

if (i) {

if (nodeEndIsOnSameLineAsNodeStart(nodes[i - 1], nodes[i])) {

write(", ");

}

else {

write(",");

writeLine();

}

}

emit(nodes[i]);

}

if (nodes.hasTrailingComma && allowTrailingComma) {

write(",");

}

decreaseIndent();

if (nodeEndPositionsAreOnSameLine(parent, lastOrUndefined(nodes))) {

if (spacesBetweenBraces) {

write(" ");

}

}

else {

writeLine();

}

}

function emitList<TNode extends Node>(nodes: TNode[], start: number, count: number, multiLine: boolean, trailingComma: boolean, leadingComma?: boolean, noTrailingNewLine?: boolean, emitNode?: (node: TNode) => void): number {

if (!emitNode) {

emitNode = emit;

}

for (let i = 0; i < count; i++) {

if (multiLine) {

if (i || leadingComma) {

write(",");

}

writeLine();

}

else {

if (i || leadingComma) {

write(", ");

}

}

emitNode(nodes[start + i]);

leadingComma = true;

}

if (trailingComma) {

write(",");

}

if (multiLine && !noTrailingNewLine) {

writeLine();

}

return count;

}

function emitCommaList(nodes: Node[]) {

if (nodes) {

emitList(nodes, 0, nodes.length, /*multiline*/ false, /*trailingComma*/ false);

}

}

function emitLines(nodes: Node[]) {

emitLinesStartingAt(nodes, /*startIndex*/ 0);

}

function emitLinesStartingAt(nodes: Node[], startIndex: number): void {

for (let i = startIndex; i < nodes.length; i++) {

writeLine();

emit(nodes[i]);

}

}

function isBinaryOrOctalIntegerLiteral(node: LiteralExpression, text: string): boolean {

if (node.kind === SyntaxKind.NumericLiteral && text.length > 1) {

switch (text.charCodeAt(1)) {

case CharacterCodes.b:

case CharacterCodes.B:

case CharacterCodes.o:

case CharacterCodes.O:

return true;

}

}

return false;

}

function emitLiteral(node: LiteralExpression) {

let text = getLiteralText(node);

if (compilerOptions.sourceMap && (node.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(node.kind))) {