/*@internal*/

namespace ts {

const enum ES2015SubstitutionFlags {

/** Enables substitutions for captured `this` */

CapturedThis = 1 << 0,

/** Enables substitutions for block-scoped bindings. */

BlockScopedBindings = 1 << 1,

}

/**

* If loop contains block scoped binding captured in some function then loop body is converted to a function.

* Lexical bindings declared in loop initializer will be passed into the loop body function as parameters,

* however if this binding is modified inside the body - this new value should be propagated back to the original binding.

* This is done by declaring new variable (out parameter holder) outside of the loop for every binding that is reassigned inside the body.

* On every iteration this variable is initialized with value of corresponding binding.

* At every point where control flow leaves the loop either explicitly (break/continue) or implicitly (at the end of loop body)

* we copy the value inside the loop to the out parameter holder.

*

* for (let x;;) {

* let a = 1;

* let b = () => a;

* x++

* if (...) break;

* ...

* }

*

* will be converted to

*

* var out_x;

* var loop = function(x) {

* var a = 1;

* var b = function() { return a; }

* x++;

* if (...) return out_x = x, "break";

* ...

* out_x = x;

* }

* for (var x;;) {

* out_x = x;

* var state = loop(x);

* x = out_x;

* if (state === "break") break;

* }

*

* NOTE: values to out parameters are not copies if loop is abrupted with 'return' - in this case this will end the entire enclosing function

* so nobody can observe this new value.

*/

interface LoopOutParameter {

flags: LoopOutParameterFlags;

originalName: Identifier;

outParamName: Identifier;

}

const enum LoopOutParameterFlags {

Body = 1 << 0, // Modified in the body of the iteration statement

Initializer = 1 << 1, // Set in the initializer of a ForStatement

}

const enum CopyDirection {

ToOriginal,

ToOutParameter

}

const enum Jump {

Break = 1 << 1,

Continue = 1 << 2,

Return = 1 << 3

}

interface ConvertedLoopState {

/*

* set of labels that occurred inside the converted loop

* used to determine if labeled jump can be emitted as is or it should be dispatched to calling code

*/

labels?: Map<boolean>;

/*

* collection of labeled jumps that transfer control outside the converted loop.

* maps store association 'label -> labelMarker' where

* - label - value of label as it appear in code

* - label marker - return value that should be interpreted by calling code as 'jump to <label>'

*/

labeledNonLocalBreaks?: Map<string>;

labeledNonLocalContinues?: Map<string>;

/*

* set of non-labeled jumps that transfer control outside the converted loop

* used to emit dispatching logic in the caller of converted loop

*/

nonLocalJumps?: Jump;

/*

* set of non-labeled jumps that should be interpreted as local

* i.e. if converted loop contains normal loop or switch statement then inside this loop break should be treated as local jump

*/

allowedNonLabeledJumps?: Jump;

/*

* alias for 'arguments' object from the calling code stack frame

* i.e.

* for (let x;;) <statement that captures x in closure and uses 'arguments'>

* should be converted to

* var loop = function(x) { <code where 'arguments' is replaced with 'arguments_1'> }

* var arguments_1 = arguments

* for (var x;;) loop(x);

* otherwise semantics of the code will be different since 'arguments' inside converted loop body

* will refer to function that holds converted loop.

* This value is set on demand.

*/

argumentsName?: Identifier;

/*

* alias for 'this' from the calling code stack frame in case if this was used inside the converted loop

*/

thisName?: Identifier;

/*

* set to true if node contains lexical 'this' so we can mark function that wraps convered loop body as 'CapturedThis' for subsequent substitution.

*/

containsLexicalThis?: boolean;

/*

* list of non-block scoped variable declarations that appear inside converted loop

* such variable declarations should be moved outside the loop body

* for (let x;;) {

* var y = 1;

* ...

* }

* should be converted to

* var loop = function(x) {

* y = 1;

* ...

* }

* var y;

* for (var x;;) loop(x);

*/

hoistedLocalVariables?: Identifier[];

conditionVariable?: Identifier;

loopParameters: ParameterDeclaration[];

/**

* List of loop out parameters - detailed descripion can be found in the comment to LoopOutParameter

*/

loopOutParameters: LoopOutParameter[];

}

type LoopConverter = (node: IterationStatement, outermostLabeledStatement: LabeledStatement | undefined, convertedLoopBodyStatements: Statement[] | undefined, ancestorFacts: HierarchyFacts) => Statement;

// Facts we track as we traverse the tree

const enum HierarchyFacts {

None = 0,

//

// Ancestor facts

//

Function = 1 << 0, // Enclosed in a non-arrow function

ArrowFunction = 1 << 1, // Enclosed in an arrow function

AsyncFunctionBody = 1 << 2, // Enclosed in an async function body

NonStaticClassElement = 1 << 3, // Enclosed in a non-static, non-async class element

CapturesThis = 1 << 4, // Enclosed in a function that captures the lexical 'this' (used in substitution)

ExportedVariableStatement = 1 << 5, // Enclosed in an exported variable statement in the current scope

TopLevel = 1 << 6, // Enclosing block-scoped container is a top-level container

Block = 1 << 7, // Enclosing block-scoped container is a Block

IterationStatement = 1 << 8, // Immediately enclosed in an IterationStatement

IterationStatementBlock = 1 << 9, // Enclosing Block is enclosed in an IterationStatement

IterationContainer = 1 << 10, // Enclosed in an outer IterationStatement

ForStatement = 1 << 11, // Enclosing block-scoped container is a ForStatement

ForInOrForOfStatement = 1 << 12, // Enclosing block-scoped container is a ForInStatement or ForOfStatement

ConstructorWithCapturedSuper = 1 << 13, // Enclosed in a constructor that captures 'this' for use with 'super'

// NOTE: do not add more ancestor flags without also updating AncestorFactsMask below.

// NOTE: when adding a new ancestor flag, be sure to update the subtree flags below.

//

// Ancestor masks

//

AncestorFactsMask = (ConstructorWithCapturedSuper << 1) - 1,

// We are always in *some* kind of block scope, but only specific block-scope containers are

// top-level or Blocks.

BlockScopeIncludes = None,

BlockScopeExcludes = TopLevel | Block | IterationStatement | IterationStatementBlock | ForStatement | ForInOrForOfStatement,

// A source file is a top-level block scope.

SourceFileIncludes = TopLevel,

SourceFileExcludes = BlockScopeExcludes & ~TopLevel | IterationContainer,

// Functions, methods, and accessors are both new lexical scopes and new block scopes.

FunctionIncludes = Function | TopLevel,

FunctionExcludes = BlockScopeExcludes & ~TopLevel | ArrowFunction | AsyncFunctionBody | CapturesThis | NonStaticClassElement | ConstructorWithCapturedSuper | IterationContainer,

AsyncFunctionBodyIncludes = FunctionIncludes | AsyncFunctionBody,

AsyncFunctionBodyExcludes = FunctionExcludes & ~NonStaticClassElement,

// Arrow functions are lexically scoped to their container, but are new block scopes.

ArrowFunctionIncludes = ArrowFunction | TopLevel,

ArrowFunctionExcludes = BlockScopeExcludes & ~TopLevel | ConstructorWithCapturedSuper,

// Constructors are both new lexical scopes and new block scopes. Constructors are also

// always considered non-static members of a class.

ConstructorIncludes = FunctionIncludes | NonStaticClassElement,

ConstructorExcludes = FunctionExcludes & ~NonStaticClassElement,

// 'do' and 'while' statements are not block scopes. We track that the subtree is contained

// within an IterationStatement to indicate whether the embedded statement is an

// IterationStatementBlock.

DoOrWhileStatementIncludes = IterationStatement | IterationContainer,

DoOrWhileStatementExcludes = None,

// 'for' statements are new block scopes and have special handling for 'let' declarations.

ForStatementIncludes = IterationStatement | ForStatement | IterationContainer,

ForStatementExcludes = BlockScopeExcludes & ~ForStatement,

// 'for-in' and 'for-of' statements are new block scopes and have special handling for

// 'let' declarations.

ForInOrForOfStatementIncludes = IterationStatement | ForInOrForOfStatement | IterationContainer,

ForInOrForOfStatementExcludes = BlockScopeExcludes & ~ForInOrForOfStatement,

// Blocks (other than function bodies) are new block scopes.

BlockIncludes = Block,

BlockExcludes = BlockScopeExcludes & ~Block,

IterationStatementBlockIncludes = IterationStatementBlock,

IterationStatementBlockExcludes = BlockScopeExcludes,

//

// Subtree facts

//

NewTarget = 1 << 14, // Contains a 'new.target' meta-property

CapturedLexicalThis = 1 << 15, // Contains a lexical `this` reference captured by an arrow function.

//

// Subtree masks

//

SubtreeFactsMask = ~AncestorFactsMask,

ArrowFunctionSubtreeExcludes = None,

FunctionSubtreeExcludes = NewTarget | CapturedLexicalThis,

}

export function transformES2015(context: TransformationContext) {

const {

startLexicalEnvironment,

resumeLexicalEnvironment,

endLexicalEnvironment,

hoistVariableDeclaration,

} = context;

const compilerOptions = context.getCompilerOptions();

const resolver = context.getEmitResolver();

const previousOnSubstituteNode = context.onSubstituteNode;

const previousOnEmitNode = context.onEmitNode;

context.onEmitNode = onEmitNode;

context.onSubstituteNode = onSubstituteNode;

let currentSourceFile: SourceFile;

let currentText: string;

let hierarchyFacts: HierarchyFacts;

let taggedTemplateStringDeclarations: VariableDeclaration[];

function recordTaggedTemplateString(temp: Identifier) {

taggedTemplateStringDeclarations = append(

taggedTemplateStringDeclarations,

createVariableDeclaration(temp));

}

/**

* Used to track if we are emitting body of the converted loop

*/

let convertedLoopState: ConvertedLoopState | undefined;

/**

* Keeps track of whether substitutions have been enabled for specific cases.

* They are persisted between each SourceFile transformation and should not

* be reset.

*/

let enabledSubstitutions: ES2015SubstitutionFlags;

return chainBundle(transformSourceFile);

function transformSourceFile(node: SourceFile) {

if (node.isDeclarationFile) {

return node;

}

currentSourceFile = node;

currentText = node.text;

const visited = visitSourceFile(node);

addEmitHelpers(visited, context.readEmitHelpers());

currentSourceFile = undefined!;

currentText = undefined!;

taggedTemplateStringDeclarations = undefined!;

hierarchyFacts = HierarchyFacts.None;

return visited;

}

/**

* Sets the `HierarchyFacts` for this node prior to visiting this node's subtree, returning the facts set prior to modification.

* @param excludeFacts The existing `HierarchyFacts` to reset before visiting the subtree.

* @param includeFacts The new `HierarchyFacts` to set before visiting the subtree.

*/

function enterSubtree(excludeFacts: HierarchyFacts, includeFacts: HierarchyFacts) {

const ancestorFacts = hierarchyFacts;

hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & HierarchyFacts.AncestorFactsMask;

return ancestorFacts;

}

/**

* Restores the `HierarchyFacts` for this node's ancestor after visiting this node's

* subtree, propagating specific facts from the subtree.

* @param ancestorFacts The `HierarchyFacts` of the ancestor to restore after visiting the subtree.

* @param excludeFacts The existing `HierarchyFacts` of the subtree that should not be propagated.

* @param includeFacts The new `HierarchyFacts` of the subtree that should be propagated.

*/

function exitSubtree(ancestorFacts: HierarchyFacts, excludeFacts: HierarchyFacts, includeFacts: HierarchyFacts) {

hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & HierarchyFacts.SubtreeFactsMask | ancestorFacts;

}

function isReturnVoidStatementInConstructorWithCapturedSuper(node: Node): boolean {

return (hierarchyFacts & HierarchyFacts.ConstructorWithCapturedSuper) !== 0

&& node.kind === SyntaxKind.ReturnStatement

&& !(<ReturnStatement>node).expression;

}

function shouldVisitNode(node: Node): boolean {

return (node.transformFlags & TransformFlags.ContainsES2015) !== 0

|| convertedLoopState !== undefined

|| (hierarchyFacts & HierarchyFacts.ConstructorWithCapturedSuper && (isStatement(node) || (node.kind === SyntaxKind.Block)))

|| (isIterationStatement(node, /*lookInLabeledStatements*/ false) && shouldConvertIterationStatement(node))

|| (getEmitFlags(node) & EmitFlags.TypeScriptClassWrapper) !== 0;

}

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

if (shouldVisitNode(node)) {

return visitJavaScript(node);

}

else {

return node;

}

}

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

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

return visitSuperKeyword(/*isExpressionOfCall*/ true);

}

