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

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

// Transforms generator functions into a compatible ES5 representation with similar runtime

// semantics. This is accomplished by first transforming the body of each generator

// function into an intermediate representation that is the compiled into a JavaScript

// switch statement.

//

// Many functions in this transformer will contain comments indicating the expected

// intermediate representation. For illustrative purposes, the following intermediate

// language is used to define this intermediate representation:

//

// .nop - Performs no operation.

// .local NAME, ... - Define local variable declarations.

// .mark LABEL - Mark the location of a label.

// .br LABEL - Jump to a label. If jumping out of a protected

// region, all .finally blocks are executed.

// .brtrue LABEL, (x) - Jump to a label IIF the expression `x` is truthy.

// If jumping out of a protected region, all .finally

// blocks are executed.

// .brfalse LABEL, (x) - Jump to a label IIF the expression `x` is falsey.

// If jumping out of a protected region, all .finally

// blocks are executed.

// .yield (x) - Yield the value of the optional expression `x`.

// Resume at the next label.

// .yieldstar (x) - Delegate yield to the value of the optional

// expression `x`. Resume at the next label.

// NOTE: `x` must be an Iterator, not an Iterable.

// .loop CONTINUE, BREAK - Marks the beginning of a loop. Any "continue" or

// "break" abrupt completions jump to the CONTINUE or

// BREAK labels, respectively.

// .endloop - Marks the end of a loop.

// .with (x) - Marks the beginning of a WithStatement block, using

// the supplied expression.

// .endwith - Marks the end of a WithStatement.

// .switch - Marks the beginning of a SwitchStatement.

// .endswitch - Marks the end of a SwitchStatement.

// .labeled NAME - Marks the beginning of a LabeledStatement with the

// supplied name.

// .endlabeled - Marks the end of a LabeledStatement.

// .try TRY, CATCH, FINALLY, END - Marks the beginning of a protected region, and the

// labels for each block.

// .catch (x) - Marks the beginning of a catch block.

// .finally - Marks the beginning of a finally block.

// .endfinally - Marks the end of a finally block.

// .endtry - Marks the end of a protected region.

// .throw (x) - Throws the value of the expression `x`.

// .return (x) - Returns the value of the expression `x`.

//

// In addition, the illustrative intermediate representation introduces some special

// variables:

//

// %sent% - Either returns the next value sent to the generator,

// returns the result of a delegated yield, or throws

// the exception sent to the generator.

// %error% - Returns the value of the current exception in a

// catch block.

//

// This intermediate representation is then compiled into JavaScript syntax. The resulting

// compilation output looks something like the following:

//

// function f() {

// var /*locals*/;

// /*functions*/

// return __generator(function (state) {

// switch (state.label) {

// /*cases per label*/

// }

// });

// }

//

// Each of the above instructions corresponds to JavaScript emit similar to the following:

//

// .local NAME | var NAME;

// -------------------------------|----------------------------------------------

// .mark LABEL | case LABEL:

// -------------------------------|----------------------------------------------

// .br LABEL | return [3 /*break*/, LABEL];

// -------------------------------|----------------------------------------------

// .brtrue LABEL, (x) | if (x) return [3 /*break*/, LABEL];

// -------------------------------|----------------------------------------------

// .brfalse LABEL, (x) | if (!(x)) return [3, /*break*/, LABEL];

// -------------------------------|----------------------------------------------

// .yield (x) | return [4 /*yield*/, x];

// .mark RESUME | case RESUME:

// a = %sent%; | a = state.sent();

// -------------------------------|----------------------------------------------

// .yieldstar (x) | return [5 /*yield**/, x];

// .mark RESUME | case RESUME:

// a = %sent%; | a = state.sent();

// -------------------------------|----------------------------------------------

// .with (_a) | with (_a) {

// a(); | a();

// | }

// | state.label = LABEL;

// .mark LABEL | case LABEL:

// | with (_a) {

// b(); | b();

// | }

