namespace ts {

const infoExtension = ".tsbundleinfo";

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) => T,

sourceFilesOrTargetSourceFile?: ReadonlyArray<SourceFile> | SourceFile,

emitOnlyDtsFiles = false) {

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

const options = host.getCompilerOptions();

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

if (sourceFiles.length) {

const bundle = createBundle(sourceFiles, host.getPrependNodes());

const result = action(getOutputPathsFor(bundle, host, emitOnlyDtsFiles), bundle);

if (result) {

return result;

}

}

}

else {

for (const sourceFile of sourceFiles) {

const result = action(getOutputPathsFor(sourceFile, host, emitOnlyDtsFiles), sourceFile);

if (result) {

return result;

}

}

}

}

/*@internal*/

export function getOutputPathsFor(sourceFile: SourceFile | Bundle, host: EmitHost, forceDtsPaths: boolean): EmitFileNames {

const options = host.getCompilerOptions();

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

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

const sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);

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

const declarationMapPath = getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;

const bundleInfoPath = options.references && jsFilePath ? (removeFileExtension(jsFilePath) + infoExtension) : undefined;

return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, bundleInfoPath };

}

else {

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

const sourceMapFilePath = isJsonSourceFile(sourceFile) ? undefined : getSourceMapFilePath(jsFilePath, options);

// For legacy reasons (ie, we have baselines capturing the behavior), js files don't report a .d.ts output path - this would only matter if `declaration` and `allowJs` were both on, which is currently an error

const isJs = isSourceFileJavaScript(sourceFile);

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

const declarationMapPath = getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;

return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, bundleInfoPath: undefined };

}

}

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

return (options.sourceMap && !options.inlineSourceMap) ? jsFilePath + ".map" : undefined;

}

function createDefaultBundleInfo(): BundleInfo {

return {

originalOffset: -1,

totalLength: -1

};

}

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

/* @internal */

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

if (isJsonSourceFile(sourceFile)) {

return Extension.Json;

}

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;

}

/*@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<Bundle | SourceFile>[], declarationTransformers?: TransformerFactory<Bundle | SourceFile>[]): EmitResult {

const compilerOptions = host.getCompilerOptions();

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

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

const emitterDiagnostics = createDiagnosticCollection();

const newLine = host.getNewLine();

const writer = createTextWriter(newLine);

const sourceMap = createSourceMapWriter(host, writer);

const declarationSourceMap = createSourceMapWriter(host, writer, {

sourceMap: compilerOptions.declarationMap,

sourceRoot: compilerOptions.sourceRoot,

mapRoot: compilerOptions.mapRoot,

extendedDiagnostics: compilerOptions.extendedDiagnostics,

// Explicitly do not passthru either `inline` option

});

let bundleInfo: BundleInfo = createDefaultBundleInfo();

let emitSkipped = false;

// Emit each output file

performance.mark("beforePrint");

forEachEmittedFile(host, emitSourceFileOrBundle, getSourceFilesToEmit(host, targetSourceFile), emitOnlyDtsFiles);

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

return {

emitSkipped,

diagnostics: emitterDiagnostics.getDiagnostics(),

emittedFiles: emittedFilesList,

sourceMaps: sourceMapDataList,

};

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

emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, bundleInfoPath);

emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath);

if (!emitSkipped && emittedFilesList) {

if (!emitOnlyDtsFiles) {

emittedFilesList.push(jsFilePath);

}

if (sourceMapFilePath) {

emittedFilesList.push(sourceMapFilePath);

}

if (declarationFilePath) {

emittedFilesList.push(declarationFilePath);

}

if (bundleInfoPath) {

emittedFilesList.push(bundleInfoPath);

}

}

}

function emitJsFileOrBundle(sourceFileOrBundle: SourceFile | Bundle, jsFilePath: string, sourceMapFilePath: string | undefined, bundleInfoPath: string | undefined) {

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

emitSkipped = true;

return;

}

if (emitOnlyDtsFiles) {

return;

}

// Transform the source files

const transform = transformNodes(resolver, host, compilerOptions, [sourceFileOrBundle], transformers!, /*allowDtsFiles*/ false);

// Create a printer to print the nodes

const printer = createPrinter({ ...compilerOptions, noEmitHelpers: compilerOptions.noEmitHelpers } as PrinterOptions, {

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

onSetSourceFile: setSourceFile,

});

Debug.assert(transform.transformed.length === 1, "Should only see one output from the transform");

printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform.transformed[0], bundleInfoPath, printer, sourceMap);

// Clean up emit nodes on parse tree

transform.dispose();

}

