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

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

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

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

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

namespace ts {

const brackets = createBracketsMap();

/*@internal*/

/**

* Iterates over the source files that are expected to have an emit output.

*

* @param host An EmitHost.

* @param action The action to execute.

* @param sourceFilesOrTargetSourceFile

* If an array, the full list of source files to emit.

* Else, calls `getSourceFilesToEmit` with the (optional) target source file to determine the list of source files to emit.

*/

export function forEachEmittedFile<T>(

host: EmitHost, action: (emitFileNames: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle, emitOnlyDtsFiles: boolean) => T,

sourceFilesOrTargetSourceFile?: SourceFile[] | SourceFile,

emitOnlyDtsFiles?: boolean) {

const sourceFiles = isArray(sourceFilesOrTargetSourceFile) ? sourceFilesOrTargetSourceFile : getSourceFilesToEmit(host, sourceFilesOrTargetSourceFile);

const options = host.getCompilerOptions();

if (options.outFile || options.out) {

if (sourceFiles.length) {

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

const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);

const declarationFilePath = options.declaration ? removeFileExtension(jsFilePath) + Extension.Dts : "";

const result = action({ jsFilePath, sourceMapFilePath, declarationFilePath }, createBundle(sourceFiles), emitOnlyDtsFiles);

if (result) {

return result;

}

}

}

else {

for (const sourceFile of sourceFiles) {

const jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, getOutputExtension(sourceFile, options));

const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);

const declarationFilePath = !isSourceFileJavaScript(sourceFile) && (emitOnlyDtsFiles || options.declaration) ? getDeclarationEmitOutputFilePath(sourceFile, host) : undefined;

const result = action({ jsFilePath, sourceMapFilePath, declarationFilePath }, sourceFile, emitOnlyDtsFiles);

if (result) {

return result;

}

}

}

}

function getSourceMapFilePath(jsFilePath: string, options: CompilerOptions) {

return options.sourceMap ? jsFilePath + ".map" : undefined;

}

// JavaScript files are always LanguageVariant.JSX, as JSX syntax is allowed in .js files also.

// So for JavaScript files, '.jsx' is only emitted if the input was '.jsx', and JsxEmit.Preserve.

// For TypeScript, the only time to emit with a '.jsx' extension, is on JSX input, and JsxEmit.Preserve

function getOutputExtension(sourceFile: SourceFile, options: CompilerOptions): Extension {

if (options.jsx === JsxEmit.Preserve) {

if (isSourceFileJavaScript(sourceFile)) {

if (fileExtensionIs(sourceFile.fileName, Extension.Jsx)) {

return Extension.Jsx;

}

}

else if (sourceFile.languageVariant === LanguageVariant.JSX) {

// TypeScript source file preserving JSX syntax

return Extension.Jsx;

}

}

return Extension.Js;

}

function getOriginalSourceFileOrBundle(sourceFileOrBundle: SourceFile | Bundle) {

if (sourceFileOrBundle.kind === SyntaxKind.Bundle) {

return updateBundle(sourceFileOrBundle, sameMap(sourceFileOrBundle.sourceFiles, getOriginalSourceFile));

}

return getOriginalSourceFile(sourceFileOrBundle);

}

/*@internal*/

// 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, emitOnlyDtsFiles?: boolean, transformers?: TransformerFactory<SourceFile>[]): EmitResult {

const compilerOptions = host.getCompilerOptions();

const moduleKind = getEmitModuleKind(compilerOptions);

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

const emittedFilesList: string[] = compilerOptions.listEmittedFiles ? [] : undefined;

const emitterDiagnostics = createDiagnosticCollection();

const newLine = host.getNewLine();

const writer = createTextWriter(newLine);

const sourceMap = createSourceMapWriter(host, writer);

let currentSourceFile: SourceFile;

let bundledHelpers: Map<boolean>;

let isOwnFileEmit: boolean;

let emitSkipped = false;

const sourceFiles = getSourceFilesToEmit(host, targetSourceFile);

// Transform the source files

const transform = transformNodes(resolver, host, compilerOptions, sourceFiles, transformers, /*allowDtsFiles*/ false);

// Create a printer to print the nodes

const printer = createPrinter(compilerOptions, {

// resolver hooks

hasGlobalName: resolver.hasGlobalName,

// transform hooks

onEmitNode: transform.emitNodeWithNotification,

substituteNode: transform.substituteNode,

// sourcemap hooks

onEmitSourceMapOfNode: sourceMap.emitNodeWithSourceMap,

onEmitSourceMapOfToken: sourceMap.emitTokenWithSourceMap,

onEmitSourceMapOfPosition: sourceMap.emitPos,

// emitter hooks

onEmitHelpers: emitHelpers,

onSetSourceFile: setSourceFile,

});

