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

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

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

/* @internal */

namespace ts {

export function getResolvedExternalModuleName(host: EmitHost, file: SourceFile): string {

return file.moduleName || getExternalModuleNameFromPath(host, file.fileName);

}

export function getExternalModuleNameFromDeclaration(host: EmitHost, resolver: EmitResolver, declaration: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration): string {

const file = resolver.getExternalModuleFileFromDeclaration(declaration);

if (!file || isDeclarationFile(file)) {

return undefined;

}

return getResolvedExternalModuleName(host, file);

}

type DependencyGroup = Array<ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration>;

const enum Jump {

Break = 1 << 1,

Continue = 1 << 2,

Return = 1 << 3

}

const entities: Map<number> = {

"quot": 0x0022,

"amp": 0x0026,

"apos": 0x0027,

"lt": 0x003C,

"gt": 0x003E,

"nbsp": 0x00A0,

"iexcl": 0x00A1,

"cent": 0x00A2,

"pound": 0x00A3,

"curren": 0x00A4,

"yen": 0x00A5,

"brvbar": 0x00A6,

"sect": 0x00A7,

"uml": 0x00A8,

"copy": 0x00A9,

"ordf": 0x00AA,

"laquo": 0x00AB,

"not": 0x00AC,

"shy": 0x00AD,

"reg": 0x00AE,

"macr": 0x00AF,

"deg": 0x00B0,

"plusmn": 0x00B1,

"sup2": 0x00B2,

"sup3": 0x00B3,

"acute": 0x00B4,

"micro": 0x00B5,

"para": 0x00B6,

"middot": 0x00B7,

"cedil": 0x00B8,

"sup1": 0x00B9,

"ordm": 0x00BA,

"raquo": 0x00BB,

"frac14": 0x00BC,

"frac12": 0x00BD,

"frac34": 0x00BE,

"iquest": 0x00BF,

"Agrave": 0x00C0,

"Aacute": 0x00C1,

"Acirc": 0x00C2,

"Atilde": 0x00C3,

"Auml": 0x00C4,

"Aring": 0x00C5,

"AElig": 0x00C6,

"Ccedil": 0x00C7,

"Egrave": 0x00C8,

"Eacute": 0x00C9,

"Ecirc": 0x00CA,

"Euml": 0x00CB,

"Igrave": 0x00CC,

"Iacute": 0x00CD,

"Icirc": 0x00CE,

"Iuml": 0x00CF,

"ETH": 0x00D0,

"Ntilde": 0x00D1,

"Ograve": 0x00D2,

"Oacute": 0x00D3,

"Ocirc": 0x00D4,

"Otilde": 0x00D5,

"Ouml": 0x00D6,

"times": 0x00D7,

"Oslash": 0x00D8,

"Ugrave": 0x00D9,

"Uacute": 0x00DA,

"Ucirc": 0x00DB,

"Uuml": 0x00DC,

"Yacute": 0x00DD,

"THORN": 0x00DE,

"szlig": 0x00DF,

"agrave": 0x00E0,

"aacute": 0x00E1,

"acirc": 0x00E2,

"atilde": 0x00E3,

"auml": 0x00E4,

"aring": 0x00E5,

"aelig": 0x00E6,

"ccedil": 0x00E7,

"egrave": 0x00E8,

"eacute": 0x00E9,

"ecirc": 0x00EA,

"euml": 0x00EB,

"igrave": 0x00EC,

"iacute": 0x00ED,

"icirc": 0x00EE,

"iuml": 0x00EF,

"eth": 0x00F0,

"ntilde": 0x00F1,

"ograve": 0x00F2,

"oacute": 0x00F3,

"ocirc": 0x00F4,

"otilde": 0x00F5,

"ouml": 0x00F6,

"divide": 0x00F7,

"oslash": 0x00F8,

"ugrave": 0x00F9,

"uacute": 0x00FA,

"ucirc": 0x00FB,

"uuml": 0x00FC,

"yacute": 0x00FD,

"thorn": 0x00FE,

"yuml": 0x00FF,

"OElig": 0x0152,

"oelig": 0x0153,

"Scaron": 0x0160,

"scaron": 0x0161,

"Yuml": 0x0178,

"fnof": 0x0192,

"circ": 0x02C6,

"tilde": 0x02DC,

"Alpha": 0x0391,

"Beta": 0x0392,

"Gamma": 0x0393,

"Delta": 0x0394,

"Epsilon": 0x0395,

"Zeta": 0x0396,

"Eta": 0x0397,

"Theta": 0x0398,

"Iota": 0x0399,

"Kappa": 0x039A,

"Lambda": 0x039B,

"Mu": 0x039C,

"Nu": 0x039D,

"Xi": 0x039E,

"Omicron": 0x039F,

"Pi": 0x03A0,

"Rho": 0x03A1,

"Sigma": 0x03A3,

"Tau": 0x03A4,

"Upsilon": 0x03A5,

"Phi": 0x03A6,

"Chi": 0x03A7,

"Psi": 0x03A8,

"Omega": 0x03A9,

"alpha": 0x03B1,

"beta": 0x03B2,

"gamma": 0x03B3,

"delta": 0x03B4,

"epsilon": 0x03B5,

"zeta": 0x03B6,

"eta": 0x03B7,

"theta": 0x03B8,

"iota": 0x03B9,

"kappa": 0x03BA,

"lambda": 0x03BB,

"mu": 0x03BC,

"nu": 0x03BD,

"xi": 0x03BE,

"omicron": 0x03BF,

"pi": 0x03C0,

"rho": 0x03C1,

"sigmaf": 0x03C2,

"sigma": 0x03C3,

"tau": 0x03C4,

"upsilon": 0x03C5,

"phi": 0x03C6,

"chi": 0x03C7,

"psi": 0x03C8,

"omega": 0x03C9,

"thetasym": 0x03D1,

"upsih": 0x03D2,

"piv": 0x03D6,

"ensp": 0x2002,

"emsp": 0x2003,

"thinsp": 0x2009,

"zwnj": 0x200C,

"zwj": 0x200D,

"lrm": 0x200E,

"rlm": 0x200F,

"ndash": 0x2013,

"mdash": 0x2014,

"lsquo": 0x2018,

"rsquo": 0x2019,

"sbquo": 0x201A,

"ldquo": 0x201C,

"rdquo": 0x201D,

"bdquo": 0x201E,

"dagger": 0x2020,

"Dagger": 0x2021,

"bull": 0x2022,

"hellip": 0x2026,

"permil": 0x2030,

"prime": 0x2032,

"Prime": 0x2033,

"lsaquo": 0x2039,

"rsaquo": 0x203A,

"oline": 0x203E,

"frasl": 0x2044,

"euro": 0x20AC,

"image": 0x2111,

"weierp": 0x2118,

"real": 0x211C,

"trade": 0x2122,

"alefsym": 0x2135,

"larr": 0x2190,

"uarr": 0x2191,

"rarr": 0x2192,

"darr": 0x2193,

"harr": 0x2194,

"crarr": 0x21B5,

"lArr": 0x21D0,

"uArr": 0x21D1,

"rArr": 0x21D2,

"dArr": 0x21D3,

"hArr": 0x21D4,

"forall": 0x2200,

"part": 0x2202,

"exist": 0x2203,

"empty": 0x2205,

"nabla": 0x2207,

"isin": 0x2208,

"notin": 0x2209,

"ni": 0x220B,

"prod": 0x220F,

"sum": 0x2211,

"minus": 0x2212,

"lowast": 0x2217,

"radic": 0x221A,

"prop": 0x221D,

"infin": 0x221E,

"ang": 0x2220,

"and": 0x2227,

"or": 0x2228,

"cap": 0x2229,

"cup": 0x222A,

"int": 0x222B,

"there4": 0x2234,

"sim": 0x223C,

"cong": 0x2245,

"asymp": 0x2248,

"ne": 0x2260,

"equiv": 0x2261,

"le": 0x2264,

"ge": 0x2265,

"sub": 0x2282,

"sup": 0x2283,

"nsub": 0x2284,

"sube": 0x2286,

"supe": 0x2287,

"oplus": 0x2295,

"otimes": 0x2297,

"perp": 0x22A5,

"sdot": 0x22C5,

"lceil": 0x2308,

"rceil": 0x2309,

"lfloor": 0x230A,

"rfloor": 0x230B,

"lang": 0x2329,

"rang": 0x232A,

"loz": 0x25CA,

"spades": 0x2660,

"clubs": 0x2663,

"hearts": 0x2665,

"diams": 0x2666

};

// 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'

}