// .endwith |

// -------------------------------|----------------------------------------------

// | case 0:

// | state.trys = [];

// | ...

// .try TRY, CATCH, FINALLY, END |

// .mark TRY | case TRY:

// | state.trys.push([TRY, CATCH, FINALLY, END]);

// .nop |

// a(); | a();

// .br END | return [3 /*break*/, END];

// .catch (e) |

// .mark CATCH | case CATCH:

// | e = state.sent();

// b(); | b();

// .br END | return [3 /*break*/, END];

// .finally |

// .mark FINALLY | case FINALLY:

// c(); | c();

// .endfinally | return [7 /*endfinally*/];

// .endtry |

// .mark END | case END:

/*@internal*/

namespace ts {

type Label = number;

const enum OpCode {

Nop, // No operation, used to force a new case in the state machine

Statement, // A regular javascript statement

Assign, // An assignment

Break, // A break instruction used to jump to a label

BreakWhenTrue, // A break instruction used to jump to a label if a condition evaluates to true

BreakWhenFalse, // A break instruction used to jump to a label if a condition evaluates to false

Yield, // A completion instruction for the `yield` keyword

YieldStar, // A completion instruction for the `yield*` keyword (not implemented, but reserved for future use)

Return, // A completion instruction for the `return` keyword

Throw, // A completion instruction for the `throw` keyword

Endfinally // Marks the end of a `finally` block

}

type OperationArguments = [Label] | [Label, Expression] | [Statement] | [Expression] | [Expression, Expression];

// whether a generated code block is opening or closing at the current operation for a FunctionBuilder

const enum BlockAction {

Open,

Close,

}

// the kind for a generated code block in a FunctionBuilder

const enum CodeBlockKind {

Exception,

With,

Switch,

Loop,

Labeled

}

// the state for a generated code exception block

const enum ExceptionBlockState {

Try,

Catch,

Finally,

Done

}

// A generated code block

interface CodeBlock {

kind: CodeBlockKind;

}

// a generated exception block, used for 'try' statements

interface ExceptionBlock extends CodeBlock {

state: ExceptionBlockState;

startLabel: Label;

catchVariable?: Identifier;

catchLabel?: Label;

finallyLabel?: Label;

endLabel: Label;

}

// A generated code that tracks the target for 'break' statements in a LabeledStatement.

interface LabeledBlock extends CodeBlock {

labelText: string;

isScript: boolean;

breakLabel: Label;

}

// a generated block that tracks the target for 'break' statements in a 'switch' statement

interface SwitchBlock extends CodeBlock {

isScript: boolean;

breakLabel: Label;

}

// a generated block that tracks the targets for 'break' and 'continue' statements, used for iteration statements

interface LoopBlock extends CodeBlock {

continueLabel: Label;

isScript: boolean;

breakLabel: Label;

}

// a generated block associated with a 'with' statement

interface WithBlock extends CodeBlock {

expression: Identifier;

startLabel: Label;

endLabel: Label;

}

// NOTE: changes to this enum should be reflected in the __generator helper.

const enum Instruction {

Next = 0,

Throw = 1,

Return = 2,

Break = 3,

Yield = 4,

YieldStar = 5,

Catch = 6,

Endfinally = 7,

}

const instructionNames = createMap<string>({

[Instruction.Return]: "return",

[Instruction.Break]: "break",

[Instruction.Yield]: "yield",

[Instruction.YieldStar]: "yield*",

[Instruction.Endfinally]: "endfinally",

});

export function transformGenerators(context: TransformationContext) {

const {

resumeLexicalEnvironment,

endLexicalEnvironment,

hoistFunctionDeclaration,

hoistVariableDeclaration,

} = context;

const compilerOptions = context.getCompilerOptions();

const languageVersion = getEmitScriptTarget(compilerOptions);

const resolver = context.getEmitResolver();

const previousOnSubstituteNode = context.onSubstituteNode;

context.onSubstituteNode = onSubstituteNode;

let currentSourceFile: SourceFile;

let renamedCatchVariables: Map<boolean>;

let renamedCatchVariableDeclarations: Map<Identifier>;

let inGeneratorFunctionBody: boolean;

let inStatementContainingYield: boolean;

// The following three arrays store information about generated code blocks.

// All three arrays are correlated by their index. This approach is used over allocating

// objects to store the same information to avoid GC overhead.

//

let blocks: CodeBlock[]; // Information about the code block

let blockOffsets: number[]; // The operation offset at which a code block begins or ends

let blockActions: BlockAction[]; // Whether the code block is opened or closed

let blockStack: CodeBlock[]; // A stack of currently open code blocks

// Labels are used to mark locations in the code that can be the target of a Break (jump)

// operation. These are translated into case clauses in a switch statement.

// The following two arrays are correlated by their index. This approach is used over

// allocating objects to store the same information to avoid GC overhead.

//

let labelOffsets: number[]; // The operation offset at which the label is defined.

let labelExpressions: LiteralExpression[][]; // The NumericLiteral nodes bound to each label.

let nextLabelId = 1; // The next label id to use.

// Operations store information about generated code for the function body. This

// Includes things like statements, assignments, breaks (jumps), and yields.

// The following three arrays are correlated by their index. This approach is used over

// allocating objects to store the same information to avoid GC overhead.

//

let operations: OpCode[]; // The operation to perform.

let operationArguments: OperationArguments[]; // The arguments to the operation.

let operationLocations: TextRange[]; // The source map location for the operation.

let state: Identifier; // The name of the state object used by the generator at runtime.

// The following variables store information used by the `build` function:

//

let blockIndex = 0; // The index of the current block.

let labelNumber = 0; // The current label number.

let labelNumbers: number[][];

let lastOperationWasAbrupt: boolean; // Indicates whether the last operation was abrupt (break/continue).

let lastOperationWasCompletion: boolean; // Indicates whether the last operation was a completion (return/throw).

let clauses: CaseClause[]; // The case clauses generated for labels.

let statements: Statement[]; // The statements for the current label.

let exceptionBlockStack: ExceptionBlock[]; // A stack of containing exception blocks.

let currentExceptionBlock: ExceptionBlock; // The current exception block.

let withBlockStack: WithBlock[]; // A stack containing `with` blocks.

return transformSourceFile;

function transformSourceFile(node: SourceFile) {

if (isDeclarationFile(node)

|| (node.transformFlags & TransformFlags.ContainsGenerator) === 0) {

return node;

}

currentSourceFile = node;

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

addEmitHelpers(visited, context.readEmitHelpers());

currentSourceFile = undefined;

return visited;

}

/**

* Visits a node.

*

* @param node The node to visit.

*/

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

const transformFlags = node.transformFlags;

if (inStatementContainingYield) {

return visitJavaScriptInStatementContainingYield(node);

}

else if (inGeneratorFunctionBody) {

return visitJavaScriptInGeneratorFunctionBody(node);

}

else if (transformFlags & TransformFlags.Generator) {

return visitGenerator(node);

}

else if (transformFlags & TransformFlags.ContainsGenerator) {

return visitEachChild(node, visitor, context);

}

else {

return node;

}

}

/**

* Visits a node that is contained within a statement that contains yield.

*

* @param node The node to visit.

*/

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

switch (node.kind) {

case SyntaxKind.DoStatement:

return visitDoStatement(<DoStatement>node);

case SyntaxKind.WhileStatement:

return visitWhileStatement(<WhileStatement>node);

case SyntaxKind.SwitchStatement:

return visitSwitchStatement(<SwitchStatement>node);

case SyntaxKind.LabeledStatement:

return visitLabeledStatement(<LabeledStatement>node);

default:

return visitJavaScriptInGeneratorFunctionBody(node);

}

}