return visitor(node);

}

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

switch (node.kind) {

case SyntaxKind.StaticKeyword:

return undefined; // elide static keyword

case SyntaxKind.ClassDeclaration:

return visitClassDeclaration(<ClassDeclaration>node);

case SyntaxKind.ClassExpression:

return visitClassExpression(<ClassExpression>node);

case SyntaxKind.Parameter:

return visitParameter(<ParameterDeclaration>node);

case SyntaxKind.FunctionDeclaration:

return visitFunctionDeclaration(<FunctionDeclaration>node);

case SyntaxKind.ArrowFunction:

return visitArrowFunction(<ArrowFunction>node);

case SyntaxKind.FunctionExpression:

return visitFunctionExpression(<FunctionExpression>node);

case SyntaxKind.VariableDeclaration:

return visitVariableDeclaration(<VariableDeclaration>node);

case SyntaxKind.Identifier:

return visitIdentifier(<Identifier>node);

case SyntaxKind.VariableDeclarationList:

return visitVariableDeclarationList(<VariableDeclarationList>node);

case SyntaxKind.SwitchStatement:

return visitSwitchStatement(<SwitchStatement>node);

case SyntaxKind.CaseBlock:

return visitCaseBlock(<CaseBlock>node);

case SyntaxKind.Block:

return visitBlock(<Block>node, /*isFunctionBody*/ false);

case SyntaxKind.BreakStatement:

case SyntaxKind.ContinueStatement:

return visitBreakOrContinueStatement(<BreakOrContinueStatement>node);

case SyntaxKind.LabeledStatement:

return visitLabeledStatement(<LabeledStatement>node);

case SyntaxKind.DoStatement:

case SyntaxKind.WhileStatement:

return visitDoOrWhileStatement(<DoStatement | WhileStatement>node, /*outermostLabeledStatement*/ undefined);

case SyntaxKind.ForStatement:

return visitForStatement(<ForStatement>node, /*outermostLabeledStatement*/ undefined);

case SyntaxKind.ForInStatement:

return visitForInStatement(<ForInStatement>node, /*outermostLabeledStatement*/ undefined);

case SyntaxKind.ForOfStatement:

return visitForOfStatement(<ForOfStatement>node, /*outermostLabeledStatement*/ undefined);

case SyntaxKind.ExpressionStatement:

return visitExpressionStatement(<ExpressionStatement>node);

case SyntaxKind.ObjectLiteralExpression:

return visitObjectLiteralExpression(<ObjectLiteralExpression>node);

case SyntaxKind.CatchClause:

return visitCatchClause(<CatchClause>node);

case SyntaxKind.ShorthandPropertyAssignment:

return visitShorthandPropertyAssignment(<ShorthandPropertyAssignment>node);

case SyntaxKind.ComputedPropertyName:

return visitComputedPropertyName(<ComputedPropertyName>node);

case SyntaxKind.ArrayLiteralExpression:

return visitArrayLiteralExpression(<ArrayLiteralExpression>node);

case SyntaxKind.CallExpression:

return visitCallExpression(<CallExpression>node);

case SyntaxKind.NewExpression:

return visitNewExpression(<NewExpression>node);

case SyntaxKind.ParenthesizedExpression:

return visitParenthesizedExpression(<ParenthesizedExpression>node, /*needsDestructuringValue*/ true);

case SyntaxKind.BinaryExpression:

return visitBinaryExpression(<BinaryExpression>node, /*needsDestructuringValue*/ true);

case SyntaxKind.NoSubstitutionTemplateLiteral:

case SyntaxKind.TemplateHead:

case SyntaxKind.TemplateMiddle:

case SyntaxKind.TemplateTail:

return visitTemplateLiteral(<LiteralExpression>node);

case SyntaxKind.StringLiteral:

return visitStringLiteral(<StringLiteral>node);

case SyntaxKind.NumericLiteral:

return visitNumericLiteral(<NumericLiteral>node);

case SyntaxKind.TaggedTemplateExpression:

return visitTaggedTemplateExpression(<TaggedTemplateExpression>node);

case SyntaxKind.TemplateExpression:

return visitTemplateExpression(<TemplateExpression>node);

case SyntaxKind.YieldExpression:

return visitYieldExpression(<YieldExpression>node);

case SyntaxKind.SpreadElement:

return visitSpreadElement(<SpreadElement>node);

case SyntaxKind.SuperKeyword:

return visitSuperKeyword(/*isExpressionOfCall*/ false);

case SyntaxKind.ThisKeyword:

return visitThisKeyword(node);

case SyntaxKind.MetaProperty:

return visitMetaProperty(<MetaProperty>node);

case SyntaxKind.MethodDeclaration:

return visitMethodDeclaration(<MethodDeclaration>node);

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

return visitAccessorDeclaration(<AccessorDeclaration>node);

case SyntaxKind.VariableStatement:

return visitVariableStatement(<VariableStatement>node);

case SyntaxKind.ReturnStatement:

return visitReturnStatement(<ReturnStatement>node);

default:

return visitEachChild(node, visitor, context);

}

}