const enum CopyDirection {

ToOriginal,

ToOutParameter

}

/**

* If loop contains block scoped binding captured in some function then loop body is converted to a function.

* Lexical bindings declared in loop initializer will be passed into the loop body function as parameters,

* however if this binding is modified inside the body - this new value should be propagated back to the original binding.

* This is done by declaring new variable (out parameter holder) outside of the loop for every binding that is reassigned inside the body.

* On every iteration this variable is initialized with value of corresponding binding.

* At every point where control flow leaves the loop either explicitly (break/continue) or implicitly (at the end of loop body)

* we copy the value inside the loop to the out parameter holder.

*

* for (let x;;) {

* let a = 1;

* let b = () => a;

* x++

* if (...) break;

* ...

* }

*

* will be converted to

*

* var out_x;

* var loop = function(x) {

* var a = 1;

* var b = function() { return a; }

* x++;

* if (...) return out_x = x, "break";

* ...

* out_x = x;

* }

* for (var x;;) {

* out_x = x;

* var state = loop(x);

* x = out_x;

* if (state === "break") break;

* }

*

* NOTE: values to out parameters are not copies if loop is abrupted with 'return' - in this case this will end the entire enclosing function

* so nobody can observe this new value.

*/

interface LoopOutParameter {

originalName: Identifier;

outParamName: string;

}