function emitDeclarationFileOrBundle(sourceFileOrBundle: SourceFile | Bundle, declarationFilePath: string | undefined, declarationMapPath: string | undefined) {

if (!(declarationFilePath && !isInJavaScriptFile(sourceFileOrBundle))) {

return;

}

const sourceFiles = isSourceFile(sourceFileOrBundle) ? [sourceFileOrBundle] : sourceFileOrBundle.sourceFiles;

// Setup and perform the transformation to retrieve declarations from the input files

const nonJsFiles = filter(sourceFiles, isSourceFileNotJavaScript);

const inputListOrBundle = (compilerOptions.outFile || compilerOptions.out) ? [createBundle(nonJsFiles, !isSourceFile(sourceFileOrBundle) ? sourceFileOrBundle.prepends : undefined)] : nonJsFiles;

const declarationTransform = transformNodes(resolver, host, compilerOptions, inputListOrBundle, concatenate([transformDeclarations], declarationTransformers), /*allowDtsFiles*/ false);

if (length(declarationTransform.diagnostics)) {

for (const diagnostic of declarationTransform.diagnostics!) {

emitterDiagnostics.add(diagnostic);

}

}

const declarationPrinter = createPrinter({ ...compilerOptions, onlyPrintJsDocStyle: true, noEmitHelpers: true } as PrinterOptions, {

// resolver hooks

hasGlobalName: resolver.hasGlobalName,

// sourcemap hooks

onEmitSourceMapOfNode: declarationSourceMap.emitNodeWithSourceMap,

onEmitSourceMapOfToken: declarationSourceMap.emitTokenWithSourceMap,

onEmitSourceMapOfPosition: declarationSourceMap.emitPos,

onSetSourceFile: setSourceFileForDeclarationSourceMaps,

// transform hooks

onEmitNode: declarationTransform.emitNodeWithNotification,

substituteNode: declarationTransform.substituteNode,

});

const declBlocked = (!!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length) || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit;

emitSkipped = emitSkipped || declBlocked;

if (!declBlocked || emitOnlyDtsFiles) {

Debug.assert(declarationTransform.transformed.length === 1, "Should only see one output from the decl transform");

printSourceFileOrBundle(declarationFilePath, declarationMapPath, declarationTransform.transformed[0], /* bundleInfopath*/ undefined, declarationPrinter, declarationSourceMap);

}

declarationTransform.dispose();

}

function printSourceFileOrBundle(jsFilePath: string, sourceMapFilePath: string | undefined, sourceFileOrBundle: SourceFile | Bundle, bundleInfoPath: string | undefined, printer: Printer, mapRecorder: SourceMapWriter) {

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

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

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

mapRecorder.initialize(jsFilePath, sourceMapFilePath || "", sourceFileOrBundle, sourceMapDataList);

if (bundle) {

printer.writeBundle(bundle, writer, bundleInfo);

}

else {

printer.writeFile(sourceFile!, writer);

}

writer.writeLine();

const sourceMappingURL = mapRecorder.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 (sourceMapFilePath) {

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

}

// Write the output file

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

// Write bundled offset information if applicable

if (bundleInfoPath) {

bundleInfo.totalLength = writer.getTextPos();

writeFile(host, emitterDiagnostics, bundleInfoPath, JSON.stringify(bundleInfo, undefined, 2), /*writeByteOrderMark*/ false);

}

// Reset state

mapRecorder.reset();

writer.clear();

bundleInfo = createDefaultBundleInfo();

}

function setSourceFile(node: SourceFile) {

sourceMap.setSourceFile(node);

}

function setSourceFileForDeclarationSourceMaps(node: SourceFile) {

declarationSourceMap.setSourceFile(node);

}

}

const enum PipelinePhase {

Notification,

Comments,

SourceMaps,

Emit

}

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

const {

hasGlobalName,

onEmitSourceMapOfNode,

onEmitSourceMapOfToken,

onEmitSourceMapOfPosition,

onEmitNode,

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;

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

const moduleKind = getEmitModuleKind(printerOptions);

const bundledHelpers = createMap<boolean>();

let isOwnFileEmit: boolean;

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

case SyntaxKind.UnparsedSource: return printUnparsedSource(<UnparsedSource>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();

}

function printUnparsedSource(unparsed: UnparsedSource): string {

writeUnparsedSource(unparsed, 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, bundleInfo?: BundleInfo) {

isOwnFileEmit = false;

const previousWriter = writer;

setWriter(output);

emitShebangIfNeeded(bundle);

emitPrologueDirectivesIfNeeded(bundle);

emitHelpers(bundle);

emitSyntheticTripleSlashReferencesIfNeeded(bundle);

for (const prepend of bundle.prepends) {

print(EmitHint.Unspecified, prepend, /*sourceFile*/ undefined);

writeLine();

}

if (bundleInfo) {

bundleInfo.originalOffset = writer.getTextPos();

}

for (const sourceFile of bundle.sourceFiles) {

print(EmitHint.SourceFile, sourceFile, sourceFile);

}

reset();

writer = previousWriter;

}

function writeUnparsedSource(unparsed: UnparsedSource, output: EmitTextWriter) {

const previousWriter = writer;

setWriter(output);

print(EmitHint.Unspecified, unparsed, /*sourceFile*/ undefined);

reset();

writer = previousWriter;

}

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

isOwnFileEmit = true;

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

}

const pipelinePhase = getPipelinePhase(PipelinePhase.Notification, hint);

pipelinePhase(hint, node);

}