/**

* Visits a node that is contained within a generator function.

*

* @param node The node to visit.

*/

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

switch (node.kind) {

case SyntaxKind.FunctionDeclaration:

return visitFunctionDeclaration(<FunctionDeclaration>node);

case SyntaxKind.FunctionExpression:

return visitFunctionExpression(<FunctionExpression>node);

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

return visitAccessorDeclaration(<AccessorDeclaration>node);

case SyntaxKind.VariableStatement:

return visitVariableStatement(<VariableStatement>node);

case SyntaxKind.ForStatement:

return visitForStatement(<ForStatement>node);

case SyntaxKind.ForInStatement:

return visitForInStatement(<ForInStatement>node);

case SyntaxKind.BreakStatement:

return visitBreakStatement(<BreakStatement>node);

case SyntaxKind.ContinueStatement:

return visitContinueStatement(<ContinueStatement>node);

case SyntaxKind.ReturnStatement:

return visitReturnStatement(<ReturnStatement>node);

default:

if (node.transformFlags & TransformFlags.ContainsYield) {

return visitJavaScriptContainingYield(node);

}

else if (node.transformFlags & (TransformFlags.ContainsGenerator | TransformFlags.ContainsHoistedDeclarationOrCompletion)) {

return visitEachChild(node, visitor, context);

}

else {

return node;

}

}

}

