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

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

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

/*@internal*/

namespace ts {

/**

* Indicates whether to emit type metadata in the new format.

*/

const USE_NEW_TYPE_METADATA_FORMAT = false;

const enum TypeScriptSubstitutionFlags {

/** Enables substitutions for decorated classes. */

ClassAliases = 1 << 0,

/** Enables substitutions for namespace exports. */

NamespaceExports = 1 << 1,

/* Enables substitutions for unqualified enum members */

NonQualifiedEnumMembers = 1 << 3

}

const enum ClassFacts {

None = 0,

HasStaticInitializedProperties = 1 << 0,

HasConstructorDecorators = 1 << 1,

HasMemberDecorators = 1 << 2,

IsExportOfNamespace = 1 << 3,

IsNamedExternalExport = 1 << 4,

IsDefaultExternalExport = 1 << 5,

IsDerivedClass = 1 << 6,

UseImmediatelyInvokedFunctionExpression = 1 << 7,

HasAnyDecorators = HasConstructorDecorators | HasMemberDecorators,

NeedsName = HasStaticInitializedProperties | HasMemberDecorators,

MayNeedImmediatelyInvokedFunctionExpression = HasAnyDecorators | HasStaticInitializedProperties,

IsExported = IsExportOfNamespace | IsDefaultExternalExport | IsNamedExternalExport,

}

export function transformTypeScript(context: TransformationContext) {

const {

startLexicalEnvironment,

resumeLexicalEnvironment,

endLexicalEnvironment,

hoistVariableDeclaration,

} = context;

const resolver = context.getEmitResolver();

const compilerOptions = context.getCompilerOptions();

const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");

const languageVersion = getEmitScriptTarget(compilerOptions);

const moduleKind = getEmitModuleKind(compilerOptions);

// Save the previous transformation hooks.

const previousOnEmitNode = context.onEmitNode;

const previousOnSubstituteNode = context.onSubstituteNode;

// Set new transformation hooks.

context.onEmitNode = onEmitNode;

context.onSubstituteNode = onSubstituteNode;

// Enable substitution for property/element access to emit const enum values.

context.enableSubstitution(SyntaxKind.PropertyAccessExpression);

context.enableSubstitution(SyntaxKind.ElementAccessExpression);

// These variables contain state that changes as we descend into the tree.

let currentSourceFile: SourceFile;

let currentNamespace: ModuleDeclaration;

let currentNamespaceContainerName: Identifier;

let currentScope: SourceFile | Block | ModuleBlock | CaseBlock;

let currentScopeFirstDeclarationsOfName: UnderscoreEscapedMap<Node>;

/**

* Keeps track of whether expression substitution has been enabled for specific edge cases.

* They are persisted between each SourceFile transformation and should not be reset.

*/

let enabledSubstitutions: TypeScriptSubstitutionFlags;

/**

* A map that keeps track of aliases created for classes with decorators to avoid issues

* with the double-binding behavior of classes.

*/

let classAliases: Identifier[];

/**

* Keeps track of whether we are within any containing namespaces when performing

* just-in-time substitution while printing an expression identifier.

*/

let applicableSubstitutions: TypeScriptSubstitutionFlags;

/**

* Tracks what computed name expressions originating from elided names must be inlined

* at the next execution site, in document order

*/

let pendingExpressions: Expression[] | undefined;

return transformSourceFile;

/**

* Transform TypeScript-specific syntax in a SourceFile.

*

* @param node A SourceFile node.

*/

function transformSourceFile(node: SourceFile) {

if (node.isDeclarationFile) {

return node;

}

currentSourceFile = node;

const visited = saveStateAndInvoke(node, visitSourceFile);

addEmitHelpers(visited, context.readEmitHelpers());

currentSourceFile = undefined;

return visited;

}

/**

* Visits a node, saving and restoring state variables on the stack.

*

* @param node The node to visit.

*/

function saveStateAndInvoke<T>(node: Node, f: (node: Node) => T): T {

// Save state

const savedCurrentScope = currentScope;

const savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName;

// Handle state changes before visiting a node.

onBeforeVisitNode(node);

const visited = f(node);

// Restore state

if (currentScope !== savedCurrentScope) {

currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName;

}

currentScope = savedCurrentScope;

return visited;

}

/**

* Performs actions that should always occur immediately before visiting a node.

*

* @param node The node to visit.

*/

function onBeforeVisitNode(node: Node) {

switch (node.kind) {

case SyntaxKind.SourceFile:

case SyntaxKind.CaseBlock:

case SyntaxKind.ModuleBlock:

case SyntaxKind.Block:

currentScope = <SourceFile | CaseBlock | ModuleBlock | Block>node;

currentScopeFirstDeclarationsOfName = undefined;

break;

case SyntaxKind.ClassDeclaration:

case SyntaxKind.FunctionDeclaration:

if (hasModifier(node, ModifierFlags.Ambient)) {

break;

}

// Record these declarations provided that they have a name.

if ((node as ClassDeclaration | FunctionDeclaration).name) {

recordEmittedDeclarationInScope(node as ClassDeclaration | FunctionDeclaration);

}

else {

// These nodes should always have names unless they are default-exports;

// however, class declaration parsing allows for undefined names, so syntactically invalid

// programs may also have an undefined name.

Debug.assert(node.kind === SyntaxKind.ClassDeclaration || hasModifier(node, ModifierFlags.Default));

}

break;

}

}

/**

* General-purpose node visitor.

*

* @param node The node to visit.

*/

function visitor(node: Node): VisitResult<Node> {

return saveStateAndInvoke(node, visitorWorker);

}

/**

* Visits and possibly transforms any node.

*

* @param node The node to visit.

*/

function visitorWorker(node: Node): VisitResult<Node> {

if (node.transformFlags & TransformFlags.TypeScript) {

// This node is explicitly marked as TypeScript, so we should transform the node.

return visitTypeScript(node);

}

else if (node.transformFlags & TransformFlags.ContainsTypeScript) {

// This node contains TypeScript, so we should visit its children.

return visitEachChild(node, visitor, context);

}

return node;

}

/**

* Specialized visitor that visits the immediate children of a SourceFile.

*

* @param node The node to visit.

*/

function sourceElementVisitor(node: Node): VisitResult<Node> {

return saveStateAndInvoke(node, sourceElementVisitorWorker);

}

/**

* Specialized visitor that visits the immediate children of a SourceFile.

*

* @param node The node to visit.

*/

function sourceElementVisitorWorker(node: Node): VisitResult<Node> {

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ImportEqualsDeclaration:

case SyntaxKind.ExportAssignment:

case SyntaxKind.ExportDeclaration:

return visitEllidableStatement(<ImportDeclaration | ImportEqualsDeclaration | ExportAssignment | ExportDeclaration>node);

default:

return visitorWorker(node);

}

}

function visitEllidableStatement(node: ImportDeclaration | ImportEqualsDeclaration | ExportAssignment | ExportDeclaration): VisitResult<Node> {

const parsed = getParseTreeNode(node);

if (parsed !== node) {

// If the node has been transformed by a `before` transformer, perform no ellision on it

// As the type information we would attempt to lookup to perform ellision is potentially unavailable for the synthesized nodes

// We do not reuse `visitorWorker`, as the ellidable statement syntax kinds are technically unrecognized by the switch-case in `visitTypeScript`,

// and will trigger debug failures when debug verbosity is turned up

if (node.transformFlags & TransformFlags.ContainsTypeScript) {

// This node contains TypeScript, so we should visit its children.

return visitEachChild(node, visitor, context);

}

// Otherwise, we can just return the node

return node;

}

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

return visitImportDeclaration(<ImportDeclaration>node);

case SyntaxKind.ImportEqualsDeclaration:

return visitImportEqualsDeclaration(<ImportEqualsDeclaration>node);

case SyntaxKind.ExportAssignment:

return visitExportAssignment(<ExportAssignment>node);

case SyntaxKind.ExportDeclaration:

return visitExportDeclaration(<ExportDeclaration>node);

default:

Debug.fail("Unhandled ellided statement");

}

}

