Genertor transpilation pass uses two sets of node properties: *
The conversion is done in the following steps: * *
function *() {}
* {@code Es6RewriteGenerators} depends on {@link Es6InjectRuntimeLibraries} to inject
* generator_engine.js template.
*/
final class Es6RewriteGenerators implements HotSwapCompilerPass {
private static final String GENERATOR_FUNCTION = "$jscomp$generator$function";
private static final String GENERATOR_CONTEXT = "$jscomp$generator$context";
private static final String GENERATOR_ARGUMENTS = "$jscomp$generator$arguments";
private static final String GENERATOR_THIS = "$jscomp$generator$this";
private static final String GENERATOR_FORIN_PREFIX = "$jscomp$generator$forin$";
private static final FeatureSet transpiledFeatures =
FeatureSet.BARE_MINIMUM.with(Feature.GENERATORS);
private final AbstractCompiler compiler;
private final JSTypeRegistry registry;
private final boolean shouldAddTypes;
private final JSType unknownType;
private final JSType numberType;
private final JSType booleanType;
private final JSType nullType;
private final JSType nullableStringType;
private final JSType voidType;
Es6RewriteGenerators(AbstractCompiler compiler) {
checkNotNull(compiler);
this.compiler = compiler;
registry = compiler.getTypeRegistry();
if (compiler.hasTypeCheckingRun()) {
// typechecking has run, so we must preserve and propagate type information
shouldAddTypes = true;
unknownType = registry.getNativeType(JSTypeNative.UNKNOWN_TYPE);
numberType = registry.getNativeType(JSTypeNative.NUMBER_TYPE);
booleanType = registry.getNativeType(JSTypeNative.BOOLEAN_TYPE);
nullType = registry.getNativeType(JSTypeNative.NULL_TYPE);
nullableStringType =
registry.createNullableType(registry.getNativeType(JSTypeNative.STRING_TYPE));
voidType = registry.getNativeType(JSTypeNative.VOID_TYPE);
} else {
shouldAddTypes = false;
unknownType = null;
numberType = null;
booleanType = null;
nullType = null;
nullableStringType = null;
voidType = null;
}
}
@Override
public void process(Node externs, Node root) {
TranspilationPasses.processTranspile(
compiler, root, transpiledFeatures, new GeneratorFunctionsTranspiler());
TranspilationPasses.maybeMarkFeaturesAsTranspiledAway(compiler, transpiledFeatures);
}
@Override
public void hotSwapScript(Node scriptRoot, Node originalRoot) {
TranspilationPasses.hotSwapTranspile(
compiler, scriptRoot, transpiledFeatures, new GeneratorFunctionsTranspiler());
TranspilationPasses.maybeMarkFeaturesAsTranspiledAway(compiler, transpiledFeatures);
}
/**
* Exposes expression with yield inside to an equivalent expression in which yield is of the form:
*
*
* var name = yield expr; ** *
For example, changes the following code: * *
* { return x || yield y; }
*
*
* into:
*
*
* {
* var temp$$0;
* if (temp$$0 = x); else temp$$0 = yield y;
* return temp$$0;
* }
*
*
* Expression should always be inside a block, so that other statements could be added at need. * *
Uses the {@link ExpressionDecomposer} class. */ private class YieldExposer extends NodeTraversal.AbstractPreOrderCallback { final ExpressionDecomposer decomposer; YieldExposer() { decomposer = new ExpressionDecomposer( compiler, compiler.getUniqueNameIdSupplier(), new HashSet<>(), Scope.createGlobalScope(new Node(Token.SCRIPT)), /* allowMethodCallDecomposing = */ true); } @Override public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) { n.setGeneratorMarker(false); if (n.isFunction()) { return false; } if (n.isYield()) { visitYield(n); return false; } return true; } void visitYield(Node n) { if (n.getParent().isExprResult()) { return; } if (decomposer.canExposeExpression(n) != ExpressionDecomposer.DecompositionType.UNDECOMPOSABLE) { decomposer.exposeExpression(n); } else { String link = "https://github.com/google/closure-compiler/wiki/FAQ" + "#i-get-an-undecomposable-expression-error-for-my-yield-or-await-expression" + "-what-do-i-do"; String suggestion = "Please rewrite the yield or await as a separate statement."; String message = "Undecomposable expression: " + suggestion + "\nSee " + link; compiler.report(JSError.make(n, Es6ToEs3Util.CANNOT_CONVERT, message)); } } } /** Finds generator functions and performs ES6 -> ES3 trnspilation */ private class GeneratorFunctionsTranspiler implements NodeTraversal.Callback { int generatorNestingLevel = 0; @Override public boolean shouldTraverse(NodeTraversal nodeTraversal, Node n, Node parent) { if (n.isGeneratorFunction()) { ++generatorNestingLevel; } return true; } @Override public void visit(NodeTraversal t, Node n, Node parent) { if (n.isGeneratorFunction()) { new SingleGeneratorFunctionTranspiler(n, --generatorNestingLevel).transpile(); } } } /** Transpiles a single generator function into a state machine program. */ private class SingleGeneratorFunctionTranspiler { final int generatorNestingLevel; /** The transpilation context for the state machine program. */ final TranspilationContext context; /** The body of original generator function that should be transpiled */ final Node originalGeneratorBody; /** * The body of a replacement function. * *
It's a block node that hoists local variables of a generator program and returns an * actual generator object created from that program: *
* {
* var a;
* var b;
* ...
* return createGenerator(function ($jscomp$generator$context) { ... });
* }
*
* The assumtion is that the hoist block always ends with a return statement, and all local
* variables are added before this "return" statement.
*/
Node newGeneratorHoistBlock;
/** The original inferred return type of the Generator */
JSType originalGenReturnType;
JSType yieldType;
SingleGeneratorFunctionTranspiler(Node genFunc, int genaratorNestingLevel) {
this.generatorNestingLevel = genaratorNestingLevel;
this.originalGeneratorBody = genFunc.getLastChild();
ObjectType contextType = null;
if (shouldAddTypes) {
// Find the yield type of the generator.
// e.g. given @return {!Generator
* function() {
* ...
* return $jscomp.asyncExecutePromiseGeneratorFunction(function* genFunc() {...});
* }
*
*/
private boolean isTranspiledAsyncFunction(Node generatorFunction) {
if (generatorFunction.getParent().isCall() && generatorFunction.getPrevious() != null) {
Node callTarget = generatorFunction.getParent().getFirstChild();
if (generatorFunction.getPrevious() == callTarget && generatorFunction.getNext() == null
&& callTarget.matchesQualifiedName("$jscomp.asyncExecutePromiseGeneratorFunction")) {
checkState(generatorFunction.getGrandparent().isReturn());
checkState(generatorFunction.getGrandparent().getNext() == null);
return true;
}
}
return false;
}
public void transpile() {
Node generatorFunction = originalGeneratorBody.getParent();
checkState(generatorFunction.isGeneratorFunction());
generatorFunction.putBooleanProp(Node.GENERATOR_FN, false);
// A "program" function:
// function ($jscomp$generator$context) {
// }
final Node program;
JSType programType = shouldAddTypes
// function(!Contextyields. */
void transpileUnmarkedNode(Node n) {
checkState(!n.isGeneratorMarker());
if (n.isFunction()) {
// All function statemnts will be normalized:
// "function a() {}" => "var a = function() {};"
// so we have to move them to the outer scope.
String functionName = n.getFirstChild().getString();
// Make sure there are no "function (...) {...}" statements (note that
// "function *(...) {...}" becomes "function $jscomp$generator$function(...) {...}" as
// inner generator functions are transpiled first).
checkState(!functionName.isEmpty() && !functionName.startsWith(GENERATOR_FUNCTION));
hoistNode(n);
return;
}
context.transpileUnmarkedBlock(n.isBlock() || n.isAddedBlock() ? n : IR.block(n));
}
/** Transpiles a label with marked statement. */
void transpileLabel(Node n) {
// Collect all labels names in "a: b: c: {}" statement
ArrayListIt's OK for this method to return false-negatives.
*/
private boolean isEndOfBlockUnreachable(Node block) {
checkState(block.isBlock());
if (!block.hasChildren()) {
return false;
}
switch (block.getLastChild().getToken()) {
case BLOCK:
return isEndOfBlockUnreachable(block.getLastChild());
case RETURN:
case THROW:
case CONTINUE:
case BREAK:
return true;
default:
return false;
}
}
/** State machine context that is used during generator function transpilation. */
private class TranspilationContext {
final HashMap This optimization is needed to reduce number of switch cases, which is used then to
* generate even shorter state machine programs.
*/
void optimizeCaseIds() {
checkState(!allCases.isEmpty(), allCases);
// Shortcut jump chains:
// case 100:
// $context.yield("something", 101);
// break;
// case 101:
// $context.jumpTo(102);
// break;
// case 102:
// $context.jumpTo(200);
// break;
// becomes:
// case 100:
// $context.yield("something", 200);
// break;
// case 101:
// $context.jumpTo(102);
// break;
// case 102:
// $context.jumpTo(200);
// break;
for (Case currentCase : allCases) {
if (currentCase.jumpTo != null) {
// Flatten jumps chains:
// 1 -> 2
// 2 -> 8
// 8 -> 300
// to:
// 1 -> 300
// 2 -> 300
// 8 -> 300
while (currentCase.jumpTo.jumpTo != null) {
currentCase.jumpTo = currentCase.jumpTo.jumpTo;
}
if (currentCase.embedInto != null && currentCase.references.size() == 1) {
currentCase.jumpTo.embedInto = currentCase.embedInto;
}
currentCase.embedInto = null;
// Update references to jump to the final case in the chain
for (Node reference : currentCase.references) {
reference.setDouble(currentCase.jumpTo.id);
}
currentCase.jumpTo.references.addAll(currentCase.references);
currentCase.references.clear();
}
}
// Merge cases without any references with the previous case:
// case 100:
// doSomething();
// case 101:
// doSomethingElse();
// break;
// case 102:
// doEvenMore();
// becomes:
// case 100:
// doSomething();
// doSomethingElse();
// break;
Iterator This is used to be able to generatate a state machine program outside of "swtich"
* statement so:
*
* It's used to drop unreferenced sections.
*/
final ArrayList Usually " {@link #addNode} cannot be invoked after this method is called.
*/
void jumpTo(Case other, Node jumpBlock) {
checkState(jumpBlock.isBlock());
checkState(jumpTo == null);
willFollowBy(other);
caseBlock.addChildrenToBack(jumpBlock.removeChildren());
mayFallThrough = false;
}
/**
* Informs which other case will be executed after this one.
*
* It's used to detect and then eliminate case statements that are used as simple jump
* hops:
*
* The following transformations are performed:
*
*
*
*
*
*
*
* for (var i in expr) {} will be converted into
* for (var i, $for$in = $context.forIn(expr); i = $for$in.getNext(); ) {}
*/
void transpileForIn(
Node n,
@Nullable TranspilationContext.Case breakCase,
@Nullable TranspilationContext.Case continueCase) {
// Decompose condition first
Node detachedExpr = maybeDecomposeExpression(n.getSecondChild().detach());
Node target = n.getFirstChild();
Node body = n.getSecondChild();
// No transpilation is needed
if (!target.isGeneratorMarker() && !body.isGeneratorMarker()) {
n.addChildAfter(detachedExpr, target);
n.setGeneratorMarker(false);
transpileUnmarkedNode(n);
return;
}
// Prepare a new init statement
final Node init;
if (target.detach().isVar()) {
// "var i in x" => "var i"
checkState(!target.isGeneratorMarker());
init = target;
checkState(!init.getFirstChild().hasChildren());
target = init.getFirstChild().cloneNode();
} else {
// "i in x" => "var"
init = new Node(Token.VAR).useSourceInfoFrom(target);
}
// "$for$in"
Node forIn =
context
.getScopedName(GENERATOR_FORIN_PREFIX + compiler.getUniqueNameIdSupplier().get())
.useSourceInfoFrom(target);
// "$context.forIn(x)"
forIn.addChildToFront(context.callContextMethod(target, "forIn", detachedExpr));
ObjectType propertyIteratorType =
shouldAddTypes ? forIn.getFirstChild().getJSType().toMaybeObjectType() : null;
forIn.setJSType(propertyIteratorType);
// "var ..., $for$in = $context.forIn(expr)"
init.addChildToBack(forIn);
// "$for$in.getNext()"
Node forInGetNext =
withType(
IR.getprop(
forIn.cloneNode(), IR.string("getNext").useSourceInfoFrom(detachedExpr)),
shouldAddTypes ? propertyIteratorType.getPropertyType("getNext") : null)
.useSourceInfoFrom(detachedExpr);
// "(i = $for$in.getNext()) != null"
Node forCond =
withType(IR.ne(
withType(IR.assign(
withType(target, nullableStringType),
withType(IR.call(forInGetNext), nullableStringType)
.useSourceInfoFrom(detachedExpr)), nullableStringType)
.useSourceInfoFrom(detachedExpr),
withType(IR.nullNode(), nullType).useSourceInfoFrom(forIn)), booleanType)
.useSourceInfoFrom(detachedExpr);
forCond.setGeneratorMarker(target.isGeneratorMarker());
// Prepare "for" statement.
// "for (var i, $for$in = $context.forIn(expr); (i = $for$in.getNext()) != null; ) {}"
Node forNode =
IR.forNode(init, forCond, IR.empty().useSourceInfoFrom(n), body.detach())
.useSourceInfoFrom(n);
// Transpile "for" instead of "for in".
transpileFor(forNode, breakCase, continueCase);
}
/** Transpiles "while" statement. */
void transpileWhile(
Node n,
@Nullable TranspilationContext.Case breakCase,
@Nullable TranspilationContext.Case continueCase) {
TranspilationContext.Case startCase = context.maybeCreateCase(continueCase);
TranspilationContext.Case endCase = context.maybeCreateCase(breakCase);
context.switchCaseTo(startCase);
// Transpile condition
Node condition = prepareNodeForWrite(maybeDecomposeExpression(n.removeFirstChild()));
Node body = n.removeFirstChild();
context.writeGeneratedNode(
IR.ifNode(
withType(IR.not(condition), booleanType).useSourceInfoFrom(condition),
context.createJumpToBlock(
endCase,
/** allowEmbedding= */
true,
n))
.useSourceInfoFrom(n));
// Transpile "while" body
context.pushBreakContinueContext(endCase, startCase);
transpileStatement(body);
context.popBreakContinueContext();
context.writeJumpTo(startCase, n);
context.switchCaseTo(endCase);
}
/** Transpiles "do while" statement. */
void transpileDo(
Node n,
@Nullable TranspilationContext.Case breakCase,
@Nullable TranspilationContext.Case continueCase) {
TranspilationContext.Case startCase = context.createCase();
breakCase = context.maybeCreateCase(breakCase);
continueCase = context.maybeCreateCase(continueCase);
context.switchCaseTo(startCase);
// Transpile body
Node body = n.removeFirstChild();
context.pushBreakContinueContext(breakCase, continueCase);
transpileStatement(body);
context.popBreakContinueContext();
// Transpile condition
context.switchCaseTo(continueCase);
Node condition = prepareNodeForWrite(maybeDecomposeExpression(n.removeFirstChild()));
context.writeGeneratedNode(
IR.ifNode(condition, context.createJumpToBlock(startCase, /** allowEmbedding=*/ false, n))
.useSourceInfoFrom(n));
context.switchCaseTo(breakCase);
}
/** Transpiles "try" statement */
void transpileTry(Node n, @Nullable TranspilationContext.Case breakCase) {
Node tryBlock = n.removeFirstChild();
Node catchBlock = n.removeFirstChild();
Node finallyBlock = n.removeFirstChild();
TranspilationContext.Case catchCase = catchBlock.hasChildren() ? context.createCase() : null;
TranspilationContext.Case finallyCase = finallyBlock == null ? null : context.createCase();
TranspilationContext.Case endCase = context.maybeCreateCase(breakCase);
// Transpile "try" block
context.enterTryBlock(catchCase, finallyCase, tryBlock);
transpileStatement(tryBlock);
if (finallyBlock == null) {
context.leaveTryBlock(catchCase, endCase, tryBlock);
} else {
// Transpile "finally" block
context.switchCaseTo(finallyCase);
context.enterFinallyBlock(catchCase, finallyCase, finallyBlock);
transpileStatement(finallyBlock);
context.leaveFinallyBlock(endCase, finallyBlock);
}
// Transpile "catch" block
if (catchBlock.hasChildren()) {
checkState(catchBlock.getFirstChild().isCatch());
context.switchCaseTo(catchCase);
Node exceptionName = catchBlock.getFirstFirstChild().detach();
context.enterCatchBlock(finallyCase, exceptionName);
Node catchBody = catchBlock.getFirstFirstChild().detach();
checkState(catchBody.isBlock());
transpileStatement(catchBody);
context.leaveCatchBlock(finallyCase, catchBody);
}
context.switchCaseTo(endCase);
}
// Transpiles "switch" statement.
void transpileSwitch(Node n, @Nullable TranspilationContext.Case breakCase) {
// Transpile condition first
n.addChildToFront(maybeDecomposeExpression(n.removeFirstChild()));
// Are all "switch" cases unmarked?
boolean hasGeneratorMarker = false;
for (Node caseSection = n.getSecondChild();
caseSection != null;
caseSection = caseSection.getNext()) {
if (caseSection.isGeneratorMarker()) {
hasGeneratorMarker = true;
break;
}
}
// No transpilation is needed
if (!hasGeneratorMarker) {
n.setGeneratorMarker(false);
transpileUnmarkedNode(n);
return;
}
/** Stores a detached body of a case statement and a case section assosiated with it. */
class SwitchCase {
private final TranspilationContext.Case generatedCase;
private final Node body;
SwitchCase(TranspilationContext.Case generatedCase, Node caseNode) {
this.generatedCase = generatedCase;
this.body = caseNode;
}
}
// TODO(skill): Don't move all case sections.
ArrayList
* $context.jumpTo(5);
* break;
*
*
* could be converted into:
*
*
* return $context.jumpTo(5);
*
*/
Node createBreakNodeFor(Node preBreak) {
Node breakNode = IR.breakNode().useSourceInfoFrom(preBreak);
switchBreaks.add(breakNode);
return breakNode;
}
/**
* Returns a node that instructs a state machine program to jump to a selected case section.
*/
Node createJumpToNode(Case section, Node sourceNode) {
return returnContextMethod(sourceNode, "jumpTo", section.getNumber(sourceNode));
}
/** Instructs a state machine program to jump to a selected case section. */
void writeJumpTo(Case section, Node sourceNode) {
currentCase.jumpTo(
section, createJumpToBlock(section, /** allowEmbedding=*/ false, sourceNode));
}
/**
* Creates a block node that contains a jump instruction.
*
* @param allowEmbedding Whether the code from the target section can be embedded into jump
* block.
*/
Node createJumpToBlock(Case section, boolean allowEmbedding, Node sourceNode) {
checkState(section.embedInto == null);
Node jumpBlock = IR.block(
callContextMethodResult(sourceNode, "jumpTo", section.getNumber(sourceNode)),
createBreakNodeFor(sourceNode))
.useSourceInfoFrom(sourceNode);
if (allowEmbedding) {
section.embedInto = jumpBlock;
}
return jumpBlock;
}
/** Converts "break" and "continue" statements into state machine jumps. */
void replaceBreakContinueWithJump(Node sourceNode, Case section, int breakSuppressors) {
final String jumpMethod;
if (finallyCases.isEmpty() || finallyCases.getFirst().id < section.id) {
// There are no finally blocks that should be exectuted pior to jumping
jumpMethod = "jumpTo";
} else {
// There are some finally blocks that should be exectuted before we can break/continue.
checkState(finallyCases.getFirst().id != section.id);
jumpMethod = "jumpThroughFinallyBlocks";
}
if (breakSuppressors == 0) {
// continue; => $context.jumpTo(x); break;
sourceNode.getParent().addChildBefore(
callContextMethodResult(sourceNode, jumpMethod, section.getNumber(sourceNode)),
sourceNode);
sourceNode.replaceWith(createBreakNodeFor(sourceNode));
} else {
// "break;" inside a loop or swtich statement:
// for (...) {
// break l1;
// }
// becomes:
// for (...) { // loop doesn't allow to use "break" to advance to the
// return $context.jumpTo(x); // next address, so "return" is used instead.
// }
sourceNode.replaceWith(
returnContextMethod(sourceNode, jumpMethod, section.getNumber(sourceNode)));
}
}
/**
* Instructs a state machine program to yield a value and then jump to a selected case
* section.
*/
void yield(
@Nullable Node expression, TranspilationContext.Case jumpToSection, Node sourceNode) {
ArrayListif (a) {b();} else { c(); }" is transpiled into:
*
* if (a) { goto labelIf; }
* c();
* goto labelEnd;
* labelIf:
* b();
* labelEnd:
*
*
* but "labelIf: b();" can be inlined to get shorter output:
*
*
* if (a) { b(); goto labelEnd; }
* c();
* labelEnd:
*
*
* In this example "labelIf" case can be embedded into "{ goto labelIf; }"
* block.
*/
@Nullable Node embedInto;
/** Tells whether this case might fall-through. */
boolean mayFallThrough = true;
/** Creates a new empty case section and assings a new id. */
Case() {
this.id = caseIdCounter++;
this.caseBlock = IR.block().useSourceInfoFrom(originalGeneratorBody);
}
Node createCaseNode() {
return IR.caseNode(
withType(IR.number(id), numberType).useSourceInfoFrom(caseBlock), caseBlock)
.useSourceInfoFrom(caseBlock);
}
/** Returns the number node of the case section and increments a reference counter. */
Node getNumber(Node sourceNode) {
if (jumpTo != null) {
return jumpTo.getNumber(sourceNode);
}
Node node = withType(IR.number(id), numberType).useSourceInfoFrom(sourceNode);
references.add(node);
return node;
}
/**
* Finalizes the case section with a jump instruction.
*
*
* case 100:
* $context.jumpTo(200);
* break;
*
*
* or
*
*
* case 300:
*
*/
void willFollowBy(Case other) {
if (jumpTo == null && !caseBlock.hasChildren()) {
checkState(other.jumpTo == null);
jumpTo = other;
}
}
/** Adds a new node to the end of the case block. */
void addNode(Node n) {
checkState(jumpTo == null);
checkState(IR.mayBeStatement(n));
caseBlock.addChildToBack(n);
}
}
/**
* Adjust YIELD-free nodes to run correctly inside a state machine program.
*
*
*
*/
private class UnmarkedNodeTranspiler implements NodeTraversal.Callback {
// Count the number of enclosing statements that a bare break could address.
// A value > 0 means that a bare break statement we encounter can be left unmodified,
// since it addresses a statement within the node we are transpiling.
int breakSuppressors;
// Same as breakSuppressors, but for bare continue statements.
int continueSuppressors;
@Override
public boolean shouldTraverse(NodeTraversal nodeTraversal, Node n, Node parent) {
if (n.isGeneratorSafe()) {
// Skip nodes that were generated by the compiler.
n.setGeneratorSafe(false);
return false;
}
checkState(!n.isGeneratorMarker());
checkState(!n.isSuper(), "Reference to SUPER is not supported");
if (NodeUtil.isLoopStructure(n)) {
++continueSuppressors;
++breakSuppressors;
} else if (n.isSwitch()) {
++breakSuppressors;
}
if (n.isBreak() || n.isContinue()) {
if (n.hasChildren()) {
visitNamedBreakContinue(n);
} else {
visitBreakContinue(n);
}
return false;
}
return !n.isFunction();
}
@Override
public void visit(NodeTraversal t, Node n, Node parent) {
if (NodeUtil.isLoopStructure(n)) {
--continueSuppressors;
--breakSuppressors;
} else if (n.isSwitch()) {
--breakSuppressors;
} else if (n.isThis()) {
visitThis(n);
} else if (n.isReturn()) {
visitReturn(n);
} else if (n.isName() && n.getString().equals("arguments")) {
visitArguments(n);
} else if (n.isVar()) {
if (parent.isVanillaFor()) {
visitVanillaForLoopVar(n);
} else if (parent.isForIn()) {
visitForInLoopVar(n);
} else {
// NOTE: for-of loops are transpiled away before this pass
visitVarStatement(n);
}
} // else no changes need to be made
}
/** Adjust return statements. */
void visitReturn(Node n) {
// return ...; => return $context.return(...);
n.addChildToFront(returnExpression(n, n.removeFirstChild()));
}
/** Converts labeled var into hois scope;
* return statements;
* break and continue statements;
* this and arguments.
* break or continue statement into a jump. */
void visitNamedBreakContinue(Node n) {
checkState(n.getFirstChild().isLabelName());
LabelCases cases = namedLabels.get(n.getFirstChild().getString());
if (cases != null) {
Case caseSection = n.isBreak() ? cases.breakCase : cases.continueCase;
context.replaceBreakContinueWithJump(n, caseSection, breakSuppressors);
}
}
/** Converts break or continue statement into a jump. */
void visitBreakContinue(Node n) {
Case caseSection = null;
if (n.isBreak() && breakSuppressors == 0) {
caseSection = breakCases.getFirst();
}
if (n.isContinue() && continueSuppressors == 0) {
caseSection = continueCases.getFirst();
}
if (caseSection != null) {
context.replaceBreakContinueWithJump(n, caseSection, breakSuppressors);
}
}
/** Replaces reference to this with $jscomp$generator$this. */
void visitThis(Node n) {
Node newThis = withType(context.getScopedName(GENERATOR_THIS), n.getJSType());
n.replaceWith(newThis);
if (!thisReferenceFound) {
Node var = IR.var(newThis.cloneNode().useSourceInfoFrom(n), n)
.useSourceInfoFrom(newGeneratorHoistBlock);
hoistNode(var);
thisReferenceFound = true;
}
}
/**
* Replaces reference to arguments with $jscomp$generator$arguments
* .
*/
void visitArguments(Node n) {
Node newArguments = context.getScopedName(GENERATOR_ARGUMENTS).useSourceInfoFrom(n);
n.replaceWith(newArguments);
if (!argumentsReferenceFound) {
Node var =
IR.var(newArguments.cloneNode(), n).useSourceInfoFrom(newGeneratorHoistBlock);
hoistNode(var);
argumentsReferenceFound = true;
}
}
/**
* Hoists {@code var} statements into the closure containing the generator to preserve their
* state across multiple invocation of state machine program.
*
*
* var a = "test", b = i + 5;
*
*
* is transpiled to:
*
*
* var a, b;
* a = "test", b = i + 5;
*
*/
void visitVarStatement(Node varStatement) {
Node commaExpression = extractAssignmentsToCommaExpression(varStatement);
if (commaExpression == null) {
varStatement.detach();
} else {
varStatement.replaceWith(IR.exprResult(commaExpression));
}
// Move declaration without initial values to just before the program method definition.
hoistNode(varStatement);
}
/**
* Hoists {@code var} declarations in vanilla for loops into the closure containing the
* generator to preserve their state across multiple invocation of state machine program.
*
*
* for (var a = "test", b = i + 5; ... ; )
*
*
* is transpiled to:
*
*
* var a, b;
* for (a = "test", b = i + 5; ...; )
*
*/
private void visitVanillaForLoopVar(Node varDeclaration) {
Node commaExpression = extractAssignmentsToCommaExpression(varDeclaration);
if (commaExpression == null) {
// `for (var x; ` becomes `for (; `
varDeclaration.replaceWith(IR.empty());
} else {
// `for (var i = 0, j = 0; `... becomes `for (i = 0, j = 0; `...
varDeclaration.replaceWith(commaExpression);
}
// Move declaration without initial values to just before the program method definition.
hoistNode(varDeclaration);
}
/**
* Hoists {@code var} declarations in for-in loops into the closure containing the
* generator to preserve their state across multiple invocation of state machine program.
*
*
* for (var a in obj)
*
*
* is transpiled to:
*
*
* var a;
* for (a in obj))
*
*/
private void visitForInLoopVar(Node varDeclaration) {
// `for (var varName in ` ...
Node varName = varDeclaration.getOnlyChild();
checkState(!varName.hasChildren(), varName);
Node clonedVarName = varName.cloneNode().setJSDocInfo(null);
// becomes `for (varName in ` ...
varDeclaration.replaceWith(clonedVarName);
// Move declaration without initial values to just before the program method definition.
hoistNode(varDeclaration);
}
/**
* Removes all initializers from a var declaration and returns them as a single expression
* of comma-separated assignments or null if there aren't any initializers.
*
* @param varDeclaration VAR node
* @return null or expression node (e.g. `varName1 = 1, varName2 = y`)
*/
@Nullable
private Node extractAssignmentsToCommaExpression(Node varDeclaration) {
ArrayList