/**

* Visits a node that contains a YieldExpression.

*

* @param node The node to visit.

*/

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

switch (node.kind) {

case SyntaxKind.BinaryExpression:

return visitBinaryExpression(<BinaryExpression>node);

case SyntaxKind.ConditionalExpression:

return visitConditionalExpression(<ConditionalExpression>node);

case SyntaxKind.YieldExpression:

return visitYieldExpression(<YieldExpression>node);

case SyntaxKind.ArrayLiteralExpression:

return visitArrayLiteralExpression(<ArrayLiteralExpression>node);

case SyntaxKind.ObjectLiteralExpression:

return visitObjectLiteralExpression(<ObjectLiteralExpression>node);

case SyntaxKind.ElementAccessExpression:

return visitElementAccessExpression(<ElementAccessExpression>node);

case SyntaxKind.CallExpression:

return visitCallExpression(<CallExpression>node);

case SyntaxKind.NewExpression:

return visitNewExpression(<NewExpression>node);

default:

return visitEachChild(node, visitor, context);

}

}

/**

* Visits a generator function.

*

* @param node The node to visit.

*/

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

switch (node.kind) {

case SyntaxKind.FunctionDeclaration:

return visitFunctionDeclaration(<FunctionDeclaration>node);

case SyntaxKind.FunctionExpression:

return visitFunctionExpression(<FunctionExpression>node);

default:

Debug.failBadSyntaxKind(node);

return visitEachChild(node, visitor, context);

}

}

/**

* Visits a function declaration.

*

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

* - The function declaration is a generator function.

* - The function declaration is contained within the body of a generator function.

*

* @param node The node to visit.

*/

function visitFunctionDeclaration(node: FunctionDeclaration): Statement {

// Currently, we only support generators that were originally async functions.

if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) {

node = setOriginalNode(

createFunctionDeclaration(

/*decorators*/ undefined,

node.modifiers,

/*asteriskToken*/ undefined,

node.name,

/*typeParameters*/ undefined,

visitParameterList(node.parameters, visitor, context),

/*type*/ undefined,

transformGeneratorFunctionBody(node.body),

/*location*/ node

),

node

);

}

else {

const savedInGeneratorFunctionBody = inGeneratorFunctionBody;

const savedInStatementContainingYield = inStatementContainingYield;

inGeneratorFunctionBody = false;

inStatementContainingYield = false;

node = visitEachChild(node, visitor, context);

inGeneratorFunctionBody = savedInGeneratorFunctionBody;

inStatementContainingYield = savedInStatementContainingYield;

}

if (inGeneratorFunctionBody) {

// Function declarations in a generator function body are hoisted

// to the top of the lexical scope and elided from the current statement.

hoistFunctionDeclaration(node);

return undefined;

}