/**

* Specialized visitor that visits the immediate children of a namespace.

*

* @param node The node to visit.

*/

function namespaceElementVisitor(node: Node): VisitResult<Node> {

return saveStateAndInvoke(node, namespaceElementVisitorWorker);

}

/**

* Specialized visitor that visits the immediate children of a namespace.

*

* @param node The node to visit.

*/

function namespaceElementVisitorWorker(node: Node): VisitResult<Node> {

if (node.kind === SyntaxKind.ExportDeclaration ||

node.kind === SyntaxKind.ImportDeclaration ||

node.kind === SyntaxKind.ImportClause ||

(node.kind === SyntaxKind.ImportEqualsDeclaration &&

(<ImportEqualsDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference)) {

// do not emit ES6 imports and exports since they are illegal inside a namespace

return undefined;

}

else if (node.transformFlags & TransformFlags.TypeScript || hasModifier(node, ModifierFlags.Export)) {

// This node is explicitly marked as TypeScript, or is exported at the namespace

// level, so we should transform the node.

return visitTypeScript(node);

}

else if (node.transformFlags & TransformFlags.ContainsTypeScript) {

// This node contains TypeScript, so we should visit its children.

return visitEachChild(node, visitor, context);

}

return node;

}

/**

* Specialized visitor that visits the immediate children of a class with TypeScript syntax.

*

* @param node The node to visit.

*/

function classElementVisitor(node: Node): VisitResult<Node> {

return saveStateAndInvoke(node, classElementVisitorWorker);

}

/**

* Specialized visitor that visits the immediate children of a class with TypeScript syntax.

*

* @param node The node to visit.

*/

function classElementVisitorWorker(node: Node): VisitResult<Node> {

switch (node.kind) {

case SyntaxKind.Constructor:

// TypeScript constructors are transformed in `visitClassDeclaration`.

// We elide them here as `visitorWorker` checks transform flags, which could

// erronously include an ES6 constructor without TypeScript syntax.

return undefined;

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.IndexSignature:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.MethodDeclaration:

// Fallback to the default visit behavior.

return visitorWorker(node);

case SyntaxKind.SemicolonClassElement:

return node;

default:

Debug.failBadSyntaxKind(node);

return undefined;

}

}

function modifierVisitor(node: Node): VisitResult<Node> {

if (modifierToFlag(node.kind) & ModifierFlags.TypeScriptModifier) {

return undefined;

}

else if (currentNamespace && node.kind === SyntaxKind.ExportKeyword) {

return undefined;

}

return node;

}

/**

* Branching visitor, visits a TypeScript syntax node.

*

* @param node The node to visit.

*/

function visitTypeScript(node: Node): VisitResult<Node> {

if (hasModifier(node, ModifierFlags.Ambient) && isStatement(node)) {

// TypeScript ambient declarations are elided, but some comments may be preserved.

// See the implementation of `getLeadingComments` in comments.ts for more details.

return createNotEmittedStatement(node);

}

switch (node.kind) {

case SyntaxKind.ExportKeyword:

case SyntaxKind.DefaultKeyword:

// ES6 export and default modifiers are elided when inside a namespace.

return currentNamespace ? undefined : node;

case SyntaxKind.PublicKeyword:

case SyntaxKind.PrivateKeyword:

case SyntaxKind.ProtectedKeyword:

case SyntaxKind.AbstractKeyword:

case SyntaxKind.ConstKeyword:

case SyntaxKind.DeclareKeyword:

case SyntaxKind.ReadonlyKeyword:

// TypeScript accessibility and readonly modifiers are elided.

case SyntaxKind.ArrayType:

case SyntaxKind.TupleType:

case SyntaxKind.TypeLiteral:

case SyntaxKind.TypePredicate:

case SyntaxKind.TypeParameter:

case SyntaxKind.AnyKeyword:

case SyntaxKind.BooleanKeyword:

case SyntaxKind.StringKeyword:

case SyntaxKind.NumberKeyword:

case SyntaxKind.NeverKeyword:

case SyntaxKind.VoidKeyword:

case SyntaxKind.SymbolKeyword:

case SyntaxKind.ConstructorType:

case SyntaxKind.FunctionType:

case SyntaxKind.TypeQuery:

case SyntaxKind.TypeReference:

case SyntaxKind.UnionType:

case SyntaxKind.IntersectionType:

case SyntaxKind.ConditionalType:

case SyntaxKind.ParenthesizedType:

case SyntaxKind.ThisType:

case SyntaxKind.TypeOperator:

case SyntaxKind.IndexedAccessType:

case SyntaxKind.MappedType:

case SyntaxKind.LiteralType:

// TypeScript type nodes are elided.

case SyntaxKind.IndexSignature:

// TypeScript index signatures are elided.

case SyntaxKind.Decorator:

// TypeScript decorators are elided. They will be emitted as part of visitClassDeclaration.

case SyntaxKind.TypeAliasDeclaration:

// TypeScript type-only declarations are elided.

return undefined;

case SyntaxKind.PropertyDeclaration:

// TypeScript property declarations are elided. However their names are still visited, and can potentially be retained if they could have sideeffects

return visitPropertyDeclaration(node as PropertyDeclaration);

case SyntaxKind.NamespaceExportDeclaration:

// TypeScript namespace export declarations are elided.

return undefined;

case SyntaxKind.Constructor:

return visitConstructor(<ConstructorDeclaration>node);

case SyntaxKind.InterfaceDeclaration:

// TypeScript interfaces are elided, but some comments may be preserved.

// See the implementation of `getLeadingComments` in comments.ts for more details.

return createNotEmittedStatement(node);

case SyntaxKind.ClassDeclaration:

// This is a class declaration with TypeScript syntax extensions.

//

// TypeScript class syntax extensions include:

// - decorators

// - optional `implements` heritage clause

// - parameter property assignments in the constructor

// - property declarations

// - index signatures

// - method overload signatures

return visitClassDeclaration(<ClassDeclaration>node);

case SyntaxKind.ClassExpression:

// This is a class expression with TypeScript syntax extensions.

//

// TypeScript class syntax extensions include:

// - decorators

// - optional `implements` heritage clause

// - parameter property assignments in the constructor

// - property declarations

// - index signatures

// - method overload signatures

return visitClassExpression(<ClassExpression>node);

case SyntaxKind.HeritageClause:

// This is a heritage clause with TypeScript syntax extensions.

//

// TypeScript heritage clause extensions include:

// - `implements` clause

return visitHeritageClause(<HeritageClause>node);

case SyntaxKind.ExpressionWithTypeArguments:

// TypeScript supports type arguments on an expression in an `extends` heritage clause.

return visitExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);

case SyntaxKind.MethodDeclaration:

// TypeScript method declarations may have decorators, modifiers

// or type annotations.

return visitMethodDeclaration(<MethodDeclaration>node);

case SyntaxKind.GetAccessor:

// Get Accessors can have TypeScript modifiers, decorators, and type annotations.

return visitGetAccessor(<GetAccessorDeclaration>node);

case SyntaxKind.SetAccessor:

// Set Accessors can have TypeScript modifiers and type annotations.

return visitSetAccessor(<SetAccessorDeclaration>node);

case SyntaxKind.FunctionDeclaration:

// Typescript function declarations can have modifiers, decorators, and type annotations.

return visitFunctionDeclaration(<FunctionDeclaration>node);

case SyntaxKind.FunctionExpression:

// TypeScript function expressions can have modifiers and type annotations.

return visitFunctionExpression(<FunctionExpression>node);

case SyntaxKind.ArrowFunction:

// TypeScript arrow functions can have modifiers and type annotations.

return visitArrowFunction(<ArrowFunction>node);

case SyntaxKind.Parameter:

// This is a parameter declaration with TypeScript syntax extensions.

//

// TypeScript parameter declaration syntax extensions include:

// - decorators

// - accessibility modifiers

// - the question mark (?) token for optional parameters

// - type annotations

// - this parameters

return visitParameter(<ParameterDeclaration>node);

case SyntaxKind.ParenthesizedExpression:

// ParenthesizedExpressions are TypeScript if their expression is a

// TypeAssertion or AsExpression

return visitParenthesizedExpression(<ParenthesizedExpression>node);

case SyntaxKind.TypeAssertionExpression:

case SyntaxKind.AsExpression:

// TypeScript type assertions are removed, but their subtrees are preserved.

return visitAssertionExpression(<AssertionExpression>node);

case SyntaxKind.CallExpression:

return visitCallExpression(<CallExpression>node);

case SyntaxKind.NewExpression:

return visitNewExpression(<NewExpression>node);

case SyntaxKind.NonNullExpression:

// TypeScript non-null expressions are removed, but their subtrees are preserved.

return visitNonNullExpression(<NonNullExpression>node);

case SyntaxKind.EnumDeclaration:

// TypeScript enum declarations do not exist in ES6 and must be rewritten.

return visitEnumDeclaration(<EnumDeclaration>node);

case SyntaxKind.VariableStatement:

// TypeScript namespace exports for variable statements must be transformed.

return visitVariableStatement(<VariableStatement>node);

case SyntaxKind.VariableDeclaration:

return visitVariableDeclaration(<VariableDeclaration>node);

case SyntaxKind.ModuleDeclaration:

// TypeScript namespace declarations must be transformed.

return visitModuleDeclaration(<ModuleDeclaration>node);

case SyntaxKind.ImportEqualsDeclaration:

// TypeScript namespace or external module import.

return visitImportEqualsDeclaration(<ImportEqualsDeclaration>node);

default:

Debug.failBadSyntaxKind(node);

return visitEachChild(node, visitor, context);

}

}