// 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 = `

var __extends = (this && this.__extends) || function (d, b) {

for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];

function __() { this.constructor = d; }

d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());

};`;

// emit output for the __decorate helper function

const decorateHelper = `

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {

var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;

if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;

return c > 3 && r && Object.defineProperty(target, key, r), r;

};`;

// emit output for the __metadata helper function

const metadataHelper = `

var __metadata = (this && this.__metadata) || function (k, v) {

if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);

};`;

// emit output for the __param helper function

const paramHelper = `

var __param = (this && this.__param) || function (paramIndex, decorator) {

return function (target, key) { decorator(target, key, paramIndex); }

};`;

const awaiterHelper = `

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {

return new (P || (P = Promise))(function (resolve, reject) {

function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }

function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }

function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }

step((generator = generator.apply(thisArg, _arguments)).next());

});

};`;

const compilerOptions = host.getCompilerOptions();

const languageVersion = getEmitScriptTarget(compilerOptions);

const modulekind = getEmitModuleKind(compilerOptions);

const sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;

const emitterDiagnostics = createDiagnosticCollection();

let emitSkipped = false;

const newLine = host.getNewLine();

const emitJavaScript = createFileEmitter();

forEachExpectedEmitFile(host, emitFile, targetSourceFile);

return {

emitSkipped,

diagnostics: emitterDiagnostics.getDiagnostics(),

sourceMaps: sourceMapDataList

};

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;

}

interface ConvertedLoopState {

/*

* set of labels that occurred inside the converted loop

* used to determine if labeled jump can be emitted as is or it should be dispatched to calling code

*/

labels?: Map<string>;

/*

* collection of labeled jumps that transfer control outside the converted loop.

* maps store association 'label -> labelMarker' where

* - label - value of label as it appear in code

* - label marker - return value that should be interpreted by calling code as 'jump to <label>'

*/

labeledNonLocalBreaks?: Map<string>;

labeledNonLocalContinues?: Map<string>;

/*

* set of non-labeled jumps that transfer control outside the converted loop

* used to emit dispatching logic in the caller of converted loop

*/

nonLocalJumps?: Jump;

/*

* set of non-labeled jumps that should be interpreted as local

* i.e. if converted loop contains normal loop or switch statement then inside this loop break should be treated as local jump

*/

allowedNonLabeledJumps?: Jump;

/*

* alias for 'arguments' object from the calling code stack frame

* i.e.

* for (let x;;) <statement that captures x in closure and uses 'arguments'>

* should be converted to

* var loop = function(x) { <code where 'arguments' is replaced with 'arguments_1'> }

* var arguments_1 = arguments

* for (var x;;) loop(x);

* otherwise semantics of the code will be different since 'arguments' inside converted loop body

* will refer to function that holds converted loop.

* This value is set on demand.

*/

argumentsName?: string;

/*

* alias for 'this' from the calling code stack frame in case if this was used inside the converted loop

*/

thisName?: string;

/*

* list of non-block scoped variable declarations that appear inside converted loop

* such variable declarations should be moved outside the loop body

* for (let x;;) {

* var y = 1;

* ...

* }

* should be converted to

* var loop = function(x) {

* y = 1;

* ...

* }

* var y;

* for (var x;;) loop(x);

*/

hoistedLocalVariables?: Identifier[];

/**

* List of loop out parameters - detailed descripion can be found in the comment to LoopOutParameter

*/

loopOutParameters?: LoopOutParameter[];

}

function setLabeledJump(state: ConvertedLoopState, isBreak: boolean, labelText: string, labelMarker: string): void {

if (isBreak) {

if (!state.labeledNonLocalBreaks) {

state.labeledNonLocalBreaks = {};

}

state.labeledNonLocalBreaks[labelText] = labelMarker;

}

else {

if (!state.labeledNonLocalContinues) {

state.labeledNonLocalContinues = {};

}

state.labeledNonLocalContinues[labelText] = labelMarker;

}

}

function hoistVariableDeclarationFromLoop(state: ConvertedLoopState, declaration: VariableDeclaration): void {

if (!state.hoistedLocalVariables) {

state.hoistedLocalVariables = [];

}

visit(declaration.name);

function visit(node: Identifier | BindingPattern) {

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

state.hoistedLocalVariables.push((<Identifier>node));

}

else {

for (const element of (<BindingPattern>node).elements) {

visit(element.name);

}

}

}

}

function createFileEmitter(): (jsFilePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) => void {

const writer = createTextWriter(newLine);

const { write, writeTextOfNode, writeLine, increaseIndent, decreaseIndent } = writer;

let sourceMap = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? createSourceMapWriter(host, writer) : getNullSourceMapWriter();

let { setSourceFile, emitStart, emitEnd, emitPos } = sourceMap;

let currentSourceFile: SourceFile;

let currentText: string;

let currentLineMap: number[];

let currentFileIdentifiers: Map<string>;

let renamedDependencies: Map<string>;

let isEs6Module: boolean;

let isCurrentFileExternalModule: boolean;

// name of an exporter function if file is a System external module

// System.register([...], function (<exporter>) {...})

// exporting in System modules looks like:

// export var x; ... x = 1

// =>

// var x;... exporter("x", x = 1)

let exportFunctionForFile: string;

let contextObjectForFile: string;

let generatedNameSet: Map<string>;

let nodeToGeneratedName: string[];

let computedPropertyNamesToGeneratedNames: string[];

let decoratedClassAliases: string[];

let convertedLoopState: ConvertedLoopState;

let extendsEmitted: boolean;

let decorateEmitted: boolean;

let paramEmitted: boolean;

let awaiterEmitted: boolean;

let tempFlags: TempFlags = 0;

let tempVariables: Identifier[];

let tempParameters: Identifier[];

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

let exportSpecifiers: Map<ExportSpecifier[]>;

let exportEquals: ExportAssignment;

let hasExportStarsToExportValues: boolean;

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

/** Sourcemap data that will get encoded */

let sourceMapData: SourceMapData;

/** Is the file being emitted into its own file */

let isOwnFileEmit: boolean;

/** If removeComments is true, no leading-comments needed to be emitted **/

const emitLeadingCommentsOfPosition = compilerOptions.removeComments ? function (pos: number) { } : emitLeadingCommentsOfPositionWorker;

const setSourceMapWriterEmit = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? changeSourceMapEmit : function (writer: SourceMapWriter) { };

const moduleEmitDelegates: Map<(node: SourceFile, emitRelativePathAsModuleName?: boolean) => void> = {

[ModuleKind.ES6]: emitES6Module,

[ModuleKind.AMD]: emitAMDModule,

[ModuleKind.System]: emitSystemModule,

[ModuleKind.UMD]: emitUMDModule,

[ModuleKind.CommonJS]: emitCommonJSModule,

};

const bundleEmitDelegates: Map<(node: SourceFile, emitRelativePathAsModuleName?: boolean) => void> = {

[ModuleKind.ES6]() {},

[ModuleKind.AMD]: emitAMDModule,

[ModuleKind.System]: emitSystemModule,

[ModuleKind.UMD]() {},

[ModuleKind.CommonJS]() {},

};

return doEmit;

function doEmit(jsFilePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) {

sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit);

generatedNameSet = {};

nodeToGeneratedName = [];

decoratedClassAliases = [];

isOwnFileEmit = !isBundledEmit;

// Emit helpers from all the files

if (isBundledEmit && modulekind) {

forEach(sourceFiles, emitEmitHelpers);

}

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

forEach(sourceFiles, emitSourceFile);

writeLine();

const sourceMappingURL = sourceMap.getSourceMappingURL();

if (sourceMappingURL) {

write(`//# sourceMappingURL=${sourceMappingURL}`);

}

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

