Auto = 0x00000000, // No preferred name

CountMask = 0x0FFFFFFF, // Temp variable counter

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

const delimiters = createDelimiterMap();

const brackets = createBracketsMap();

// emit output for the __extends helper function

const extendsHelper = `

// Emit output for the __assign helper function.

// This is typically used for JSX spread attributes,

// and can be used for object literal spread properties.

const assignHelper = `

// emit output for the __decorate helper function

const decorateHelper = `

// emit output for the __metadata helper function

const metadataHelper = `

// emit output for the __param helper function

const paramHelper = `

// emit output for the __awaiter helper function

const awaiterHelper = `

// emit output for the __export helper function

const exportStarHelper = `

// emit output for the UMD helper function.

const umdHelper = `

const superHelper = `

const advancedSuperHelper = `

const compilerOptions = host.getCompilerOptions();

const languageVersion = getEmitScriptTarget(compilerOptions);

const moduleKind = getEmitModuleKind(compilerOptions);

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

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

const emitterDiagnostics = createDiagnosticCollection();

let emitSkipped = false;

const newLine = host.getNewLine();

const printFile = createFilePrinter();

forEachExpectedEmitFile(host, emitFile, targetSourceFile);

return {

emitSkipped,

diagnostics: emitterDiagnostics.getDiagnostics(),

emittedFiles: emittedFilesList,

sourceMaps: sourceMapDataList

};

function emitFile({ jsFilePath, sourceMapFilePath, declarationFilePath}: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean) {

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

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

printFile(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit);

}

else {

emitSkipped = true;

}

if (declarationFilePath) {

emitSkipped = writeDeclarationFile(declarationFilePath, sourceFiles, isBundledEmit, host, resolver, emitterDiagnostics) || emitSkipped;

}

if (!emitSkipped && emittedFilesList) {

emittedFilesList.push(jsFilePath);

if (sourceMapFilePath) {

emittedFilesList.push(sourceMapFilePath);

}

if (declarationFilePath) {

emittedFilesList.push(declarationFilePath);

}

}

}

function createFilePrinter() {

const transformers = getTransformers(compilerOptions).concat(initializePrinter);

const writer = createTextWriter(newLine);

const {

write,

writeLine,

increaseIndent,

decreaseIndent

} = writer;

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

const {

emitStart,

emitEnd,

emitTokenStart,

emitTokenEnd

} = sourceMap;

const comments = createCommentWriter(host, writer, sourceMap);

const {

getLeadingComments,

getTrailingComments,

getTrailingCommentsOfPosition,

emitLeadingComments,

emitTrailingComments,

emitLeadingDetachedComments,

emitTrailingDetachedComments

} = comments;

let context: TransformationContext;

let getNodeEmitFlags: (node: Node) => NodeEmitFlags;

let setNodeEmitFlags: (node: Node, flags: NodeEmitFlags) => void;

let getSourceMapRange: (node: Node) => TextRange;

let getTokenSourceMapRange: (node: Node, token: SyntaxKind) => TextRange;

let getCommentRange: (node: Node) => TextRange;

let isSubstitutionEnabled: (node: Node) => boolean;

let isEmitNotificationEnabled: (node: Node) => boolean;

let onSubstituteNode: (node: Node, isExpression: boolean) => Node;

let onEmitNode: (node: Node, emit: (node: Node) => void) => void;

let nodeToGeneratedName: string[];

let generatedNameSet: Map<string>;

let tempFlags: TempFlags;

let currentSourceFile: SourceFile;

let currentText: string;

let currentFileIdentifiers: Map<string>;

let extendsEmitted: boolean;

let assignEmitted: boolean;

let decorateEmitted: boolean;

let paramEmitted: boolean;

let awaiterEmitted: boolean;

let isOwnFileEmit: boolean;

return doPrint;

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

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

nodeToGeneratedName = [];

generatedNameSet = {};

isOwnFileEmit = !isBundledEmit;

// Emit helpers from all the files

if (isBundledEmit && moduleKind) {

forEach(sourceFiles, emitEmitHelpers);

}

// Transform and print the source files

transformFiles(resolver, host, sourceFiles, transformers);

writeLine();

const sourceMappingURL = sourceMap.getSourceMappingURL();

if (sourceMappingURL) {

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

}

// Write the source map

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

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

}

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

// Reset state

sourceMap.reset();

comments.reset();

writer.reset();

getNodeEmitFlags = undefined;

setNodeEmitFlags = undefined;

getSourceMapRange = undefined;

getTokenSourceMapRange = undefined;

getCommentRange = undefined;

isSubstitutionEnabled = undefined;

isEmitNotificationEnabled = undefined;

onSubstituteNode = undefined;

onEmitNode = undefined;

tempFlags = TempFlags.Auto;

currentSourceFile = undefined;

currentText = undefined;

extendsEmitted = false;