function visitSourceFile(node: SourceFile) {

const alwaysStrict = getStrictOptionValue(compilerOptions, "alwaysStrict") &&

!(isExternalModule(node) && moduleKind >= ModuleKind.ES2015);

return updateSourceFileNode(

node,

visitLexicalEnvironment(node.statements, sourceElementVisitor, context, /*start*/ 0, alwaysStrict));

}

/**

* Tests whether we should emit a __decorate call for a class declaration.

*/

function shouldEmitDecorateCallForClass(node: ClassDeclaration) {

if (node.decorators && node.decorators.length > 0) {

return true;

}

const constructor = getFirstConstructorWithBody(node);

if (constructor) {

return forEach(constructor.parameters, shouldEmitDecorateCallForParameter);

}

return false;

}

/**

* Tests whether we should emit a __decorate call for a parameter declaration.

*/

function shouldEmitDecorateCallForParameter(parameter: ParameterDeclaration) {

return parameter.decorators !== undefined && parameter.decorators.length > 0;

}

function getClassFacts(node: ClassDeclaration, staticProperties: ReadonlyArray<PropertyDeclaration>) {

let facts = ClassFacts.None;

if (some(staticProperties)) facts |= ClassFacts.HasStaticInitializedProperties;

const extendsClauseElement = getClassExtendsHeritageClauseElement(node);

if (extendsClauseElement && skipOuterExpressions(extendsClauseElement.expression).kind !== SyntaxKind.NullKeyword) facts |= ClassFacts.IsDerivedClass;

if (shouldEmitDecorateCallForClass(node)) facts |= ClassFacts.HasConstructorDecorators;

if (childIsDecorated(node)) facts |= ClassFacts.HasMemberDecorators;

if (isExportOfNamespace(node)) facts |= ClassFacts.IsExportOfNamespace;

else if (isDefaultExternalModuleExport(node)) facts |= ClassFacts.IsDefaultExternalExport;

else if (isNamedExternalModuleExport(node)) facts |= ClassFacts.IsNamedExternalExport;

if (languageVersion <= ScriptTarget.ES5 && (facts & ClassFacts.MayNeedImmediatelyInvokedFunctionExpression)) facts |= ClassFacts.UseImmediatelyInvokedFunctionExpression;

return facts;

}