else {

return node;

}

}

/**

* Visits a function expression.

*

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

* - The function expression is a generator function.

* - The function expression is contained within the body of a generator function.

*

* @param node The node to visit.

*/

function visitFunctionExpression(node: FunctionExpression): Expression {

// Currently, we only support generators that were originally async functions.

if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) {

node = setOriginalNode(

createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

node.name,

/*typeParameters*/ undefined,

visitParameterList(node.parameters, visitor, context),

/*type*/ undefined,

transformGeneratorFunctionBody(node.body),

/*location*/ node

),

node

);

}

else {

const savedInGeneratorFunctionBody = inGeneratorFunctionBody;

const savedInStatementContainingYield = inStatementContainingYield;

inGeneratorFunctionBody = false;

inStatementContainingYield = false;

node = visitEachChild(node, visitor, context);

inGeneratorFunctionBody = savedInGeneratorFunctionBody;

inStatementContainingYield = savedInStatementContainingYield;

}

return node;

}

/**

* Visits a get or set accessor declaration.

*

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

* - The accessor is contained within the body of a generator function.

*

* @param node The node to visit.

*/

function visitAccessorDeclaration(node: AccessorDeclaration) {

const savedInGeneratorFunctionBody = inGeneratorFunctionBody;

const savedInStatementContainingYield = inStatementContainingYield;

inGeneratorFunctionBody = false;

inStatementContainingYield = false;

node = visitEachChild(node, visitor, context);

inGeneratorFunctionBody = savedInGeneratorFunctionBody;

inStatementContainingYield = savedInStatementContainingYield;

return node;

}

/**

* Transforms the body of a generator function declaration.

*

* @param node The function body to transform.

*/

function transformGeneratorFunctionBody(body: Block) {

// Save existing generator state

const statements: Statement[] = [];

const savedInGeneratorFunctionBody = inGeneratorFunctionBody;

const savedInStatementContainingYield = inStatementContainingYield;

const savedBlocks = blocks;

const savedBlockOffsets = blockOffsets;

const savedBlockActions = blockActions;

const savedBlockStack = blockStack;

const savedLabelOffsets = labelOffsets;

const savedLabelExpressions = labelExpressions;

const savedNextLabelId = nextLabelId;

const savedOperations = operations;

const savedOperationArguments = operationArguments;

const savedOperationLocations = operationLocations;

const savedState = state;

// Initialize generator state

inGeneratorFunctionBody = true;

inStatementContainingYield = false;

blocks = undefined;

blockOffsets = undefined;

blockActions = undefined;

blockStack = undefined;

labelOffsets = undefined;

labelExpressions = undefined;

nextLabelId = 1;

operations = undefined;

operationArguments = undefined;

operationLocations = undefined;

state = createTempVariable(/*recordTempVariable*/ undefined);

// Build the generator

resumeLexicalEnvironment();

const statementOffset = addPrologueDirectives(statements, body.statements, /*ensureUseStrict*/ false, visitor);

transformAndEmitStatements(body.statements, statementOffset);

const buildResult = build();

addRange(statements, endLexicalEnvironment());

statements.push(createReturn(buildResult));

// Restore previous generator state

inGeneratorFunctionBody = savedInGeneratorFunctionBody;

inStatementContainingYield = savedInStatementContainingYield;

blocks = savedBlocks;

blockOffsets = savedBlockOffsets;

blockActions = savedBlockActions;

blockStack = savedBlockStack;

labelOffsets = savedLabelOffsets;

labelExpressions = savedLabelExpressions;

nextLabelId = savedNextLabelId;

operations = savedOperations;

operationArguments = savedOperationArguments;

operationLocations = savedOperationLocations;

state = savedState;

return createBlock(statements, /*location*/ body, body.multiLine);

}

/**

* Visits a variable statement.

*

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

* - The variable statement is contained within the body of a generator function.

*

* @param node The node to visit.

*/