// reset the state

sourceMap.reset();

writer.reset();

currentSourceFile = undefined;

currentText = undefined;

currentLineMap = undefined;

exportFunctionForFile = undefined;

contextObjectForFile = undefined;

generatedNameSet = undefined;

nodeToGeneratedName = undefined;

decoratedClassAliases = undefined;

computedPropertyNamesToGeneratedNames = undefined;

convertedLoopState = undefined;

extendsEmitted = false;

decorateEmitted = false;

paramEmitted = false;

awaiterEmitted = false;

tempFlags = 0;

tempVariables = undefined;

tempParameters = undefined;

externalImports = undefined;

exportSpecifiers = undefined;

exportEquals = undefined;

hasExportStarsToExportValues = undefined;

detachedCommentsInfo = undefined;

sourceMapData = undefined;

isEs6Module = false;

renamedDependencies = undefined;

isCurrentFileExternalModule = false;

}

function emitSourceFile(sourceFile: SourceFile): void {

currentSourceFile = sourceFile;

currentText = sourceFile.text;

currentLineMap = getLineStarts(sourceFile);

exportFunctionForFile = undefined;

contextObjectForFile = undefined;

isEs6Module = sourceFile.symbol && sourceFile.symbol.exports && !!sourceFile.symbol.exports["___esModule"];

renamedDependencies = sourceFile.renamedDependencies;

currentFileIdentifiers = sourceFile.identifiers;

isCurrentFileExternalModule = isExternalModule(sourceFile);

setSourceFile(sourceFile);

emitNodeWithCommentsAndWithoutSourcemap(sourceFile);

}