/**

* Transforms a class declaration with TypeScript syntax into compatible ES6.

*

* This function will only be called when one of the following conditions are met:

* - The class has decorators.

* - The class has property declarations with initializers.

* - The class contains a constructor that contains parameters with accessibility modifiers.

* - The class is an export in a TypeScript namespace.

*

* @param node The node to transform.

*/

function visitClassDeclaration(node: ClassDeclaration): VisitResult<Statement> {

const savedPendingExpressions = pendingExpressions;

pendingExpressions = undefined;

const staticProperties = getInitializedProperties(node, /*isStatic*/ true);

const facts = getClassFacts(node, staticProperties);

if (facts & ClassFacts.UseImmediatelyInvokedFunctionExpression) {

context.startLexicalEnvironment();

}

const name = node.name || (facts & ClassFacts.NeedsName ? getGeneratedNameForNode(node) : undefined);

const classStatement = facts & ClassFacts.HasConstructorDecorators

? createClassDeclarationHeadWithDecorators(node, name, facts)

: createClassDeclarationHeadWithoutDecorators(node, name, facts);

let statements: Statement[] = [classStatement];

// Write any pending expressions from elided or moved computed property names

if (some(pendingExpressions)) {

statements.push(createStatement(inlineExpressions(pendingExpressions)));

}

pendingExpressions = savedPendingExpressions;

// Emit static property assignment. Because classDeclaration is lexically evaluated,

// it is safe to emit static property assignment after classDeclaration

// From ES6 specification:

// HasLexicalDeclaration (N) : Determines if the argument identifier has a binding in this environment record that was created using

// a lexical declaration such as a LexicalDeclaration or a ClassDeclaration.

if (facts & ClassFacts.HasStaticInitializedProperties) {

addInitializedPropertyStatements(statements, staticProperties, facts & ClassFacts.UseImmediatelyInvokedFunctionExpression ? getInternalName(node) : getLocalName(node));

}

// Write any decorators of the node.

addClassElementDecorationStatements(statements, node, /*isStatic*/ false);

addClassElementDecorationStatements(statements, node, /*isStatic*/ true);

addConstructorDecorationStatement(statements, node);

if (facts & ClassFacts.UseImmediatelyInvokedFunctionExpression) {

// When we emit a TypeScript class down to ES5, we must wrap it in an IIFE so that the

// 'es2015' transformer can properly nest static initializers and decorators. The result

// looks something like:

//

// var C = function () {

// class C {

// }

// C.static_prop = 1;

// return C;

// }();

//

const closingBraceLocation = createTokenRange(skipTrivia(currentSourceFile.text, node.members.end), SyntaxKind.CloseBraceToken);

const localName = getInternalName(node);

// The following partially-emitted expression exists purely to align our sourcemap

// emit with the original emitter.

const outer = createPartiallyEmittedExpression(localName);

outer.end = closingBraceLocation.end;

setEmitFlags(outer, EmitFlags.NoComments);

const statement = createReturn(outer);

statement.pos = closingBraceLocation.pos;

setEmitFlags(statement, EmitFlags.NoComments | EmitFlags.NoTokenSourceMaps);

statements.push(statement);

addRange(statements, context.endLexicalEnvironment());

const iife = createImmediatelyInvokedArrowFunction(statements);

setEmitFlags(iife, EmitFlags.TypeScriptClassWrapper);

const varStatement = createVariableStatement(

/*modifiers*/ undefined,

createVariableDeclarationList([

createVariableDeclaration(

getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ false),

/*type*/ undefined,

iife

)

])

);

setOriginalNode(varStatement, node);

setCommentRange(varStatement, node);

setSourceMapRange(varStatement, moveRangePastDecorators(node));

startOnNewLine(varStatement);

statements = [varStatement];

}