function visitVariableStatement(node: VariableStatement): Statement {

if (node.transformFlags & TransformFlags.ContainsYield) {

transformAndEmitVariableDeclarationList(node.declarationList);

return undefined;

}

else {

// Do not hoist custom prologues.

if (getEmitFlags(node) & EmitFlags.CustomPrologue) {

return node;

}

for (const variable of node.declarationList.declarations) {

hoistVariableDeclaration(<Identifier>variable.name);

}

const variables = getInitializedVariables(node.declarationList);

if (variables.length === 0) {

return undefined;

}

return createStatement(

inlineExpressions(

map(variables, transformInitializedVariable)

)

);

}

}

/**

* Visits a binary expression.

*

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

* - The node contains a YieldExpression.

*

* @param node The node to visit.

*/

function visitBinaryExpression(node: BinaryExpression): Expression {

switch (getExpressionAssociativity(node)) {

case Associativity.Left:

return visitLeftAssociativeBinaryExpression(node);

case Associativity.Right:

return visitRightAssociativeBinaryExpression(node);

default:

Debug.fail("Unknown associativity.");

}

}

function isCompoundAssignment(kind: BinaryOperator): kind is CompoundAssignmentOperator {

return kind >= SyntaxKind.FirstCompoundAssignment

&& kind <= SyntaxKind.LastCompoundAssignment;

}

function getOperatorForCompoundAssignment(kind: CompoundAssignmentOperator): BitwiseOperatorOrHigher {

switch (kind) {

case SyntaxKind.PlusEqualsToken: return SyntaxKind.PlusToken;

case SyntaxKind.MinusEqualsToken: return SyntaxKind.MinusToken;

case SyntaxKind.AsteriskEqualsToken: return SyntaxKind.AsteriskToken;

case SyntaxKind.AsteriskAsteriskEqualsToken: return SyntaxKind.AsteriskAsteriskToken;

case SyntaxKind.SlashEqualsToken: return SyntaxKind.SlashToken;

case SyntaxKind.PercentEqualsToken: return SyntaxKind.PercentToken;

case SyntaxKind.LessThanLessThanEqualsToken: return SyntaxKind.LessThanLessThanToken;

case SyntaxKind.GreaterThanGreaterThanEqualsToken: return SyntaxKind.GreaterThanGreaterThanToken;

case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: return SyntaxKind.GreaterThanGreaterThanGreaterThanToken;

case SyntaxKind.AmpersandEqualsToken: return SyntaxKind.AmpersandToken;

case SyntaxKind.BarEqualsToken: return SyntaxKind.BarToken;

case SyntaxKind.CaretEqualsToken: return SyntaxKind.CaretToken;

}

}

/**

* Visits a right-associative binary expression containing `yield`.

*

* @param node The node to visit.

*/

function visitRightAssociativeBinaryExpression(node: BinaryExpression) {

const { left, right } = node;

if (containsYield(right)) {

let target: Expression;

switch (left.kind) {

case SyntaxKind.PropertyAccessExpression:

// [source]

// a.b = yield;

//

// [intermediate]

// .local _a

// _a = a;

// .yield resumeLabel

// .mark resumeLabel

// _a.b = %sent%;

target = updatePropertyAccess(

<PropertyAccessExpression>left,

cacheExpression(visitNode((<PropertyAccessExpression>left).expression, visitor, isLeftHandSideExpression)),

(<PropertyAccessExpression>left).name

);

break;

case SyntaxKind.ElementAccessExpression:

// [source]

// a[b] = yield;

//

// [intermediate]

// .local _a, _b

// _a = a;

// _b = b;

// .yield resumeLabel

// .mark resumeLabel

// _a[_b] = %sent%;

target = updateElementAccess(<ElementAccessExpression>left,

cacheExpression(visitNode((<ElementAccessExpression>left).expression, visitor, isLeftHandSideExpression)),

cacheExpression(visitNode((<ElementAccessExpression>left).argumentExpression, visitor, isExpression))

);

break;

default:

target = visitNode(left, visitor, isExpression);

break;

}

const operator = node.operatorToken.kind;

if (isCompoundAssignment(operator)) {

return createBinary(

target,

SyntaxKind.EqualsToken,

createBinary(

cacheExpression(target),

getOperatorForCompoundAssignment(operator),

visitNode(right, visitor, isExpression),

node

),

node

);

}

else {

return updateBinary(node, target, visitNode(right, visitor, isExpression));

}

}

return visitEachChild(node, visitor, context);

}