function visitSourceFile(node: SourceFile): SourceFile {

const ancestorFacts = enterSubtree(HierarchyFacts.SourceFileExcludes, HierarchyFacts.SourceFileIncludes);

const prologue: Statement[] = [];

const statements: Statement[] = [];

startLexicalEnvironment();

let statementOffset = addStandardPrologue(prologue, node.statements, /*ensureUseStrict*/ false);

statementOffset = addCustomPrologue(prologue, node.statements, statementOffset, visitor);

addRange(statements, visitNodes(node.statements, visitor, isStatement, statementOffset));

if (taggedTemplateStringDeclarations) {

statements.push(

createVariableStatement(/*modifiers*/ undefined,

createVariableDeclarationList(taggedTemplateStringDeclarations)));

}

mergeLexicalEnvironment(prologue, endLexicalEnvironment());

insertCaptureThisForNodeIfNeeded(prologue, node);

exitSubtree(ancestorFacts, HierarchyFacts.None, HierarchyFacts.None);

return updateSourceFileNode(

node,

setTextRange(createNodeArray(concatenate(prologue, statements)), node.statements)

);

}

function visitSwitchStatement(node: SwitchStatement): SwitchStatement {

if (convertedLoopState !== undefined) {

const savedAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps;

// for switch statement allow only non-labeled break

convertedLoopState.allowedNonLabeledJumps! |= Jump.Break;

const result = visitEachChild(node, visitor, context);

convertedLoopState.allowedNonLabeledJumps = savedAllowedNonLabeledJumps;

return result;

}

return visitEachChild(node, visitor, context);

}