// Emit each output file

performance.mark("beforePrint");

forEachEmittedFile(host, emitSourceFileOrBundle, transform.transformed, emitOnlyDtsFiles);

performance.measure("printTime", "beforePrint");

// Clean up emit nodes on parse tree

transform.dispose();

return {

emitSkipped,

diagnostics: emitterDiagnostics.getDiagnostics(),

emittedFiles: emittedFilesList,

sourceMaps: sourceMapDataList

};

function emitSourceFileOrBundle({ jsFilePath, sourceMapFilePath, declarationFilePath }: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle) {

// Make sure not to write js file and source map file if any of them cannot be written

if (!host.isEmitBlocked(jsFilePath) && !compilerOptions.noEmit && !compilerOptions.emitDeclarationsOnly) {

if (!emitOnlyDtsFiles) {

printSourceFileOrBundle(jsFilePath, sourceMapFilePath, sourceFileOrBundle);

}

}

else {

emitSkipped = true;

}

if (declarationFilePath) {

emitSkipped = writeDeclarationFile(declarationFilePath, getOriginalSourceFileOrBundle(sourceFileOrBundle), host, resolver, emitterDiagnostics, emitOnlyDtsFiles) || emitSkipped;

}

if (!emitSkipped && emittedFilesList) {

if (!emitOnlyDtsFiles) {

emittedFilesList.push(jsFilePath);

}

if (sourceMapFilePath) {

emittedFilesList.push(sourceMapFilePath);

}

if (declarationFilePath) {

emittedFilesList.push(declarationFilePath);

}

}

}

function printSourceFileOrBundle(jsFilePath: string, sourceMapFilePath: string, sourceFileOrBundle: SourceFile | Bundle) {

const bundle = sourceFileOrBundle.kind === SyntaxKind.Bundle ? sourceFileOrBundle : undefined;

const sourceFile = sourceFileOrBundle.kind === SyntaxKind.SourceFile ? sourceFileOrBundle : undefined;

const sourceFiles = bundle ? bundle.sourceFiles : [sourceFile];

sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFileOrBundle);

if (bundle) {

bundledHelpers = createMap<boolean>();

isOwnFileEmit = false;

printer.writeBundle(bundle, writer);

}

else {

isOwnFileEmit = true;

printer.writeFile(sourceFile, writer);

}

writer.writeLine();

const sourceMappingURL = sourceMap.getSourceMappingURL();

if (sourceMappingURL) {

writer.write(`//# ${"sourceMappingURL"}=${sourceMappingURL}`); // Sometimes tools can sometimes see this line as a source mapping url comment

}

// Write the source map

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

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

}

// Record source map data for the test harness.

if (sourceMapDataList) {

sourceMapDataList.push(sourceMap.getSourceMapData());

}

// Write the output file

writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), compilerOptions.emitBOM, sourceFiles);

// Reset state

sourceMap.reset();

writer.clear();

currentSourceFile = undefined;

bundledHelpers = undefined;

isOwnFileEmit = false;

}

function setSourceFile(node: SourceFile) {

currentSourceFile = node;

sourceMap.setSourceFile(node);

}

function emitHelpers(node: Node, writeLines: (text: string) => void) {

let helpersEmitted = false;

const bundle = node.kind === SyntaxKind.Bundle ? <Bundle>node : undefined;

if (bundle && moduleKind === ModuleKind.None) {

return;

}

const numNodes = bundle ? bundle.sourceFiles.length : 1;

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

const currentNode = bundle ? bundle.sourceFiles[i] : node;

const sourceFile = isSourceFile(currentNode) ? currentNode : currentSourceFile;

const shouldSkip = compilerOptions.noEmitHelpers || getExternalHelpersModuleName(sourceFile) !== undefined;

const shouldBundle = isSourceFile(currentNode) && !isOwnFileEmit;

const helpers = getEmitHelpers(currentNode);

if (helpers) {

for (const helper of stableSort(helpers, compareEmitHelpers)) {

if (!helper.scoped) {

// Skip the helper if it can be skipped and the noEmitHelpers compiler

// option is set, or if it can be imported and the importHelpers compiler

// option is set.

if (shouldSkip) continue;

// Skip the helper if it can be bundled but hasn't already been emitted and we

// are emitting a bundled module.

if (shouldBundle) {

if (bundledHelpers.get(helper.name)) {

continue;

}

bundledHelpers.set(helper.name, true);

}

}

else if (bundle) {

// Skip the helper if it is scoped and we are emitting bundled helpers

continue;

}

writeLines(helper.text);

helpersEmitted = true;

}

}

}