function visitLeftAssociativeBinaryExpression(node: BinaryExpression) {

if (containsYield(node.right)) {

if (isLogicalOperator(node.operatorToken.kind)) {

return visitLogicalBinaryExpression(node);

}

else if (node.operatorToken.kind === SyntaxKind.CommaToken) {

return visitCommaExpression(node);

}

// [source]

// a() + (yield) + c()

//

// [intermediate]

// .local _a

// _a = a();

// .yield resumeLabel

// _a + %sent% + c()

const clone = getMutableClone(node);

clone.left = cacheExpression(visitNode(node.left, visitor, isExpression));

clone.right = visitNode(node.right, visitor, isExpression);

return clone;

}

return visitEachChild(node, visitor, context);

}

/**

* Visits a logical binary expression containing `yield`.

*

* @param node A node to visit.

*/

function visitLogicalBinaryExpression(node: BinaryExpression) {

// Logical binary expressions (`&&` and `||`) are shortcutting expressions and need

// to be transformed as such:

//

// [source]

// x = a() && yield;

//

// [intermediate]

// .local _a

// _a = a();

// .brfalse resultLabel, (_a)

// .yield resumeLabel

// .mark resumeLabel

// _a = %sent%;

// .mark resultLabel

// x = _a;

//

// [source]

// x = a() || yield;

//

// [intermediate]

// .local _a

// _a = a();

// .brtrue resultLabel, (_a)

// .yield resumeLabel

// .mark resumeLabel

// _a = %sent%;

// .mark resultLabel

// x = _a;

const resultLabel = defineLabel();

const resultLocal = declareLocal();

emitAssignment(resultLocal, visitNode(node.left, visitor, isExpression), /*location*/ node.left);

if (node.operatorToken.kind === SyntaxKind.AmpersandAmpersandToken) {

// Logical `&&` shortcuts when the left-hand operand is falsey.

emitBreakWhenFalse(resultLabel, resultLocal, /*location*/ node.left);

}

else {

// Logical `||` shortcuts when the left-hand operand is truthy.

emitBreakWhenTrue(resultLabel, resultLocal, /*location*/ node.left);

}

emitAssignment(resultLocal, visitNode(node.right, visitor, isExpression), /*location*/ node.right);

markLabel(resultLabel);

return resultLocal;

}

/**

* Visits a comma expression containing `yield`.

*

* @param node The node to visit.

*/

function visitCommaExpression(node: BinaryExpression) {

// [source]

// x = a(), yield, b();

//

// [intermediate]

// a();

// .yield resumeLabel

// .mark resumeLabel

// x = %sent%, b();

let pendingExpressions: Expression[] = [];

visit(node.left);

visit(node.right);

return inlineExpressions(pendingExpressions);

function visit(node: Expression) {

if (isBinaryExpression(node) && node.operatorToken.kind === SyntaxKind.CommaToken) {

visit(node.left);

visit(node.right);

}

else {

if (containsYield(node) && pendingExpressions.length > 0) {

emitWorker(OpCode.Statement, [createStatement(inlineExpressions(pendingExpressions))]);

pendingExpressions = [];

}

pendingExpressions.push(visitNode(node, visitor, isExpression));

}

}

}

/**

* Visits a conditional expression containing `yield`.

*

* @param node The node to visit.

*/