function visitCaseBlock(node: CaseBlock): CaseBlock {

const ancestorFacts = enterSubtree(HierarchyFacts.BlockScopeExcludes, HierarchyFacts.BlockScopeIncludes);

const updated = visitEachChild(node, visitor, context);

exitSubtree(ancestorFacts, HierarchyFacts.None, HierarchyFacts.None);

return updated;

}

function returnCapturedThis(node: Node): ReturnStatement {

return setOriginalNode(createReturn(createFileLevelUniqueName("_this")), node);

}

function visitReturnStatement(node: ReturnStatement): Statement {

if (convertedLoopState) {

convertedLoopState.nonLocalJumps! |= Jump.Return;

if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) {

node = returnCapturedThis(node);

}

return createReturn(

createObjectLiteral(

[

createPropertyAssignment(

createIdentifier("value"),

node.expression

? visitNode(node.expression, visitor, isExpression)

: createVoidZero()

)

]

)

);

}

else if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) {

return returnCapturedThis(node);

}

return visitEachChild(node, visitor, context);

}

function visitThisKeyword(node: Node): Node {

if (hierarchyFacts & HierarchyFacts.ArrowFunction) {

hierarchyFacts |= HierarchyFacts.CapturedLexicalThis;

}

if (convertedLoopState) {

if (hierarchyFacts & HierarchyFacts.ArrowFunction) {

// if the enclosing function is an ArrowFunction then we use the captured 'this' keyword.

convertedLoopState.containsLexicalThis = true;

return node;

}

return convertedLoopState.thisName || (convertedLoopState.thisName = createUniqueName("this"));

}

return node;

}