// If the class is exported as part of a TypeScript namespace, emit the namespace export.

// Otherwise, if the class was exported at the top level and was decorated, emit an export

// declaration or export default for the class.

if (facts & ClassFacts.IsExportOfNamespace) {

addExportMemberAssignment(statements, node);

}

else if (facts & ClassFacts.UseImmediatelyInvokedFunctionExpression || facts & ClassFacts.HasConstructorDecorators) {

if (facts & ClassFacts.IsDefaultExternalExport) {

statements.push(createExportDefault(getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true)));

}

else if (facts & ClassFacts.IsNamedExternalExport) {

statements.push(createExternalModuleExport(getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true)));

}

}

if (statements.length > 1) {

// Add a DeclarationMarker as a marker for the end of the declaration

statements.push(createEndOfDeclarationMarker(node));

setEmitFlags(classStatement, getEmitFlags(classStatement) | EmitFlags.HasEndOfDeclarationMarker);

}

return singleOrMany(statements);

}

/**

* Transforms a non-decorated class declaration and appends the resulting statements.

*

* @param node A ClassDeclaration node.

* @param name The name of the class.

* @param facts Precomputed facts about the class.

*/

function createClassDeclarationHeadWithoutDecorators(node: ClassDeclaration, name: Identifier, facts: ClassFacts) {

// ${modifiers} class ${name} ${heritageClauses} {

// ${members}

// }

// we do not emit modifiers on the declaration if we are emitting an IIFE

const modifiers = !(facts & ClassFacts.UseImmediatelyInvokedFunctionExpression)

? visitNodes(node.modifiers, modifierVisitor, isModifier)

: undefined;

const classDeclaration = createClassDeclaration(

/*decorators*/ undefined,

modifiers,

name,

/*typeParameters*/ undefined,

visitNodes(node.heritageClauses, visitor, isHeritageClause),

transformClassMembers(node, (facts & ClassFacts.IsDerivedClass) !== 0)

);

// To better align with the old emitter, we should not emit a trailing source map

// entry if the class has static properties.

let emitFlags = getEmitFlags(node);

if (facts & ClassFacts.HasStaticInitializedProperties) {

emitFlags |= EmitFlags.NoTrailingSourceMap;

}

setTextRange(classDeclaration, node);

setOriginalNode(classDeclaration, node);

setEmitFlags(classDeclaration, emitFlags);

return classDeclaration;

}

