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 transformers = emitOnlyDtsFiles ? [] : getTransformers(compilerOptions);

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 = transformFiles(resolver, host, sourceFiles, transformers);

// Create a printer to print the nodes

const printer = createPrinter(compilerOptions, {

// resolver hooks

hasGlobalName: resolver.hasGlobalName,

// transform hooks

onEmitNode: transform.emitNodeWithNotification,

onSubstituteNode: transform.emitNodeWithSubstitution,

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

for (const sourceFile of sourceFiles) {

disposeEmitNodes(sourceFile);

}

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

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.reset();

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 || (sourceFile && 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;

}

const {

hasGlobalName,

onEmitSourceMapOfNode,

onEmitSourceMapOfToken,

onEmitSourceMapOfPosition,

onEmitNode,

onEmitHelpers,

onSetSourceFile,

onSubstituteNode,

} = handlers;

const newLine = getNewLineCharacter(printerOptions);

const languageVersion = getEmitScriptTarget(printerOptions);

const comments = createCommentWriter(printerOptions, onEmitSourceMapOfPosition);

const {

emitNodeWithComments,

emitBodyWithDetachedComments,

emitTrailingCommentsOfPosition,

emitLeadingCommentsOfPosition,

} = comments;

let currentSourceFile: SourceFile;

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<string>; // 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 writer: EmitTextWriter;

let ownWriter: EmitTextWriter;

reset();

return {

// public API

printNode,

printFile,

printBundle,

// internal API

writeNode,

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 printBundle(bundle: Bundle): string {

writeBundle(bundle, beginPrint());

return endPrint();

}

function printFile(sourceFile: SourceFile): string {

writeFile(sourceFile, beginPrint());

return endPrint();

}

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

const previousWriter = writer;

setWriter(output);

print(hint, node, sourceFile);

reset();

writer = previousWriter;

}

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

const previousWriter = writer;

setWriter(output);

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

print(EmitHint.SourceFile, sourceFile, sourceFile);

reset();

writer = previousWriter;

}

function beginPrint() {

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

}

function endPrint() {

const text = ownWriter.getText();

ownWriter.reset();

return text;

}

function print(hint: EmitHint, node: Node, sourceFile: 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<string>();

tempFlagsStack = [];

tempFlags = TempFlags.Auto;

comments.reset();

setWriter(/*output*/ undefined);

}

function emit(node: Node, hint = EmitHint.Unspecified) {

pipelineEmitWithNotification(hint, 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) {

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

}

else {

pipelineEmitWithSubstitution(hint, node);

}

}

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

if (onSubstituteNode) {

onSubstituteNode(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.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 pipelineEmitUnspecified(node: Node): void {

const kind = node.kind;

// Reserved words

// Strict mode reserved words

// Contextual keywords

if (isKeyword(kind)) {

writeTokenText(kind);

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

// 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.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:

return emitJsxOpeningElement(<JsxOpeningElement>node);

case SyntaxKind.JsxClosingElement:

return emitJsxClosingElement(<JsxClosingElement>node);

case SyntaxKind.JsxAttribute:

return emitJsxAttribute(<JsxAttribute>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 pipelineEmitWithSubstitution(EmitHint.Expression, node);

}

}

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:

writeTokenText(kind);

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

// Transformation nodes

case SyntaxKind.PartiallyEmittedExpression:

return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);

}

}

function emitBodyIndirect(node: Node, elements: NodeArray<Node>, emitCallback: (node: Node) => void): void {

if (emitBodyWithDetachedComments) {

emitBodyWithDetachedComments(node, elements, emitCallback);

}

else {

emitCallback(node);

}

}

function emitHelpersIndirect(node: Node) {

if (onEmitHelpers) {

onEmitHelpers(node, writeLines);

}

}

//

// Literals/Pseudo-literals

//

// SyntaxKind.NumericLiteral

function emitNumericLiteral(node: NumericLiteral) {

emitLiteral(node);

if (node.trailingComment) {

write(` /*${node.trailingComment}*/`);

}

}

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

writer.writeLiteral(text);

}

else {

write(text);

}

}

//

// Identifiers

//

function emitIdentifier(node: Identifier) {

write(getTextOfNode(node, /*includeTrivia*/ false));

}

//

// Names

//

function emitQualifiedName(node: QualifiedName) {

emitEntityName(node.left);

write(".");

emit(node.right);

}

function emitEntityName(node: EntityName) {

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

emitExpression(<Identifier>node);

}

else {

emit(node);

}

}

function emitComputedPropertyName(node: ComputedPropertyName) {

write("[");

emitExpression(node.expression);

write("]");

}

//

// Signature elements

//

function emitTypeParameter(node: TypeParameterDeclaration) {

emit(node.name);

emitWithPrefix(" extends ", node.constraint);

}

function emitParameter(node: ParameterDeclaration) {

emitDecorators(node, node.decorators);

emitModifiers(node, node.modifiers);

writeIfPresent(node.dotDotDotToken, "...");

emit(node.name);

writeIfPresent(node.questionToken, "?");

emitExpressionWithPrefix(" = ", node.initializer);

emitWithPrefix(": ", node.type);

}

function emitDecorator(decorator: Decorator) {

write("@");

emitExpression(decorator.expression);

}

//

// Type members

//

function emitPropertySignature(node: PropertySignature) {