function visitIdentifier(node: Identifier): Identifier {

if (!convertedLoopState) {

return node;

}

if (isGeneratedIdentifier(node)) {

return node;

}

if (node.escapedText !== "arguments" || !resolver.isArgumentsLocalBinding(node)) {

return node;

}

return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = createUniqueName("arguments"));

}

function visitBreakOrContinueStatement(node: BreakOrContinueStatement): Statement {

if (convertedLoopState) {

// check if we can emit break/continue as is

// it is possible if either

// - break/continue is labeled and label is located inside the converted loop

// - break/continue is non-labeled and located in non-converted loop/switch statement

const jump = node.kind === SyntaxKind.BreakStatement ? Jump.Break : Jump.Continue;

const canUseBreakOrContinue =

(node.label && convertedLoopState.labels && convertedLoopState.labels.get(idText(node.label))) ||

(!node.label && (convertedLoopState.allowedNonLabeledJumps! & jump));

if (!canUseBreakOrContinue) {

let labelMarker: string;

const label = node.label;

if (!label) {

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

convertedLoopState.nonLocalJumps! |= Jump.Break;

labelMarker = "break";

}

else {

convertedLoopState.nonLocalJumps! |= Jump.Continue;

// note: return value is emitted only to simplify debugging, call to converted loop body does not do any dispatching on it.

labelMarker = "continue";

}

}

else {

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

labelMarker = `break-${label.escapedText}`;

setLabeledJump(convertedLoopState, /*isBreak*/ true, idText(label), labelMarker);

}

else {

labelMarker = `continue-${label.escapedText}`;

setLabeledJump(convertedLoopState, /*isBreak*/ false, idText(label), labelMarker);

}

}

let returnExpression: Expression = createLiteral(labelMarker);

if (convertedLoopState.loopOutParameters.length) {

const outParams = convertedLoopState.loopOutParameters;

let expr: Expression | undefined;

for (let i = 0; i < outParams.length; i++) {

const copyExpr = copyOutParameter(outParams[i], CopyDirection.ToOutParameter);

if (i === 0) {

expr = copyExpr;

}

else {

expr = createBinary(expr!, SyntaxKind.CommaToken, copyExpr);

}

}

returnExpression = createBinary(expr!, SyntaxKind.CommaToken, returnExpression);

}

return createReturn(returnExpression);

}

}