function visitConditionalExpression(node: ConditionalExpression): Expression {

// [source]

// x = a() ? yield : b();

//

// [intermediate]

// .local _a

// .brfalse whenFalseLabel, (a())

// .yield resumeLabel

// .mark resumeLabel

// _a = %sent%;

// .br resultLabel

// .mark whenFalseLabel

// _a = b();

// .mark resultLabel

// x = _a;

// We only need to perform a specific transformation if a `yield` expression exists

// in either the `whenTrue` or `whenFalse` branches.

// A `yield` in the condition will be handled by the normal visitor.

if (containsYield(node.whenTrue) || containsYield(node.whenFalse)) {

const whenFalseLabel = defineLabel();

const resultLabel = defineLabel();

const resultLocal = declareLocal();

emitBreakWhenFalse(whenFalseLabel, visitNode(node.condition, visitor, isExpression), /*location*/ node.condition);

emitAssignment(resultLocal, visitNode(node.whenTrue, visitor, isExpression), /*location*/ node.whenTrue);

emitBreak(resultLabel);

markLabel(whenFalseLabel);

emitAssignment(resultLocal, visitNode(node.whenFalse, visitor, isExpression), /*location*/ node.whenFalse);

markLabel(resultLabel);

return resultLocal;

}

return visitEachChild(node, visitor, context);

}

/**

* Visits a `yield` expression.

*

* @param node The node to visit.

*/

function visitYieldExpression(node: YieldExpression): LeftHandSideExpression {

// [source]

// x = yield a();

//

// [intermediate]

// .yield resumeLabel, (a())

// .mark resumeLabel

// x = %sent%;

// NOTE: we are explicitly not handling YieldStar at this time.

const resumeLabel = defineLabel();

const expression = visitNode(node.expression, visitor, isExpression);

if (node.asteriskToken) {

emitYieldStar(expression, /*location*/ node);

}

else {

emitYield(expression, /*location*/ node);

}

markLabel(resumeLabel);

return createGeneratorResume(/*location*/ node);

}

/**

* Visits an ArrayLiteralExpression that contains a YieldExpression.

*

* @param node The node to visit.

*/

function visitArrayLiteralExpression(node: ArrayLiteralExpression) {

return visitElements(node.elements, /*leadingElement*/ undefined, /*location*/ undefined, node.multiLine);

}

/**

* Visits an array of expressions containing one or more YieldExpression nodes

* and returns an expression for the resulting value.

*

* @param elements The elements to visit.

* @param multiLine Whether array literals created should be emitted on multiple lines.

*/

function visitElements(elements: NodeArray<Expression>, leadingElement?: Expression, location?: TextRange, multiLine?: boolean) {

// [source]

// ar = [1, yield, 2];

//

// [intermediate]

// .local _a

// _a = [1];

// .yield resumeLabel

// .mark resumeLabel

// ar = _a.concat([%sent%, 2]);

const numInitialElements = countInitialNodesWithoutYield(elements);

const temp = declareLocal();

let hasAssignedTemp = false;

if (numInitialElements > 0) {

const initialElements = visitNodes(elements, visitor, isExpression, 0, numInitialElements);

emitAssignment(temp,

createArrayLiteral(

leadingElement

? [leadingElement, ...initialElements]

: initialElements

)

);

leadingElement = undefined;

hasAssignedTemp = true;

}

const expressions = reduceLeft(elements, reduceElement, <Expression[]>[], numInitialElements);

return hasAssignedTemp

? createArrayConcat(temp, [createArrayLiteral(expressions, /*location*/ undefined, multiLine)])

: createArrayLiteral(leadingElement ? [leadingElement, ...expressions] : expressions, location, multiLine);

function reduceElement(expressions: Expression[], element: Expression) {

if (containsYield(element) && expressions.length > 0) {

emitAssignment(

temp,

hasAssignedTemp

? createArrayConcat(

temp,

[createArrayLiteral(expressions, /*location*/ undefined, multiLine)]

)