assignEmitted = false;

decorateEmitted = false;

paramEmitted = false;

awaiterEmitted = false;

isOwnFileEmit = false;

}

function initializePrinter(_context: TransformationContext) {

context = _context;

getNodeEmitFlags = context.getNodeEmitFlags;

setNodeEmitFlags = context.setNodeEmitFlags;

getSourceMapRange = context.getSourceMapRange;

getTokenSourceMapRange = context.getTokenSourceMapRange;

getCommentRange = context.getCommentRange;

isSubstitutionEnabled = context.isSubstitutionEnabled;

isEmitNotificationEnabled = context.isEmitNotificationEnabled;

onSubstituteNode = context.onSubstituteNode;

onEmitNode = context.onEmitNode;

return printSourceFile;

}

function printSourceFile(node: SourceFile) {

currentSourceFile = node;

currentText = node.text;

currentFileIdentifiers = node.identifiers;

sourceMap.setSourceFile(node);

comments.setSourceFile(node);

emitNodeWithNotificationOption(node, emitWorker);

return node;

}

/**

function emit(node: Node) {

emitNodeWithNotificationOption(node, emitWithoutNotificationOption);

}

/**

// TODO(rbuckton): This should be removed once source maps are aligned with the old

// emitter and new baselines are taken. This exists solely to

// align with the old emitter.

function emitSpecialized(node: Node, flags: NodeEmitFlags) {

if (node) {

const flagsToAdd = flags & ~getNodeEmitFlags(node);

if (flagsToAdd) {

setNodeEmitFlags(node, getNodeEmitFlags(node) | flagsToAdd);

emit(node);

setNodeEmitFlags(node, getNodeEmitFlags(node) & ~flagsToAdd);

return;

}

emit(node);

}

}

/**

function emitWithoutNotificationOption(node: Node) {

emitNodeWithWorker(node, emitWorker);

}

/**

function emitExpression(node: Expression) {

emitNodeWithNotificationOption(node, emitExpressionWithoutNotificationOption);

}

/**

function emitExpressionWithoutNotificationOption(node: Expression) {

emitNodeWithWorker(node, emitExpressionWorker);

}

/**

function emitNodeWithNotificationOption(node: Node, emit: (node: Node) => void) {

if (node) {

if (isEmitNotificationEnabled(node)) {

onEmitNode(node, emit);

}

else {

emit(node);

}

}

}

function emitNodeWithWorker(node: Node, emitWorker: (node: Node) => void) {

if (node) {

const leadingComments = getLeadingComments(/*range*/ node, /*contextNode*/ node, shouldSkipLeadingCommentsForNode, getCommentRange);

const trailingComments = getTrailingComments(/*range*/ node, /*contextNode*/ node, shouldSkipTrailingCommentsForNode, getCommentRange);

emitLeadingComments(/*range*/ node, leadingComments, /*contextNode*/ node, getCommentRange);

emitStart(/*range*/ node, /*contextNode*/ node, shouldSkipLeadingSourceMapForNode, shouldSkipSourceMapForChildren, getSourceMapRange);

emitWorker(node);

emitEnd(/*range*/ node, /*contextNode*/ node, shouldSkipTrailingSourceMapForNode, shouldSkipSourceMapForChildren, getSourceMapRange);

emitTrailingComments(node, trailingComments);

}

}

/**

function shouldSkipLeadingCommentsForNode(node: Node) {

return isNotEmittedStatement(node)

|| (getNodeEmitFlags(node) & NodeEmitFlags.NoLeadingComments) !== 0;

}

/**

function shouldSkipTrailingCommentsForNode(node: Node) {

return isNotEmittedStatement(node)

|| (getNodeEmitFlags(node) & NodeEmitFlags.NoTrailingComments) !== 0;

}

/**

function shouldSkipLeadingSourceMapForNode(node: Node) {

return isNotEmittedStatement(node)

|| (getNodeEmitFlags(node) & NodeEmitFlags.NoLeadingSourceMap) !== 0;

}

/**

function shouldSkipTrailingSourceMapForNode(node: Node) {

return isNotEmittedStatement(node)

|| (getNodeEmitFlags(node) & NodeEmitFlags.NoTrailingSourceMap) !== 0;

}

/**

function shouldSkipSourceMapForChildren(node: Node) {

return (getNodeEmitFlags(node) & NodeEmitFlags.NoNestedSourceMaps) !== 0;

}

function emitWorker(node: Node): void {

if (tryEmitSubstitute(node, emitWorker, /*isExpression*/ false)) {

return;

}

const kind = node.kind;

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

// Reserved words

case SyntaxKind.ConstKeyword:

case SyntaxKind.DefaultKeyword:

case SyntaxKind.ExportKeyword:

case SyntaxKind.VoidKeyword:

// Strict mode reserved words

case SyntaxKind.PrivateKeyword:

case SyntaxKind.ProtectedKeyword:

case SyntaxKind.PublicKeyword:

case SyntaxKind.StaticKeyword:

// Contextual keywords

case SyntaxKind.AbstractKeyword:

case SyntaxKind.AnyKeyword:

case SyntaxKind.AsyncKeyword:

case SyntaxKind.BooleanKeyword:

case SyntaxKind.DeclareKeyword:

case SyntaxKind.NumberKeyword:

case SyntaxKind.ReadonlyKeyword:

case SyntaxKind.StringKeyword:

case SyntaxKind.SymbolKeyword:

case SyntaxKind.GlobalKeyword:

return writeTokenNode(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(<ThisTypeNode>node);

case SyntaxKind.StringLiteralType:

return emitLiteral(<StringLiteralTypeNode>node);

// Binding patterns

case SyntaxKind.ObjectBindingPattern:

return emitObjectBindingPattern(<BindingPattern>node);

case SyntaxKind.ArrayBindingPattern:

return emitArrayBindingPattern(<BindingPattern>node);

case SyntaxKind.BindingElement:

return emitBindingElement(<BindingElement>node);

// Misc

case SyntaxKind.TemplateSpan:

return emitTemplateSpan(<TemplateSpan>node);

case SyntaxKind.SemicolonClassElement:

return emitSemicolonClassElement(<SemicolonClassElement>node);

// Statements

case SyntaxKind.Block:

return emitBlock(<Block>node);

case SyntaxKind.VariableStatement:

return emitVariableStatement(<VariableStatement>node);

case SyntaxKind.EmptyStatement:

return emitEmptyStatement(<EmptyStatement>node);

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

// Enum

case SyntaxKind.EnumMember:

return emitEnumMember(<EnumMember>node);

// Top-level nodes

case SyntaxKind.SourceFile:

return emitSourceFile(<SourceFile>node);

// JSDoc nodes (ignored)

// Transformation nodes (ignored)

}

if (isExpression(node)) {

return emitExpressionWorker(node);

}

}

function emitExpressionWorker(node: Node) {

if (tryEmitSubstitute(node, emitExpressionWorker, /*isExpression*/ true)) {

return;

}

const kind = node.kind;

switch (kind) {

// Literals

case SyntaxKind.NumericLiteral:

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:

return writeTokenNode(node);

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

return emitSpreadElementExpression(<SpreadElementExpression>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);

// JSX

case SyntaxKind.JsxElement:

return emitJsxElement(<JsxElement>node);

case SyntaxKind.JsxSelfClosingElement:

return emitJsxSelfClosingElement(<JsxSelfClosingElement>node);

// Transformation nodes

case SyntaxKind.PartiallyEmittedExpression:

return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);

}

}

//

// Literals/Pseudo-literals

//

// SyntaxKind.NumericLiteral

// SyntaxKind.StringLiteral

// SyntaxKind.RegularExpressionLiteral

// SyntaxKind.NoSubstitutionTemplateLiteral

// SyntaxKind.TemplateHead

// SyntaxKind.TemplateMiddle

// SyntaxKind.TemplateTail

function emitLiteral(node: LiteralLikeNode) {

const text = getLiteralTextOfNode(node);

if ((compilerOptions.sourceMap || compilerOptions.inlineSourceMap)

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

writer.writeLiteral(text);

}

else {

write(text);

}

}

//

// Identifiers

//

function emitIdentifier(node: Identifier) {

if (getNodeEmitFlags(node) & NodeEmitFlags.UMDDefine) {

writeLines(umdHelper);

}

else {

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

emitDecorators(node, node.decorators);

emitModifiers(node, node.modifiers);

emit(node.name);

writeIfPresent(node.questionToken, "?");

emitWithPrefix(": ", node.type);

write(";");

}

function emitPropertyDeclaration(node: PropertyDeclaration) {

emitDecorators(node, node.decorators);

emitModifiers(node, node.modifiers);

emit(node.name);

emitWithPrefix(": ", node.type);

emitExpressionWithPrefix(" = ", node.initializer);

write(";");

}

function emitMethodSignature(node: MethodSignature) {

emitDecorators(node, node.decorators);

emitModifiers(node, node.modifiers);

emit(node.name);

writeIfPresent(node.questionToken, "?");

emitTypeParameters(node, node.typeParameters);

emitParameters(node, node.parameters);

emitWithPrefix(": ", node.type);

write(";");

}

function emitMethodDeclaration(node: MethodDeclaration) {

emitDecorators(node, node.decorators);

emitModifiers(node, node.modifiers);

writeIfPresent(node.asteriskToken, "*");

emit(node.name);

emitSignatureAndBody(node, emitSignatureHead);

}

function emitConstructor(node: ConstructorDeclaration) {

emitModifiers(node, node.modifiers);

write("constructor");

emitSignatureAndBody(node, emitSignatureHead);