return helpersEmitted;

}

}

export function createPrinter(printerOptions: PrinterOptions = {}, handlers: PrintHandlers = {}): Printer {

const {

hasGlobalName,

onEmitSourceMapOfNode,

onEmitSourceMapOfToken,

onEmitSourceMapOfPosition,

onEmitNode,

onEmitHelpers,

onSetSourceFile,

substituteNode,

onBeforeEmitNodeArray,

onAfterEmitNodeArray,

onBeforeEmitToken,

onAfterEmitToken

} = handlers;

const newLine = getNewLineCharacter(printerOptions);

const comments = createCommentWriter(printerOptions, onEmitSourceMapOfPosition);

const {

emitNodeWithComments,

emitBodyWithDetachedComments,

emitTrailingCommentsOfPosition,

emitLeadingCommentsOfPosition,

} = comments;

let currentSourceFile: SourceFile | undefined;

let nodeIdToGeneratedName: string[]; // Map of generated names for specific nodes.

let autoGeneratedIdToGeneratedName: string[]; // Map of generated names for temp and loop variables.

let generatedNames: Map<true>; // Set of names generated by the NameGenerator.

let tempFlagsStack: TempFlags[]; // Stack of enclosing name generation scopes.

let tempFlags: TempFlags; // TempFlags for the current name generation scope.

let reservedNamesStack: Map<true>[]; // Stack of TempFlags reserved in enclosing name generation scopes.

let reservedNames: Map<true>; // TempFlags to reserve in nested name generation scopes.

let writer: EmitTextWriter;

let ownWriter: EmitTextWriter;

let write = writeBase;

let commitPendingSemicolon: typeof commitPendingSemicolonInternal = noop;

let writeSemicolon: typeof writeSemicolonInternal = writeSemicolonInternal;

let pendingSemicolon = false;

if (printerOptions.omitTrailingSemicolon) {

commitPendingSemicolon = commitPendingSemicolonInternal;

writeSemicolon = deferWriteSemicolon;

}

const syntheticParent: TextRange = { pos: -1, end: -1 };

reset();

return {

// public API

printNode,

printList,

printFile,

printBundle,

// internal API

writeNode,

writeList,

writeFile,

writeBundle

};

function printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string {

switch (hint) {

case EmitHint.SourceFile:

Debug.assert(isSourceFile(node), "Expected a SourceFile node.");

break;

case EmitHint.IdentifierName:

Debug.assert(isIdentifier(node), "Expected an Identifier node.");

break;

case EmitHint.Expression:

Debug.assert(isExpression(node), "Expected an Expression node.");

break;

}

switch (node.kind) {

case SyntaxKind.SourceFile: return printFile(<SourceFile>node);

case SyntaxKind.Bundle: return printBundle(<Bundle>node);

}

writeNode(hint, node, sourceFile, beginPrint());

return endPrint();

}

function printList<T extends Node>(format: ListFormat, nodes: NodeArray<T>, sourceFile: SourceFile) {

writeList(format, nodes, sourceFile, beginPrint());

return endPrint();

}

function printBundle(bundle: Bundle): string {

writeBundle(bundle, beginPrint());

return endPrint();

}

function printFile(sourceFile: SourceFile): string {

writeFile(sourceFile, beginPrint());

return endPrint();

}

/**

* If `sourceFile` is `undefined`, `node` must be a synthesized `TypeNode`.

*/

function writeNode(hint: EmitHint, node: TypeNode, sourceFile: undefined, output: EmitTextWriter): void;

function writeNode(hint: EmitHint, node: Node, sourceFile: SourceFile, output: EmitTextWriter): void;

function writeNode(hint: EmitHint, node: Node, sourceFile: SourceFile | undefined, output: EmitTextWriter) {

const previousWriter = writer;

setWriter(output);

print(hint, node, sourceFile);

reset();

writer = previousWriter;

}

function writeList<T extends Node>(format: ListFormat, nodes: NodeArray<T>, sourceFile: SourceFile | undefined, output: EmitTextWriter) {

const previousWriter = writer;

setWriter(output);

if (sourceFile) {

setSourceFile(sourceFile);

}

emitList(syntheticParent, nodes, format);

reset();

writer = previousWriter;

}

function writeBundle(bundle: Bundle, output: EmitTextWriter) {

const previousWriter = writer;

setWriter(output);

emitShebangIfNeeded(bundle);

emitPrologueDirectivesIfNeeded(bundle);

emitHelpersIndirect(bundle);

for (const sourceFile of bundle.sourceFiles) {

print(EmitHint.SourceFile, sourceFile, sourceFile);

}

reset();

writer = previousWriter;

}

function writeFile(sourceFile: SourceFile, output: EmitTextWriter) {

const previousWriter = writer;

setWriter(output);

emitShebangIfNeeded(sourceFile);

emitPrologueDirectivesIfNeeded(sourceFile);

print(EmitHint.SourceFile, sourceFile, sourceFile);

reset();

writer = previousWriter;

}

function beginPrint() {

return ownWriter || (ownWriter = createTextWriter(newLine));

}

function endPrint() {

const text = ownWriter.getText();

ownWriter.clear();

return text;

}

function print(hint: EmitHint, node: Node, sourceFile: SourceFile | undefined) {

if (sourceFile) {

setSourceFile(sourceFile);

}

pipelineEmitWithNotification(hint, node);

}

function setSourceFile(sourceFile: SourceFile) {

currentSourceFile = sourceFile;

comments.setSourceFile(sourceFile);

if (onSetSourceFile) {

onSetSourceFile(sourceFile);

}

}

function setWriter(output: EmitTextWriter | undefined) {

writer = output;

comments.setWriter(output);

}

function reset() {

nodeIdToGeneratedName = [];

autoGeneratedIdToGeneratedName = [];

generatedNames = createMap<true>();

tempFlagsStack = [];

tempFlags = TempFlags.Auto;

reservedNamesStack = [];

comments.reset();

setWriter(/*output*/ undefined);

}

// TODO: Should this just be `emit`?

// See https://github.com/Microsoft/TypeScript/pull/18284#discussion_r137611034

function emitIfPresent(node: Node | undefined) {

if (node) {

emit(node);

}

}

function emit(node: Node) {

pipelineEmitWithNotification(EmitHint.Unspecified, node);

}

function emitIdentifierName(node: Identifier) {

pipelineEmitWithNotification(EmitHint.IdentifierName, node);

}

function emitExpression(node: Expression) {

pipelineEmitWithNotification(EmitHint.Expression, node);

}

function pipelineEmitWithNotification(hint: EmitHint, node: Node) {

if (onEmitNode) {

onEmitNode(hint, node, pipelineEmitWithComments);

}

else {

pipelineEmitWithComments(hint, node);

}

}

function pipelineEmitWithComments(hint: EmitHint, node: Node) {

node = trySubstituteNode(hint, node);

if (emitNodeWithComments && hint !== EmitHint.SourceFile) {

emitNodeWithComments(hint, node, pipelineEmitWithSourceMap);

}

else {

pipelineEmitWithSourceMap(hint, node);

}

}

function pipelineEmitWithSourceMap(hint: EmitHint, node: Node) {

if (onEmitSourceMapOfNode && hint !== EmitHint.SourceFile && hint !== EmitHint.IdentifierName) {

onEmitSourceMapOfNode(hint, node, pipelineEmitWithHint);

}

else {

pipelineEmitWithHint(hint, node);

}

}

function pipelineEmitWithHint(hint: EmitHint, node: Node): void {

switch (hint) {

case EmitHint.SourceFile: return pipelineEmitSourceFile(node);

case EmitHint.IdentifierName: return pipelineEmitIdentifierName(node);

case EmitHint.Expression: return pipelineEmitExpression(node);

case EmitHint.MappedTypeParameter: return emitMappedTypeParameter(cast(node, isTypeParameterDeclaration));

case EmitHint.Unspecified: return pipelineEmitUnspecified(node);

}

}

function pipelineEmitSourceFile(node: Node): void {

Debug.assertNode(node, isSourceFile);

emitSourceFile(<SourceFile>node);

}

function pipelineEmitIdentifierName(node: Node): void {

Debug.assertNode(node, isIdentifier);

emitIdentifier(<Identifier>node);

}

function emitMappedTypeParameter(node: TypeParameterDeclaration): void {

emit(node.name);

writeSpace();

writeKeyword("in");

writeSpace();

emit(node.constraint);

}

function pipelineEmitUnspecified(node: Node): void {

const kind = node.kind;

// Reserved words

// Strict mode reserved words

// Contextual keywords

if (isKeyword(kind)) {

writeTokenNode(node, writeKeyword);

return;

}

switch (kind) {

// Pseudo-literals

case SyntaxKind.TemplateHead:

case SyntaxKind.TemplateMiddle:

case SyntaxKind.TemplateTail:

return emitLiteral(<LiteralExpression>node);

// Identifiers

case SyntaxKind.Identifier:

return emitIdentifier(<Identifier>node);

// Parse tree nodes

// Names

case SyntaxKind.QualifiedName:

return emitQualifiedName(<QualifiedName>node);

case SyntaxKind.ComputedPropertyName:

return emitComputedPropertyName(<ComputedPropertyName>node);

// Signature elements

case SyntaxKind.TypeParameter:

return emitTypeParameter(<TypeParameterDeclaration>node);

case SyntaxKind.Parameter:

return emitParameter(<ParameterDeclaration>node);

case SyntaxKind.Decorator:

return emitDecorator(<Decorator>node);

// Type members

case SyntaxKind.PropertySignature:

return emitPropertySignature(<PropertySignature>node);

case SyntaxKind.PropertyDeclaration:

return emitPropertyDeclaration(<PropertyDeclaration>node);

case SyntaxKind.MethodSignature:

return emitMethodSignature(<MethodSignature>node);

case SyntaxKind.MethodDeclaration:

return emitMethodDeclaration(<MethodDeclaration>node);

case SyntaxKind.Constructor:

return emitConstructor(<ConstructorDeclaration>node);

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

return emitAccessorDeclaration(<AccessorDeclaration>node);

case SyntaxKind.CallSignature:

return emitCallSignature(<CallSignatureDeclaration>node);

case SyntaxKind.ConstructSignature:

return emitConstructSignature(<ConstructSignatureDeclaration>node);

case SyntaxKind.IndexSignature:

return emitIndexSignature(<IndexSignatureDeclaration>node);

// Types

case SyntaxKind.TypePredicate:

return emitTypePredicate(<TypePredicateNode>node);

case SyntaxKind.TypeReference:

return emitTypeReference(<TypeReferenceNode>node);

case SyntaxKind.FunctionType:

return emitFunctionType(<FunctionTypeNode>node);

case SyntaxKind.JSDocFunctionType:

return emitJSDocFunctionType(node as JSDocFunctionType);

case SyntaxKind.ConstructorType:

return emitConstructorType(<ConstructorTypeNode>node);

case SyntaxKind.TypeQuery:

return emitTypeQuery(<TypeQueryNode>node);

case SyntaxKind.TypeLiteral:

return emitTypeLiteral(<TypeLiteralNode>node);

case SyntaxKind.ArrayType:

return emitArrayType(<ArrayTypeNode>node);

case SyntaxKind.TupleType:

return emitTupleType(<TupleTypeNode>node);

case SyntaxKind.UnionType:

return emitUnionType(<UnionTypeNode>node);

case SyntaxKind.IntersectionType:

return emitIntersectionType(<IntersectionTypeNode>node);

case SyntaxKind.ConditionalType:

return emitConditionalType(<ConditionalTypeNode>node);

case SyntaxKind.InferType:

return emitInferType(<InferTypeNode>node);

case SyntaxKind.ParenthesizedType:

return emitParenthesizedType(<ParenthesizedTypeNode>node);

case SyntaxKind.ExpressionWithTypeArguments:

return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);

case SyntaxKind.ThisType:

return emitThisType();

case SyntaxKind.TypeOperator:

return emitTypeOperator(<TypeOperatorNode>node);

case SyntaxKind.IndexedAccessType:

return emitIndexedAccessType(<IndexedAccessTypeNode>node);

case SyntaxKind.MappedType:

return emitMappedType(<MappedTypeNode>node);

case SyntaxKind.LiteralType:

return emitLiteralType(<LiteralTypeNode>node);

case SyntaxKind.JSDocAllType:

write("*");

return;

case SyntaxKind.JSDocUnknownType:

write("?");

return;

case SyntaxKind.JSDocNullableType:

return emitJSDocNullableType(node as JSDocNullableType);

case SyntaxKind.JSDocNonNullableType:

return emitJSDocNonNullableType(node as JSDocNonNullableType);

case SyntaxKind.JSDocOptionalType:

return emitJSDocOptionalType(node as JSDocOptionalType);

case SyntaxKind.JSDocVariadicType:

return emitJSDocVariadicType(node as JSDocVariadicType);

// Binding patterns

case SyntaxKind.ObjectBindingPattern:

return emitObjectBindingPattern(<ObjectBindingPattern>node);

case SyntaxKind.ArrayBindingPattern:

return emitArrayBindingPattern(<ArrayBindingPattern>node);

case SyntaxKind.BindingElement:

return emitBindingElement(<BindingElement>node);

// Misc

case SyntaxKind.TemplateSpan:

return emitTemplateSpan(<TemplateSpan>node);

case SyntaxKind.SemicolonClassElement:

return emitSemicolonClassElement();

// Statements

case SyntaxKind.Block:

return emitBlock(<Block>node);

case SyntaxKind.VariableStatement:

return emitVariableStatement(<VariableStatement>node);

case SyntaxKind.EmptyStatement:

return emitEmptyStatement();

case SyntaxKind.ExpressionStatement:

return emitExpressionStatement(<ExpressionStatement>node);

case SyntaxKind.IfStatement:

return emitIfStatement(<IfStatement>node);

case SyntaxKind.DoStatement:

return emitDoStatement(<DoStatement>node);

case SyntaxKind.WhileStatement:

return emitWhileStatement(<WhileStatement>node);

case SyntaxKind.ForStatement:

return emitForStatement(<ForStatement>node);

case SyntaxKind.ForInStatement:

return emitForInStatement(<ForInStatement>node);

case SyntaxKind.ForOfStatement:

return emitForOfStatement(<ForOfStatement>node);

case SyntaxKind.ContinueStatement:

return emitContinueStatement(<ContinueStatement>node);

case SyntaxKind.BreakStatement:

return emitBreakStatement(<BreakStatement>node);

case SyntaxKind.ReturnStatement:

return emitReturnStatement(<ReturnStatement>node);

case SyntaxKind.WithStatement:

return emitWithStatement(<WithStatement>node);

case SyntaxKind.SwitchStatement:

return emitSwitchStatement(<SwitchStatement>node);

case SyntaxKind.LabeledStatement:

return emitLabeledStatement(<LabeledStatement>node);

case SyntaxKind.ThrowStatement:

return emitThrowStatement(<ThrowStatement>node);

case SyntaxKind.TryStatement:

return emitTryStatement(<TryStatement>node);

case SyntaxKind.DebuggerStatement:

return emitDebuggerStatement(<DebuggerStatement>node);

// Declarations

case SyntaxKind.VariableDeclaration:

return emitVariableDeclaration(<VariableDeclaration>node);

case SyntaxKind.VariableDeclarationList:

return emitVariableDeclarationList(<VariableDeclarationList>node);

case SyntaxKind.FunctionDeclaration:

return emitFunctionDeclaration(<FunctionDeclaration>node);

case SyntaxKind.ClassDeclaration:

return emitClassDeclaration(<ClassDeclaration>node);

case SyntaxKind.InterfaceDeclaration:

return emitInterfaceDeclaration(<InterfaceDeclaration>node);

case SyntaxKind.TypeAliasDeclaration:

return emitTypeAliasDeclaration(<TypeAliasDeclaration>node);

case SyntaxKind.EnumDeclaration:

return emitEnumDeclaration(<EnumDeclaration>node);

case SyntaxKind.ModuleDeclaration:

return emitModuleDeclaration(<ModuleDeclaration>node);

case SyntaxKind.ModuleBlock:

return emitModuleBlock(<ModuleBlock>node);

case SyntaxKind.CaseBlock:

return emitCaseBlock(<CaseBlock>node);

case SyntaxKind.NamespaceExportDeclaration:

return emitNamespaceExportDeclaration(<NamespaceExportDeclaration>node);

case SyntaxKind.ImportEqualsDeclaration:

return emitImportEqualsDeclaration(<ImportEqualsDeclaration>node);

case SyntaxKind.ImportDeclaration:

return emitImportDeclaration(<ImportDeclaration>node);

case SyntaxKind.ImportClause:

return emitImportClause(<ImportClause>node);

case SyntaxKind.NamespaceImport:

return emitNamespaceImport(<NamespaceImport>node);

case SyntaxKind.NamedImports:

return emitNamedImports(<NamedImports>node);

case SyntaxKind.ImportSpecifier:

return emitImportSpecifier(<ImportSpecifier>node);

case SyntaxKind.ExportAssignment:

return emitExportAssignment(<ExportAssignment>node);

case SyntaxKind.ExportDeclaration:

return emitExportDeclaration(<ExportDeclaration>node);

case SyntaxKind.NamedExports:

return emitNamedExports(<NamedExports>node);

case SyntaxKind.ExportSpecifier:

return emitExportSpecifier(<ExportSpecifier>node);

case SyntaxKind.MissingDeclaration:

return;

// Module references

case SyntaxKind.ExternalModuleReference:

return emitExternalModuleReference(<ExternalModuleReference>node);

// JSX (non-expression)

case SyntaxKind.JsxText:

return emitJsxText(<JsxText>node);

case SyntaxKind.JsxOpeningElement:

case SyntaxKind.JsxOpeningFragment:

return emitJsxOpeningElementOrFragment(<JsxOpeningElement>node);

case SyntaxKind.JsxClosingElement:

case SyntaxKind.JsxClosingFragment:

return emitJsxClosingElementOrFragment(<JsxClosingElement>node);

case SyntaxKind.JsxAttribute:

return emitJsxAttribute(<JsxAttribute>node);

case SyntaxKind.JsxAttributes:

return emitJsxAttributes(<JsxAttributes>node);

case SyntaxKind.JsxSpreadAttribute:

return emitJsxSpreadAttribute(<JsxSpreadAttribute>node);

case SyntaxKind.JsxExpression:

return emitJsxExpression(<JsxExpression>node);

// Clauses

case SyntaxKind.CaseClause:

return emitCaseClause(<CaseClause>node);

case SyntaxKind.DefaultClause:

return emitDefaultClause(<DefaultClause>node);

case SyntaxKind.HeritageClause:

return emitHeritageClause(<HeritageClause>node);

case SyntaxKind.CatchClause:

return emitCatchClause(<CatchClause>node);

// Property assignments

case SyntaxKind.PropertyAssignment:

return emitPropertyAssignment(<PropertyAssignment>node);

case SyntaxKind.ShorthandPropertyAssignment:

return emitShorthandPropertyAssignment(<ShorthandPropertyAssignment>node);

case SyntaxKind.SpreadAssignment:

return emitSpreadAssignment(node as SpreadAssignment);

// Enum

case SyntaxKind.EnumMember:

return emitEnumMember(<EnumMember>node);

// JSDoc nodes (ignored)

// Transformation nodes (ignored)

}

// If the node is an expression, try to emit it as an expression with

// substitution.

if (isExpression(node)) {

return pipelineEmitExpression(trySubstituteNode(EmitHint.Expression, node));

}

if (isToken(node)) {

writeTokenNode(node, writePunctuation);

return;

}

}