return visitEachChild(node, visitor, context);

}

/**

* Visits a ClassDeclaration and transforms it into a variable statement.

*

* @param node A ClassDeclaration node.

*/

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

// [source]

// class C { }

//

// [output]

// var C = (function () {

// function C() {

// }

// return C;

// }());

const variable = createVariableDeclaration(

getLocalName(node, /*allowComments*/ true),

/*type*/ undefined,

transformClassLikeDeclarationToExpression(node)

);

setOriginalNode(variable, node);

const statements: Statement[] = [];

const statement = createVariableStatement(/*modifiers*/ undefined, createVariableDeclarationList([variable]));

setOriginalNode(statement, node);

setTextRange(statement, node);

startOnNewLine(statement);

statements.push(statement);

// Add an `export default` statement for default exports (for `--target es5 --module es6`)

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

const exportStatement = hasModifier(node, ModifierFlags.Default)

? createExportDefault(getLocalName(node))

: createExternalModuleExport(getLocalName(node));

setOriginalNode(exportStatement, statement);

statements.push(exportStatement);

}

const emitFlags = getEmitFlags(node);

if ((emitFlags & EmitFlags.HasEndOfDeclarationMarker) === 0) {

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

statements.push(createEndOfDeclarationMarker(node));

setEmitFlags(statement, emitFlags | EmitFlags.HasEndOfDeclarationMarker);

}

return singleOrMany(statements);

}

/**

* Visits a ClassExpression and transforms it into an expression.

*

* @param node A ClassExpression node.

*/

function visitClassExpression(node: ClassExpression): Expression {

// [source]

// C = class { }

//

// [output]

// C = (function () {

// function class_1() {

// }

// return class_1;

// }())

return transformClassLikeDeclarationToExpression(node);

}

/**

* Transforms a ClassExpression or ClassDeclaration into an expression.

*

* @param node A ClassExpression or ClassDeclaration node.

*/

function transformClassLikeDeclarationToExpression(node: ClassExpression | ClassDeclaration): Expression {

// [source]

// class C extends D {

// constructor() {}

// method() {}

// get prop() {}

// set prop(v) {}

// }

//

// [output]

// (function (_super) {

// __extends(C, _super);

// function C() {

// }

// C.prototype.method = function () {}

// Object.defineProperty(C.prototype, "prop", {

// get: function() {},

// set: function() {},

// enumerable: true,

// configurable: true

// });

// return C;

// }(D))

if (node.name) {

enableSubstitutionsForBlockScopedBindings();

}

const extendsClauseElement = getClassExtendsHeritageElement(node);

const classFunction = createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

extendsClauseElement ? [createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, createFileLevelUniqueName("_super"))] : [],

/*type*/ undefined,

transformClassBody(node, extendsClauseElement)

);

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

// the body of the function here if it was requested in an earlier