/**

* Transforms a decorated class declaration and appends the resulting statements. If

* the class requires an alias to avoid issues with double-binding, the alias is returned.

*/

function createClassDeclarationHeadWithDecorators(node: ClassDeclaration, name: Identifier, facts: ClassFacts) {

// When we emit an ES6 class that has a class decorator, we must tailor the

// emit to certain specific cases.

//

// In the simplest case, we emit the class declaration as a let declaration, and

// evaluate decorators after the close of the class body:

//

// [Example 1]

// ---------------------------------------------------------------------

// TypeScript | Javascript

// ---------------------------------------------------------------------

// @dec | let C = class C {

// class C { | }

// } | C = __decorate([dec], C);

// ---------------------------------------------------------------------

// @dec | let C = class C {

// export class C { | }

// } | C = __decorate([dec], C);

// | export { C };

// ---------------------------------------------------------------------

//

// If a class declaration contains a reference to itself *inside* of the class body,

// this introduces two bindings to the class: One outside of the class body, and one

// inside of the class body. If we apply decorators as in [Example 1] above, there

// is the possibility that the decorator `dec` will return a new value for the

// constructor, which would result in the binding inside of the class no longer

// pointing to the same reference as the binding outside of the class.

//

// As a result, we must instead rewrite all references to the class *inside* of the

// class body to instead point to a local temporary alias for the class:

//

// [Example 2]

// ---------------------------------------------------------------------

// TypeScript | Javascript

// ---------------------------------------------------------------------

// @dec | let C = C_1 = class C {

// class C { | static x() { return C_1.y; }

// static x() { return C.y; } | }

// static y = 1; | C.y = 1;

// } | C = C_1 = __decorate([dec], C);

// | var C_1;

// ---------------------------------------------------------------------

// @dec | let C = class C {

// export class C { | static x() { return C_1.y; }

// static x() { return C.y; } | }

// static y = 1; | C.y = 1;

// } | C = C_1 = __decorate([dec], C);

// | export { C };

// | var C_1;

// ---------------------------------------------------------------------

//

// If a class declaration is the default export of a module, we instead emit

// the export after the decorated declaration:

//

// [Example 3]

// ---------------------------------------------------------------------

// TypeScript | Javascript

// ---------------------------------------------------------------------

// @dec | let default_1 = class {

// export default class { | }

// } | default_1 = __decorate([dec], default_1);

// | export default default_1;

// ---------------------------------------------------------------------

// @dec | let C = class C {

// export default class C { | }

// } | C = __decorate([dec], C);

// | export default C;

// ---------------------------------------------------------------------

//

// If the class declaration is the default export and a reference to itself

// inside of the class body, we must emit both an alias for the class *and*

// move the export after the declaration:

//

// [Example 4]

// ---------------------------------------------------------------------

// TypeScript | Javascript

// ---------------------------------------------------------------------

// @dec | let C = class C {

// export default class C { | static x() { return C_1.y; }

// static x() { return C.y; } | }

// static y = 1; | C.y = 1;

// } | C = C_1 = __decorate([dec], C);

// | export default C;

// | var C_1;

// ---------------------------------------------------------------------

//

const location = moveRangePastDecorators(node);

const classAlias = getClassAliasIfNeeded(node);

const declName = getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true);