function pipelineEmitExpression(node: Node): void {

const kind = node.kind;

switch (kind) {

// Literals

case SyntaxKind.NumericLiteral:

return emitNumericLiteral(<NumericLiteral>node);

case SyntaxKind.StringLiteral:

case SyntaxKind.RegularExpressionLiteral:

case SyntaxKind.NoSubstitutionTemplateLiteral:

return emitLiteral(<LiteralExpression>node);

// Identifiers

case SyntaxKind.Identifier:

return emitIdentifier(<Identifier>node);

// Reserved words

case SyntaxKind.FalseKeyword:

case SyntaxKind.NullKeyword:

case SyntaxKind.SuperKeyword:

case SyntaxKind.TrueKeyword:

case SyntaxKind.ThisKeyword:

case SyntaxKind.ImportKeyword:

writeTokenNode(node, writeKeyword);

return;

// Expressions

case SyntaxKind.ArrayLiteralExpression:

return emitArrayLiteralExpression(<ArrayLiteralExpression>node);

case SyntaxKind.ObjectLiteralExpression:

return emitObjectLiteralExpression(<ObjectLiteralExpression>node);

case SyntaxKind.PropertyAccessExpression:

return emitPropertyAccessExpression(<PropertyAccessExpression>node);

case SyntaxKind.ElementAccessExpression:

return emitElementAccessExpression(<ElementAccessExpression>node);

case SyntaxKind.CallExpression:

return emitCallExpression(<CallExpression>node);

case SyntaxKind.NewExpression:

return emitNewExpression(<NewExpression>node);

case SyntaxKind.TaggedTemplateExpression:

return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);

case SyntaxKind.TypeAssertionExpression:

return emitTypeAssertionExpression(<TypeAssertion>node);

case SyntaxKind.ParenthesizedExpression:

return emitParenthesizedExpression(<ParenthesizedExpression>node);

case SyntaxKind.FunctionExpression:

return emitFunctionExpression(<FunctionExpression>node);

case SyntaxKind.ArrowFunction:

return emitArrowFunction(<ArrowFunction>node);

case SyntaxKind.DeleteExpression:

return emitDeleteExpression(<DeleteExpression>node);

case SyntaxKind.TypeOfExpression:

return emitTypeOfExpression(<TypeOfExpression>node);

case SyntaxKind.VoidExpression:

return emitVoidExpression(<VoidExpression>node);

case SyntaxKind.AwaitExpression:

return emitAwaitExpression(<AwaitExpression>node);

case SyntaxKind.PrefixUnaryExpression:

return emitPrefixUnaryExpression(<PrefixUnaryExpression>node);

case SyntaxKind.PostfixUnaryExpression:

return emitPostfixUnaryExpression(<PostfixUnaryExpression>node);

case SyntaxKind.BinaryExpression:

return emitBinaryExpression(<BinaryExpression>node);

case SyntaxKind.ConditionalExpression:

return emitConditionalExpression(<ConditionalExpression>node);

case SyntaxKind.TemplateExpression:

return emitTemplateExpression(<TemplateExpression>node);

case SyntaxKind.YieldExpression:

return emitYieldExpression(<YieldExpression>node);

case SyntaxKind.SpreadElement:

return emitSpreadExpression(<SpreadElement>node);

case SyntaxKind.ClassExpression:

return emitClassExpression(<ClassExpression>node);

case SyntaxKind.OmittedExpression:

return;

case SyntaxKind.AsExpression:

return emitAsExpression(<AsExpression>node);

case SyntaxKind.NonNullExpression:

return emitNonNullExpression(<NonNullExpression>node);

case SyntaxKind.MetaProperty:

return emitMetaProperty(<MetaProperty>node);

// JSX

case SyntaxKind.JsxElement:

return emitJsxElement(<JsxElement>node);

case SyntaxKind.JsxSelfClosingElement:

return emitJsxSelfClosingElement(<JsxSelfClosingElement>node);

case SyntaxKind.JsxFragment:

return emitJsxFragment(<JsxFragment>node);

// Transformation nodes

case SyntaxKind.PartiallyEmittedExpression:

return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);