function setSourceFile(sourceFile: SourceFile) {

currentSourceFile = sourceFile;

comments.setSourceFile(sourceFile);

if (onSetSourceFile) {

onSetSourceFile(sourceFile);

}

}

function setWriter(output: EmitTextWriter | undefined) {

writer = output!; // TODO: GH#18217

comments.setWriter(output!);

}

function reset() {

nodeIdToGeneratedName = [];

autoGeneratedIdToGeneratedName = [];

generatedNames = createMap<true>();

tempFlagsStack = [];

tempFlags = TempFlags.Auto;

reservedNamesStack = [];

comments.reset();

setWriter(/*output*/ undefined);

}

function emit(node: Node | undefined) {

if (!node) return;

const pipelinePhase = getPipelinePhase(PipelinePhase.Notification, EmitHint.Unspecified);

pipelinePhase(EmitHint.Unspecified, node);

}

function emitIdentifierName(node: Identifier | undefined) {

if (!node) return;

const pipelinePhase = getPipelinePhase(PipelinePhase.Notification, EmitHint.IdentifierName);

pipelinePhase(EmitHint.IdentifierName, node);

}

function emitExpression(node: Expression | undefined) {

if (!node) return;

const pipelinePhase = getPipelinePhase(PipelinePhase.Notification, EmitHint.Expression);

pipelinePhase(EmitHint.Expression, node);

}

function getPipelinePhase(phase: PipelinePhase, hint: EmitHint) {

switch (phase) {

case PipelinePhase.Notification:

if (onEmitNode) {

return pipelineEmitWithNotification;

}

// falls through

case PipelinePhase.Comments:

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

return pipelineEmitWithComments;

}

return pipelineEmitWithoutComments;

case PipelinePhase.SourceMaps:

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

return pipelineEmitWithSourceMap;

}

// falls through

case PipelinePhase.Emit:

return pipelineEmitWithHint;

default:

return Debug.assertNever(phase, `Unexpected value for PipelinePhase: ${phase}`);

}

}

function getNextPipelinePhase(currentPhase: PipelinePhase, hint: EmitHint) {

return getPipelinePhase(currentPhase + 1, hint);

}

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

Debug.assertDefined(onEmitNode)(hint, node, getNextPipelinePhase(PipelinePhase.Notification, hint));

}

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

Debug.assertDefined(emitNodeWithComments);

Debug.assert(hint !== EmitHint.SourceFile);

emitNodeWithComments(hint, trySubstituteNode(hint, node), getNextPipelinePhase(PipelinePhase.Comments, hint));

}

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

const pipelinePhase = getNextPipelinePhase(PipelinePhase.Comments, hint);

pipelinePhase(hint, trySubstituteNode(hint, node));

}

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

Debug.assert(hint !== EmitHint.SourceFile && hint !== EmitHint.IdentifierName);

Debug.assertDefined(onEmitSourceMapOfNode)(hint, node, pipelineEmitWithHint);

}

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

if (hint === EmitHint.SourceFile) return emitSourceFile(cast(node, isSourceFile));

if (hint === EmitHint.IdentifierName) return emitIdentifier(cast(node, isIdentifier));

if (hint === EmitHint.MappedTypeParameter) return emitMappedTypeParameter(cast(node, isTypeParameterDeclaration));

if (hint === EmitHint.Unspecified) {

if (isKeyword(node.kind)) return writeTokenNode(node, writeKeyword);

switch (node.kind) {

// Pseudo-literals

case SyntaxKind.TemplateHead:

case SyntaxKind.TemplateMiddle:

case SyntaxKind.TemplateTail:

return emitLiteral(<LiteralExpression>node);

case SyntaxKind.UnparsedSource:

return emitUnparsedSource(<UnparsedSource>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.ImportType:

return emitImportTypeNode(<ImportTypeNode>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 (isExpression(node)) {

hint = EmitHint.Expression;

node = trySubstituteNode(EmitHint.Expression, node);

}

else if (isToken(node)) {

return writeTokenNode(node, writePunctuation);

}

}

if (hint === EmitHint.Expression) {

switch (node.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 emitMappedTypeParameter(node: TypeParameterDeclaration): void {

emit(node.name);

writeSpace();

writeKeyword("in");

writeSpace();

emit(node.constraint);

}

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

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

}

function emitHelpers(node: Node) {

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 = printerOptions.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;

}

if (typeof helper.text === "string") {

writeLines(helper.text);

}

else {

writeLines(helper.text(makeFileLevelOptmiisticUniqueName));

}

helpersEmitted = true;

}

}

}

return helpersEmitted;

}

//