// ... = class ${name} ${heritageClauses} {

// ${members}

// }

const heritageClauses = visitNodes(node.heritageClauses, visitor, isHeritageClause);

const members = transformClassMembers(node, (facts & ClassFacts.IsDerivedClass) !== 0);

const classExpression = createClassExpression(/*modifiers*/ undefined, name, /*typeParameters*/ undefined, heritageClauses, members);

setOriginalNode(classExpression, node);

setTextRange(classExpression, location);

// let ${name} = ${classExpression} where name is either declaredName if the class doesn't contain self-reference

// or decoratedClassAlias if the class contain self-reference.

const statement = createVariableStatement(

/*modifiers*/ undefined,

createVariableDeclarationList([

createVariableDeclaration(

declName,

/*type*/ undefined,

classAlias ? createAssignment(classAlias, classExpression) : classExpression

)

], NodeFlags.Let)

);

setOriginalNode(statement, node);

setTextRange(statement, location);

setCommentRange(statement, node);

return statement;

}

/**

* Transforms a class expression with TypeScript syntax into compatible ES6.

*

* This function will only be called when one of the following conditions are met:

* - The class has property declarations with initializers.

* - The class contains a constructor that contains parameters with accessibility modifiers.

*

* @param node The node to transform.

*/

function visitClassExpression(node: ClassExpression): Expression {

const savedPendingExpressions = pendingExpressions;

pendingExpressions = undefined;

const staticProperties = getInitializedProperties(node, /*isStatic*/ true);

const heritageClauses = visitNodes(node.heritageClauses, visitor, isHeritageClause);

const members = transformClassMembers(node, some(heritageClauses, c => c.token === SyntaxKind.ExtendsKeyword));

const classExpression = createClassExpression(

/*modifiers*/ undefined,

node.name,

/*typeParameters*/ undefined,

heritageClauses,

members

);

setOriginalNode(classExpression, node);

setTextRange(classExpression, node);

if (some(staticProperties) || some(pendingExpressions)) {

const expressions: Expression[] = [];

const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & NodeCheckFlags.ClassWithConstructorReference;

const temp = createTempVariable(hoistVariableDeclaration, !!isClassWithConstructorReference);

if (isClassWithConstructorReference) {

// record an alias as the class name is not in scope for statics.

enableSubstitutionForClassAliases();

const alias = getSynthesizedClone(temp);

alias.autoGenerateFlags &= ~GeneratedIdentifierFlags.ReservedInNestedScopes;

classAliases[getOriginalNodeId(node)] = alias;

}

// To preserve the behavior of the old emitter, we explicitly indent

// the body of a class with static initializers.

setEmitFlags(classExpression, EmitFlags.Indented | getEmitFlags(classExpression));

expressions.push(startOnNewLine(createAssignment(temp, classExpression)));

// Add any pending expressions leftover from elided or relocated computed property names

addRange(expressions, map(pendingExpressions, startOnNewLine));

pendingExpressions = savedPendingExpressions;

addRange(expressions, generateInitializedPropertyExpressions(staticProperties, temp));

expressions.push(startOnNewLine(temp));

return inlineExpressions(expressions);

}

pendingExpressions = savedPendingExpressions;

return classExpression;

}