function isUniqueName(name: string): boolean {

return !resolver.hasGlobalName(name) &&

!hasProperty(currentFileIdentifiers, 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)) {

const name = flags === TempFlags._i ? "_i" : "_n";

if (isUniqueName(name)) {

tempFlags |= flags;

return name;

}

}

while (true) {

const count = tempFlags & TempFlags.CountMask;

tempFlags++;

// Skip over 'i' and 'n'

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

const 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) {

const generatedName = baseName + i;

if (isUniqueName(generatedName)) {

return generatedNameSet[generatedName] = generatedName;

}

i++;

}

}

function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration) {

const name = node.name.text;

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

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

}

function generateNameForImportOrExportDeclaration(node: ImportDeclaration | ExportDeclaration) {

const expr = getExternalModuleName(node);

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

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

return makeUniqueName(baseName);

}

function generateNameForExportDefault() {

return makeUniqueName("default");

}

function generateNameForClassExpression() {

return makeUniqueName("class");

}

function generateNameForNode(node: Node) {

switch (node.kind) {

case SyntaxKind.Identifier:

return makeUniqueName((<Identifier>node).text);

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.EnumDeclaration:

return generateNameForModuleOrEnum(<ModuleDeclaration | EnumDeclaration>node);

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ExportDeclaration:

return generateNameForImportOrExportDeclaration(<ImportDeclaration | ExportDeclaration>node);

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.ExportAssignment:

return generateNameForExportDefault();

case SyntaxKind.ClassExpression:

return generateNameForClassExpression();

}

}