case SyntaxKind.CommaListExpression:

return emitCommaList(<CommaListExpression>node);

}

}

function trySubstituteNode(hint: EmitHint, node: Node) {

return node && substituteNode && substituteNode(hint, node) || node;

}

function emitHelpersIndirect(node: Node) {

if (onEmitHelpers) {

onEmitHelpers(node, writeLines);

}

}

//

// Literals/Pseudo-literals

//

// SyntaxKind.NumericLiteral

function emitNumericLiteral(node: NumericLiteral) {

emitLiteral(node);

}

// SyntaxKind.StringLiteral

// SyntaxKind.RegularExpressionLiteral

// SyntaxKind.NoSubstitutionTemplateLiteral

// SyntaxKind.TemplateHead

// SyntaxKind.TemplateMiddle

// SyntaxKind.TemplateTail

function emitLiteral(node: LiteralLikeNode) {

const text = getLiteralTextOfNode(node);

if ((printerOptions.sourceMap || printerOptions.inlineSourceMap)

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

writeLiteral(text);

}

else {

// Quick info expects all literals to be called with writeStringLiteral, as there's no specific type for numberLiterals

writeStringLiteral(text);

}

}

//

// Identifiers

//

function emitIdentifier(node: Identifier) {

const writeText = node.symbol ? writeSymbol : write;

writeText(getTextOfNode(node, /*includeTrivia*/ false), node.symbol);

emitList(node, node.typeArguments, ListFormat.TypeParameters); // Call emitList directly since it could be an array of TypeParameterDeclarations _or_ type arguments

}

//

// Names

//

function emitQualifiedName(node: QualifiedName) {

emitEntityName(node.left);

writePunctuation(".");

emit(node.right);

}

function emitEntityName(node: EntityName) {

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

emitExpression(<Identifier>node);

}

else {

emit(node);

}

}

function emitComputedPropertyName(node: ComputedPropertyName) {

writePunctuation("[");

emitExpression(node.expression);

writePunctuation("]");

}

//

// Signature elements

//

function emitTypeParameter(node: TypeParameterDeclaration) {

emit(node.name);

if (node.constraint) {

writeSpace();

writeKeyword("extends");

writeSpace();

emit(node.constraint);

}

if (node.default) {

writeSpace();

writeOperator("=");

writeSpace();

emit(node.default);

}

}

function emitParameter(node: ParameterDeclaration) {

emitDecorators(node, node.decorators);

emitModifiers(node, node.modifiers);

emitIfPresent(node.dotDotDotToken);

if (node.name) {

emitNodeWithWriter(node.name, writeParameter);

}

emitIfPresent(node.questionToken);

if (node.parent && node.parent.kind === SyntaxKind.JSDocFunctionType && !node.name) {

emit(node.type);

}

else {

emitTypeAnnotation(node.type);

}