// transformation.

setEmitFlags(classFunction, (getEmitFlags(node) & EmitFlags.Indented) | EmitFlags.ReuseTempVariableScope);

// "inner" and "outer" below are added purely to preserve source map locations from

// the old emitter

const inner = createPartiallyEmittedExpression(classFunction);

inner.end = node.end;

setEmitFlags(inner, EmitFlags.NoComments);

const outer = createPartiallyEmittedExpression(inner);

outer.end = skipTrivia(currentText, node.pos);

setEmitFlags(outer, EmitFlags.NoComments);

const result = createParen(

createCall(

outer,

/*typeArguments*/ undefined,

extendsClauseElement

? [visitNode(extendsClauseElement.expression, visitor, isExpression)]

: []

)

);

addSyntheticLeadingComment(result, SyntaxKind.MultiLineCommentTrivia, "* @class ");

return result;

}

/**

* Transforms a ClassExpression or ClassDeclaration into a function body.

*

* @param node A ClassExpression or ClassDeclaration node.

* @param extendsClauseElement The expression for the class `extends` clause.

*/

function transformClassBody(node: ClassExpression | ClassDeclaration, extendsClauseElement: ExpressionWithTypeArguments | undefined): Block {

const statements: Statement[] = [];

startLexicalEnvironment();

addExtendsHelperIfNeeded(statements, node, extendsClauseElement);

addConstructor(statements, node, extendsClauseElement);

addClassMembers(statements, node);

// Create a synthetic text range for the return statement.

const closingBraceLocation = createTokenRange(skipTrivia(currentText, 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);

insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());

const block = createBlock(setTextRange(createNodeArray(statements), /*location*/ node.members), /*multiLine*/ true);

setEmitFlags(block, EmitFlags.NoComments);

return block;

}

/**

* Adds a call to the `__extends` helper if needed for a class.

*

* @param statements The statements of the class body function.

* @param node The ClassExpression or ClassDeclaration node.

* @param extendsClauseElement The expression for the class `extends` clause.

*/

function addExtendsHelperIfNeeded(statements: Statement[], node: ClassExpression | ClassDeclaration, extendsClauseElement: ExpressionWithTypeArguments | undefined): void {

if (extendsClauseElement) {

statements.push(

setTextRange(

createExpressionStatement(

createExtendsHelper(context, getInternalName(node))

),

/*location*/ extendsClauseElement

)

);

}

}

/**

* Adds the constructor of the class to a class body function.

*

* @param statements The statements of the class body function.

* @param node The ClassExpression or ClassDeclaration node.

* @param extendsClauseElement The expression for the class `extends` clause.

*/

function addConstructor(statements: Statement[], node: ClassExpression | ClassDeclaration, extendsClauseElement: ExpressionWithTypeArguments | undefined): void {

const savedConvertedLoopState = convertedLoopState;

convertedLoopState = undefined;

const ancestorFacts = enterSubtree(HierarchyFacts.ConstructorExcludes, HierarchyFacts.ConstructorIncludes);

const constructor = getFirstConstructorWithBody(node);

const hasSynthesizedSuper = hasSynthesizedDefaultSuperCall(constructor, extendsClauseElement !== undefined);

const constructorFunction = createFunctionDeclaration(

/*decorators*/ undefined,

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

getInternalName(node),

/*typeParameters*/ undefined,

transformConstructorParameters(constructor, hasSynthesizedSuper),

/*type*/ undefined,

transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper)

);

setTextRange(constructorFunction, constructor || node);

if (extendsClauseElement) {

setEmitFlags(constructorFunction, EmitFlags.CapturesThis);

}

statements.push(constructorFunction);

exitSubtree(ancestorFacts, HierarchyFacts.FunctionSubtreeExcludes, HierarchyFacts.None);

convertedLoopState = savedConvertedLoopState;

}

/**

* Transforms the parameters of the constructor declaration of a class.

*

* @param constructor The constructor for the class.

* @param hasSynthesizedSuper A value indicating whether the constructor starts with a

* synthesized `super` call.

*/

function transformConstructorParameters(constructor: ConstructorDeclaration | undefined, hasSynthesizedSuper: boolean) {

// If the TypeScript transformer needed to synthesize a constructor for property

// initializers, it would have also added a synthetic `...args` parameter and

// `super` call.

// If this is the case, we do not include the synthetic `...args` parameter and

// will instead use the `arguments` object in ES5/3.

return visitParameterList(constructor && !hasSynthesizedSuper ? constructor.parameters : undefined, visitor, context)

|| <ParameterDeclaration[]>[];

}

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