/**

* Transforms the members of a class.

*

* @param node The current class.

* @param isDerivedClass A value indicating whether the class has an extends clause that does not extend 'null'.

*/

function transformClassMembers(node: ClassDeclaration | ClassExpression, isDerivedClass: boolean) {

const members: ClassElement[] = [];

const constructor = transformConstructor(node, isDerivedClass);

if (constructor) {

members.push(constructor);

}

addRange(members, visitNodes(node.members, classElementVisitor, isClassElement));

return setTextRange(createNodeArray(members), /*location*/ node.members);

}

/**

* Transforms (or creates) a constructor for a class.

*

* @param node The current class.

* @param isDerivedClass A value indicating whether the class has an extends clause that does not extend 'null'.

*/

function transformConstructor(node: ClassDeclaration | ClassExpression, isDerivedClass: boolean) {

// Check if we have property assignment inside class declaration.

// If there is a property assignment, we need to emit constructor whether users define it or not

// If there is no property assignment, we can omit constructor if users do not define it

const hasInstancePropertyWithInitializer = forEach(node.members, isInstanceInitializedProperty);

const hasParameterPropertyAssignments = node.transformFlags & TransformFlags.ContainsParameterPropertyAssignments;

const constructor = getFirstConstructorWithBody(node);

// If the class does not contain nodes that require a synthesized constructor,

// accept the current constructor if it exists.

if (!hasInstancePropertyWithInitializer && !hasParameterPropertyAssignments) {

return visitEachChild(constructor, visitor, context);

}

const parameters = transformConstructorParameters(constructor);

const body = transformConstructorBody(node, constructor, isDerivedClass);

// constructor(${parameters}) {

// ${body}

// }

return startOnNewLine(

setOriginalNode(

setTextRange(

createConstructor(

/*decorators*/ undefined,

/*modifiers*/ undefined,

parameters,

body

),

constructor || node

),

constructor

)

);

}

/**

* Transforms (or creates) the parameters for the constructor of a class with

* parameter property assignments or instance property initializers.

*

* @param constructor The constructor declaration.

*/

function transformConstructorParameters(constructor: ConstructorDeclaration) {

// The ES2015 spec specifies in 14.5.14. Runtime Semantics: ClassDefinitionEvaluation:

// If constructor is empty, then

// If ClassHeritag_eopt is present and protoParent is not null, then

// Let constructor be the result of parsing the source text

// constructor(...args) { super (...args);}

// using the syntactic grammar with the goal symbol MethodDefinition[~Yield].

// Else,

// Let constructor be the result of parsing the source text

// constructor( ){ }

// using the syntactic grammar with the goal symbol MethodDefinition[~Yield].

//

// While we could emit the '...args' rest parameter, certain later tools in the pipeline might