function getGeneratedNameForNode(node: Node) {

const id = getNodeId(node);

return nodeToGeneratedName[id] || (nodeToGeneratedName[id] = unescapeIdentifier(generateNameForNode(node)));

}

/** Write emitted output to disk */

function writeEmittedFiles(emitOutput: string, jsFilePath: string, sourceMapFilePath: string, writeByteOrderMark: boolean) {

if (compilerOptions.sourceMap && !compilerOptions.inlineSourceMap) {

writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap.getText(), /*writeByteOrderMark*/ false);

}

if (sourceMapDataList) {

sourceMapDataList.push(sourceMap.getSourceMapData());

}

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

}

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

function createTempVariable(flags: TempFlags): Identifier {

const 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 {

const temp = createTempVariable(flags);

recordTempDeclaration(temp);

return temp;

}

function emitTempDeclarations(newLine: boolean) {

if (tempVariables) {

if (newLine) {

writeLine();

}

else {

write(" ");

}

write("var ");

emitCommaList(tempVariables);

write(";");

}

}

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

* This by default writes the text provided with the given tokenKind

* but if optional emitFn callback is provided the text is emitted using the callback instead of default text

* @param tokenKind the kind of the token to search and emit

* @param startPos the position in the source to start searching for the token

* @param emitFn if given will be invoked to emit the text instead of actual token emit */

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

const tokenStartPos = skipTrivia(currentText, startPos);

emitPos(tokenStartPos);

const tokenString = tokenToString(tokenKind);

if (emitFn) {

emitFn();

}

else {

write(tokenString);

}

const tokenEndPos = tokenStartPos + tokenString.length;

emitPos(tokenEndPos);

return tokenEndPos;

}

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 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(", ");

}

}

const node = nodes[start + i];

// This emitting is to make sure we emit following comment properly

// ...(x, /*comment1*/ y)...

// ^ => node.pos

// "comment1" is not considered leading comment for "y" but rather

// considered as trailing comment of the previous node.

emitTrailingCommentsOfPosition(node.pos);

emitNode(node);

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: LiteralLikeNode, 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 | TemplateLiteralFragment) {

const text = getLiteralText(node);

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

writer.writeLiteral(text);

}

// For versions below ES6, emit binary & octal literals in their canonical decimal form.

else if (languageVersion < ScriptTarget.ES6 && isBinaryOrOctalIntegerLiteral(node, text)) {

write(node.text);

}

else {

write(text);

}

}

function getLiteralText(node: LiteralExpression | TemplateLiteralFragment) {

// Any template literal or string literal with an extended escape

// (e.g. "\u{0067}") will need to be downleveled as a escaped string literal.

if (languageVersion < ScriptTarget.ES6 && (isTemplateLiteralKind(node.kind) || node.hasExtendedUnicodeEscape)) {

return getQuotedEscapedLiteralText('"', node.text, '"');

}

// If we don't need to downlevel and we can reach the original source text using

// the node's parent reference, then simply get the text as it was originally written.

if (node.parent) {

return getTextOfNodeFromSourceText(currentText, node);

}

// If we can't reach the original source text, use the canonical form if it's a number,

// or an escaped quoted form of the original text if it's string-like.

switch (node.kind) {

case SyntaxKind.StringLiteral:

return getQuotedEscapedLiteralText('"', node.text, '"');

case SyntaxKind.NoSubstitutionTemplateLiteral:

return getQuotedEscapedLiteralText("`", node.text, "`");

case SyntaxKind.TemplateHead:

return getQuotedEscapedLiteralText("`", node.text, "${");

case SyntaxKind.TemplateMiddle:

return getQuotedEscapedLiteralText("}", node.text, "${");

case SyntaxKind.TemplateTail:

return getQuotedEscapedLiteralText("}", node.text, "`");

case SyntaxKind.NumericLiteral:

return node.text;

}

Debug.fail(`Literal kind '${node.kind}' not accounted for.`);

}

function getQuotedEscapedLiteralText(leftQuote: string, text: string, rightQuote: string) {

return leftQuote + escapeNonAsciiCharacters(escapeString(text)) + rightQuote;

}