// We must be here because the user didn't write a constructor

// but we needed to call 'super(...args)' anyway as per 14.5.14 of the ES2016 spec.

// If that's the case we can just immediately return the result of a 'super()' call.

const statements: Statement[] = [];

resumeLexicalEnvironment();

mergeLexicalEnvironment(statements, endLexicalEnvironment());

if (isDerivedClass) {

// return _super !== null && _super.apply(this, arguments) || this;

statements.push(createReturn(createDefaultSuperCallOrThis()));

}

const statementsArray = createNodeArray(statements);

setTextRange(statementsArray, node.members);

const block = createBlock(statementsArray, /*multiLine*/ true);

setTextRange(block, node);

setEmitFlags(block, EmitFlags.NoComments);

return block;

}

/**

* Transforms the body of a constructor declaration of a class.

*

* @param constructor The constructor for the class.

* @param node The node which contains the constructor.

* @param extendsClauseElement The expression for the class `extends` clause.

* @param hasSynthesizedSuper A value indicating whether the constructor starts with a

* synthesized `super` call.

*/

function transformConstructorBody(constructor: ConstructorDeclaration & { body: FunctionBody } | undefined, node: ClassDeclaration | ClassExpression, extendsClauseElement: ExpressionWithTypeArguments | undefined, hasSynthesizedSuper: boolean) {

// determine whether the class is known syntactically to be a derived class (e.g. a

// class that extends a value that is not syntactically known to be `null`).

const isDerivedClass = !!extendsClauseElement && skipOuterExpressions(extendsClauseElement.expression).kind !== SyntaxKind.NullKeyword;

// When the subclass does not have a constructor, we synthesize a *default* constructor using the following

// representation:

//

// ```

// // es2015 (source)

// class C extends Base { }

//

// // es5 (transformed)

// var C = (function (_super) {

// function C() {

// return _super.apply(this, arguments) || this;

// }

// return C;

// })(Base);

// ```

if (!constructor) return createDefaultConstructorBody(node, isDerivedClass);

// The prologue will contain all leading standard and custom prologue statements added by this transform

const prologue: Statement[] = [];

const statements: Statement[] = [];

resumeLexicalEnvironment();

// If a super call has already been synthesized,

// we're going to assume that we should just transform everything after that.

// The assumption is that no prior step in the pipeline has added any prologue directives.

let statementOffset = 0;

if (!hasSynthesizedSuper) statementOffset = addStandardPrologue(prologue, constructor.body.statements, /*ensureUseStrict*/ false);

addDefaultValueAssignmentsIfNeeded(statements, constructor);

addRestParameterIfNeeded(statements, constructor, hasSynthesizedSuper);

if (!hasSynthesizedSuper) statementOffset = addCustomPrologue(statements, constructor.body.statements, statementOffset, visitor);

// If the first statement is a call to `super()`, visit the statement directly

let superCallExpression: Expression | undefined;

if (hasSynthesizedSuper) {

superCallExpression = createDefaultSuperCallOrThis();

}

else if (isDerivedClass && statementOffset < constructor.body.statements.length) {

const firstStatement = constructor.body.statements[statementOffset];

if (isExpressionStatement(firstStatement) && isSuperCall(firstStatement.expression)) {

superCallExpression = visitImmediateSuperCallInBody(firstStatement.expression);

}

}

if (superCallExpression) {

hierarchyFacts |= HierarchyFacts.ConstructorWithCapturedSuper;

statementOffset++; // skip this statement, we will add it after visiting the rest of the body.

}

// visit the remaining statements

addRange(statements, visitNodes(constructor.body.statements, visitor, isStatement, /*start*/ statementOffset));

mergeLexicalEnvironment(prologue, endLexicalEnvironment());

insertCaptureNewTargetIfNeeded(prologue, constructor, /*copyOnWrite*/ false);

if (isDerivedClass) {

if (superCallExpression && statementOffset === constructor.body.statements.length && !(constructor.body.transformFlags & TransformFlags.ContainsLexicalThis)) {

// If the subclass constructor does *not* contain `this` and *ends* with a `super()` call, we will use the

// following representation:

//

// ```

// // es2015 (source)

// class C extends Base {

// constructor() {

// super("foo");

// }