Java Code Examples for jdk.nashorn.internal.ir.Block#accept()

@Override
public boolean enterTryNode(final TryNode tryNode) {
    tryNode.toString(sb);
    tryNode.getBody().accept(this);

    final List<Block> catchBlocks = tryNode.getCatchBlocks();

    for (final Block catchBlock : catchBlocks) {
        final CatchNode catchNode = (CatchNode)catchBlock.getStatements().get(0);
        catchNode.toString(sb);
        catchNode.getBody().accept(this);
    }

    final Block finallyBody = tryNode.getFinallyBody();

    if (finallyBody != null) {
        sb.append(" finally ");
        finallyBody.accept(this);
    }

    return false;
}
 

@Override
public boolean enterTryNode(final TryNode tryNode) {
    tryNode.toString(sb, printTypes);
    printLocalVariableConversion(tryNode);
    tryNode.getBody().accept(this);

    final List<Block> catchBlocks = tryNode.getCatchBlocks();

    for (final Block catchBlock : catchBlocks) {
        final CatchNode catchNode = (CatchNode)catchBlock.getStatements().get(0);
        catchNode.toString(sb, printTypes);
        catchNode.getBody().accept(this);
    }

    final Block finallyBody = tryNode.getFinallyBody();

    if (finallyBody != null) {
        sb.append(" finally ");
        finallyBody.accept(this);
    }

    for (final Block inlinedFinally : tryNode.getInlinedFinallies()) {
        inlinedFinally.accept(this);
    }
    return false;
}
 

@Override
public boolean enterTryNode(final TryNode tryNode) {
    tryNode.toString(sb, printTypes);
    printLocalVariableConversion(tryNode);
    tryNode.getBody().accept(this);

    final List<Block> catchBlocks = tryNode.getCatchBlocks();

    for (final Block catchBlock : catchBlocks) {
        final CatchNode catchNode = (CatchNode)catchBlock.getStatements().get(0);
        catchNode.toString(sb, printTypes);
        catchNode.getBody().accept(this);
    }

    final Block finallyBody = tryNode.getFinallyBody();

    if (finallyBody != null) {
        sb.append(" finally ");
        finallyBody.accept(this);
    }

    for (final Block inlinedFinally : tryNode.getInlinedFinallies()) {
        inlinedFinally.accept(this);
    }
    return false;
}
 

@Override
public boolean enterWhileNode(final WhileNode whileNode) {
    final Expression test          = whileNode.getTest();
    final Block      body          = whileNode.getBody();
    final Label      breakLabel    = whileNode.getBreakLabel();
    final Label      continueLabel = whileNode.getContinueLabel();
    final boolean    isDoWhile     = whileNode.isDoWhile();
    final Label      loopLabel     = new Label("loop");

    if (!isDoWhile) {
        method._goto(continueLabel);
    }

    method.label(loopLabel);
    body.accept(this);
    if (!whileNode.isTerminal()) {
        method.label(continueLabel);
        lineNumber(whileNode);
        new BranchOptimizer(this, method).execute(test, loopLabel, true);
        method.label(breakLabel);
    }

    return false;
}
 

private static void extractVarNodes(final Block block, final List<Statement> statements) {
    final LexicalContext lc = new LexicalContext();
    block.accept(lc, new NodeVisitor<LexicalContext>(lc) {
        @Override
        public boolean enterVarNode(VarNode varNode) {
            statements.add(varNode.setInit(null));
            return false;
        }
    });
}
 

private void enterFor(final ForNode forNode) {
    final Expression init   = forNode.getInit();
    final Expression test   = forNode.getTest();
    final Block      body   = forNode.getBody();
    final Expression modify = forNode.getModify();

    if (init != null) {
        init.accept(this);
    }

    final Label loopLabel = new Label("loop");
    final Label testLabel = new Label("test");

    method._goto(testLabel);
    method.label(loopLabel);
    body.accept(this);
    method.label(forNode.getContinueLabel());

    if (!body.isTerminal() && modify != null) {
        load(modify);
    }

    method.label(testLabel);
    if (test != null) {
        new BranchOptimizer(this, method).execute(test, loopLabel, true);
    } else {
        method._goto(loopLabel);
    }

    method.label(forNode.getBreakLabel());
}
 

private void enterDoWhileLoop(final WhileNode loopNode) {
    assertTypeStackIsEmpty();
    final JoinPredecessorExpression test = loopNode.getTest();
    final Block body = loopNode.getBody();
    final Label continueLabel = loopNode.getContinueLabel();
    final Label breakLabel = loopNode.getBreakLabel();
    final Map<Symbol, LvarType> beforeLoopTypes = localVariableTypes;
    final Label repeatLabel = new Label("");
    for(;;) {
        jumpToLabel(loopNode, repeatLabel, beforeLoopTypes);
        final Map<Symbol, LvarType> beforeRepeatTypes = localVariableTypes;
        body.accept(this);
        if(reachable) {
            jumpToLabel(body, continueLabel);
        }
        joinOnLabel(continueLabel);
        if(!reachable) {
            break;
        }
        visitExpressionOnEmptyStack(test);
        jumpToLabel(test, breakLabel);
        if(isAlwaysFalse(test)) {
            break;
        }
        jumpToLabel(test, repeatLabel);
        joinOnLabel(repeatLabel);
        if(localVariableTypes.equals(beforeRepeatTypes)) {
            break;
        }
        resetJoinPoint(continueLabel);
        resetJoinPoint(breakLabel);
        resetJoinPoint(repeatLabel);
    }

    if(isAlwaysTrue(test)) {
        doesNotContinueSequentially();
    }

    leaveBreakable(loopNode);
}
 

/**
 * Define symbols for all variable declarations at the top of the function scope. This way we can get around
 * problems like
 *
 * while (true) {
 *   break;
 *   if (true) {
 *     var s;
 *   }
 * }
 *
 * to an arbitrary nesting depth.
 *
 * see NASHORN-73
 *
 * @param functionNode the FunctionNode we are entering
 * @param body the body of the FunctionNode we are entering
 */
private void acceptDeclarations(final FunctionNode functionNode, final Block body) {
    // This visitor will assign symbol to all declared variables.
    body.accept(new SimpleNodeVisitor() {
        @Override
        protected boolean enterDefault(final Node node) {
            // Don't bother visiting expressions; var is a statement, it can't be inside an expression.
            // This will also prevent visiting nested functions (as FunctionNode is an expression).
            return !(node instanceof Expression);
        }

        @Override
        public Node leaveVarNode(final VarNode varNode) {
            final IdentNode ident  = varNode.getName();
            final boolean blockScoped = varNode.isBlockScoped();
            if (blockScoped && lc.inUnprotectedSwitchContext()) {
                throwUnprotectedSwitchError(varNode);
            }
            final Block block = blockScoped ? lc.getCurrentBlock() : body;
            final Symbol symbol = defineSymbol(block, ident.getName(), ident, varNode.getSymbolFlags());
            if (varNode.isFunctionDeclaration()) {
                symbol.setIsFunctionDeclaration();
            }
            return varNode.setName(ident.setSymbol(symbol));
        }
    });
}
 

private void enterDoWhileLoop(final WhileNode loopNode) {
    assertTypeStackIsEmpty();
    final JoinPredecessorExpression test = loopNode.getTest();
    final Block body = loopNode.getBody();
    final Label continueLabel = loopNode.getContinueLabel();
    final Label breakLabel = loopNode.getBreakLabel();
    final Map<Symbol, LvarType> beforeLoopTypes = localVariableTypes;
    final Label repeatLabel = new Label("");
    for(;;) {
        jumpToLabel(loopNode, repeatLabel, beforeLoopTypes);
        final Map<Symbol, LvarType> beforeRepeatTypes = localVariableTypes;
        body.accept(this);
        if(reachable) {
            jumpToLabel(body, continueLabel);
        }
        joinOnLabel(continueLabel);
        if(!reachable) {
            break;
        }
        visitExpressionOnEmptyStack(test);
        jumpToLabel(test, breakLabel);
        if(isAlwaysFalse(test)) {
            break;
        }
        jumpToLabel(test, repeatLabel);
        joinOnLabel(repeatLabel);
        if(localVariableTypes.equals(beforeRepeatTypes)) {
            break;
        }
        resetJoinPoint(continueLabel);
        resetJoinPoint(breakLabel);
        resetJoinPoint(repeatLabel);
    }

    if(isAlwaysTrue(test)) {
        doesNotContinueSequentially();
    }

    leaveBreakable(loopNode);
}
 

private void enterDoWhileLoop(final WhileNode loopNode) {
    assertTypeStackIsEmpty();
    final JoinPredecessorExpression test = loopNode.getTest();
    final Block body = loopNode.getBody();
    final Label continueLabel = loopNode.getContinueLabel();
    final Label breakLabel = loopNode.getBreakLabel();
    final Map<Symbol, LvarType> beforeLoopTypes = localVariableTypes;
    final Label repeatLabel = new Label("");
    for(;;) {
        jumpToLabel(loopNode, repeatLabel, beforeLoopTypes);
        final Map<Symbol, LvarType> beforeRepeatTypes = localVariableTypes;
        body.accept(this);
        if(reachable) {
            jumpToLabel(body, continueLabel);
        }
        joinOnLabel(continueLabel);
        if(!reachable) {
            break;
        }
        visitExpressionOnEmptyStack(test);
        jumpToLabel(test, breakLabel);
        if(isAlwaysFalse(test)) {
            break;
        }
        jumpToLabel(test, repeatLabel);
        joinOnLabel(repeatLabel);
        if(localVariableTypes.equals(beforeRepeatTypes)) {
            break;
        }
        resetJoinPoint(continueLabel);
        resetJoinPoint(breakLabel);
        resetJoinPoint(repeatLabel);
    }

    if(isAlwaysTrue(test)) {
        doesNotContinueSequentially();
    }

    leaveBreakable(loopNode);
}
 

private void enterDoWhileLoop(final WhileNode loopNode) {
    assertTypeStackIsEmpty();
    final JoinPredecessorExpression test = loopNode.getTest();
    final Block body = loopNode.getBody();
    final Label continueLabel = loopNode.getContinueLabel();
    final Label breakLabel = loopNode.getBreakLabel();
    final Map<Symbol, LvarType> beforeLoopTypes = localVariableTypes;
    final Label repeatLabel = new Label("");
    for(;;) {
        jumpToLabel(loopNode, repeatLabel, beforeLoopTypes);
        final Map<Symbol, LvarType> beforeRepeatTypes = localVariableTypes;
        body.accept(this);
        if(reachable) {
            jumpToLabel(body, continueLabel);
        }
        joinOnLabel(continueLabel);
        if(!reachable) {
            break;
        }
        visitExpressionOnEmptyStack(test);
        jumpToLabel(test, breakLabel);
        if(isAlwaysFalse(test)) {
            break;
        }
        jumpToLabel(test, repeatLabel);
        joinOnLabel(repeatLabel);
        if(localVariableTypes.equals(beforeRepeatTypes)) {
            break;
        }
        resetJoinPoint(continueLabel);
        resetJoinPoint(breakLabel);
        resetJoinPoint(repeatLabel);
    }

    if(isAlwaysTrue(test)) {
        doesNotContinueSequentially();
    }

    leaveBreakable(loopNode);
}
 

private void enterDoWhileLoop(final WhileNode loopNode) {
    assertTypeStackIsEmpty();
    final JoinPredecessorExpression test = loopNode.getTest();
    final Block body = loopNode.getBody();
    final Label continueLabel = loopNode.getContinueLabel();
    final Label breakLabel = loopNode.getBreakLabel();
    final Map<Symbol, LvarType> beforeLoopTypes = localVariableTypes;
    final Label repeatLabel = new Label("");
    for(;;) {
        jumpToLabel(loopNode, repeatLabel, beforeLoopTypes);
        final Map<Symbol, LvarType> beforeRepeatTypes = localVariableTypes;
        body.accept(this);
        if(reachable) {
            jumpToLabel(body, continueLabel);
        }
        joinOnLabel(continueLabel);
        if(!reachable) {
            break;
        }
        visitExpressionOnEmptyStack(test);
        jumpToLabel(test, breakLabel);
        if(isAlwaysFalse(test)) {
            break;
        }
        jumpToLabel(test, repeatLabel);
        joinOnLabel(repeatLabel);
        if(localVariableTypes.equals(beforeRepeatTypes)) {
            break;
        }
        resetJoinPoint(continueLabel);
        resetJoinPoint(breakLabel);
        resetJoinPoint(repeatLabel);
    }

    if(isAlwaysTrue(test)) {
        doesNotContinueSequentially();
    }

    leaveBreakable(loopNode);
}
 

private void enterFor(final ForNode forNode) {
    final Expression init   = forNode.getInit();
    final Expression test   = forNode.getTest();
    final Block      body   = forNode.getBody();
    final Expression modify = forNode.getModify();

    if (init != null) {
        init.accept(this);
    }

    final Label loopLabel = new Label("loop");
    final Label testLabel = new Label("test");

    method._goto(testLabel);
    method.label(loopLabel);
    body.accept(this);
    method.label(forNode.getContinueLabel());

    if (!body.isTerminal() && modify != null) {
        load(modify);
    }

    method.label(testLabel);
    if (test != null) {
        new BranchOptimizer(this, method).execute(test, loopLabel, true);
    } else {
        method._goto(loopLabel);
    }

    method.label(forNode.getBreakLabel());
}
 

/**
 * Define symbols for all variable declarations at the top of the function scope. This way we can get around
 * problems like
 *
 * while (true) {
 *   break;
 *   if (true) {
 *     var s;
 *   }
 * }
 *
 * to an arbitrary nesting depth.
 *
 * see NASHORN-73
 *
 * @param functionNode the FunctionNode we are entering
 * @param body the body of the FunctionNode we are entering
 */
private void acceptDeclarations(final FunctionNode functionNode, final Block body) {
    // This visitor will assign symbol to all declared variables.
    body.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
        @Override
        protected boolean enterDefault(final Node node) {
            // Don't bother visiting expressions; var is a statement, it can't be inside an expression.
            // This will also prevent visiting nested functions (as FunctionNode is an expression).
            return !(node instanceof Expression);
        }

        @Override
        public Node leaveVarNode(final VarNode varNode) {
            final IdentNode ident  = varNode.getName();
            final boolean blockScoped = varNode.isBlockScoped();
            if (blockScoped && lc.inUnprotectedSwitchContext()) {
                throwUnprotectedSwitchError(varNode);
            }
            final Block block = blockScoped ? lc.getCurrentBlock() : body;
            final Symbol symbol = defineSymbol(block, ident.getName(), ident, varNode.getSymbolFlags());
            if (varNode.isFunctionDeclaration()) {
                symbol.setIsFunctionDeclaration();
            }
            return varNode.setName(ident.setSymbol(symbol));
        }
    });
}
 

/**
 * Define symbols for all variable declarations at the top of the function scope. This way we can get around
 * problems like
 *
 * while (true) {
 *   break;
 *   if (true) {
 *     var s;
 *   }
 * }
 *
 * to an arbitrary nesting depth.
 *
 * see NASHORN-73
 *
 * @param functionNode the FunctionNode we are entering
 * @param body the body of the FunctionNode we are entering
 */
private void acceptDeclarations(final FunctionNode functionNode, final Block body) {
    // This visitor will assign symbol to all declared variables.
    body.accept(new SimpleNodeVisitor() {
        @Override
        protected boolean enterDefault(final Node node) {
            // Don't bother visiting expressions; var is a statement, it can't be inside an expression.
            // This will also prevent visiting nested functions (as FunctionNode is an expression).
            return !(node instanceof Expression);
        }

        @Override
        public Node leaveVarNode(final VarNode varNode) {
            final IdentNode ident  = varNode.getName();
            final boolean blockScoped = varNode.isBlockScoped();
            if (blockScoped && lc.inUnprotectedSwitchContext()) {
                throwUnprotectedSwitchError(varNode);
            }
            final Block block = blockScoped ? lc.getCurrentBlock() : body;
            final Symbol symbol = defineSymbol(block, ident.getName(), ident, varNode.getSymbolFlags());
            if (varNode.isFunctionDeclaration()) {
                symbol.setIsFunctionDeclaration();
            }
            return varNode.setName(ident.setSymbol(symbol));
        }
    });
}
 

@Override
public boolean enterIfNode(final IfNode ifNode) {
    ifNode.toString(sb);
    ifNode.getPass().accept(this);

    final Block fail = ifNode.getFail();

    if (fail != null) {
        sb.append(" else ");
        fail.accept(this);
    }

    return false;
}
 

private void enterTestFirstLoop(final LoopNode loopNode, final JoinPredecessorExpression modify,
        final Expression iteratorValues, final boolean iteratorValuesAreObject) {
    final JoinPredecessorExpression test = loopNode.getTest();
    if(isAlwaysFalse(test)) {
        visitExpressionOnEmptyStack(test);
        return;
    }

    final Label continueLabel = loopNode.getContinueLabel();
    final Label breakLabel = loopNode.getBreakLabel();

    final Label repeatLabel = modify == null ? continueLabel : new Label("");
    final Map<Symbol, LvarType> beforeLoopTypes = localVariableTypes;
    for(;;) {
        jumpToLabel(loopNode, repeatLabel, beforeLoopTypes);
        final Map<Symbol, LvarType> beforeRepeatTypes = localVariableTypes;
        if(test != null) {
            visitExpressionOnEmptyStack(test);
        }
        if(!isAlwaysTrue(test)) {
            jumpToLabel(test, breakLabel);
        }
        if(iteratorValues instanceof IdentNode) {
            final IdentNode ident = (IdentNode)iteratorValues;
            // Receives iterator values; the optimistic type of the iterator values is tracked on the
            // identifier, but we override optimism if it's known that the object being iterated over will
            // never have primitive property names.
            onAssignment(ident, iteratorValuesAreObject ? LvarType.OBJECT :
                toLvarType(compiler.getOptimisticType(ident)));
        }
        final Block body = loopNode.getBody();
        body.accept(this);
        if(reachable) {
            jumpToLabel(body, continueLabel);
        }
        joinOnLabel(continueLabel);
        if(!reachable) {
            break;
        }
        if(modify != null) {
            visitExpressionOnEmptyStack(modify);
            jumpToLabel(modify, repeatLabel);
            joinOnLabel(repeatLabel);
        }
        if(localVariableTypes.equals(beforeRepeatTypes)) {
            break;
        }
        // Reset the join points and repeat the analysis
        resetJoinPoint(continueLabel);
        resetJoinPoint(breakLabel);
        resetJoinPoint(repeatLabel);
    }

    if(isAlwaysTrue(test) && iteratorValues == null) {
        doesNotContinueSequentially();
    }

    leaveBreakable(loopNode);
}
 

private void enterTestFirstLoop(final LoopNode loopNode, final JoinPredecessorExpression modify,
        final Expression iteratorValues, final boolean iteratorValuesAreObject) {
    final JoinPredecessorExpression test = loopNode.getTest();
    if(isAlwaysFalse(test)) {
        visitExpressionOnEmptyStack(test);
        return;
    }

    final Label continueLabel = loopNode.getContinueLabel();
    final Label breakLabel = loopNode.getBreakLabel();

    final Label repeatLabel = modify == null ? continueLabel : new Label("");
    final Map<Symbol, LvarType> beforeLoopTypes = localVariableTypes;
    for(;;) {
        jumpToLabel(loopNode, repeatLabel, beforeLoopTypes);
        final Map<Symbol, LvarType> beforeRepeatTypes = localVariableTypes;
        if(test != null) {
            visitExpressionOnEmptyStack(test);
        }
        if(!isAlwaysTrue(test)) {
            jumpToLabel(test, breakLabel);
        }
        if(iteratorValues instanceof IdentNode) {
            final IdentNode ident = (IdentNode)iteratorValues;
            // Receives iterator values; the optimistic type of the iterator values is tracked on the
            // identifier, but we override optimism if it's known that the object being iterated over will
            // never have primitive property names.
            onAssignment(ident, iteratorValuesAreObject ? LvarType.OBJECT :
                toLvarType(compiler.getOptimisticType(ident)));
        }
        final Block body = loopNode.getBody();
        body.accept(this);
        if(reachable) {
            jumpToLabel(body, continueLabel);
        }
        joinOnLabel(continueLabel);
        if(!reachable) {
            break;
        }
        if(modify != null) {
            visitExpressionOnEmptyStack(modify);
            jumpToLabel(modify, repeatLabel);
            joinOnLabel(repeatLabel);
        }
        if(localVariableTypes.equals(beforeRepeatTypes)) {
            break;
        }
        // Reset the join points and repeat the analysis
        resetJoinPoint(continueLabel);
        resetJoinPoint(breakLabel);
        resetJoinPoint(repeatLabel);
    }

    if(isAlwaysTrue(test) && iteratorValues == null) {
        doesNotContinueSequentially();
    }

    leaveBreakable(loopNode);
}
 

@Override
public boolean enterTryNode(final TryNode tryNode) {
    lineNumber(tryNode);

    final Block       body        = tryNode.getBody();
    final List<Block> catchBlocks = tryNode.getCatchBlocks();
    final Symbol      symbol      = tryNode.getException();
    final Label       entry       = new Label("try");
    final Label       recovery    = new Label("catch");
    final Label       exit        = tryNode.getExit();
    final Label       skip        = new Label("skip");

    method.label(entry);

    body.accept(this);

    if (!body.hasTerminalFlags()) {
        method._goto(skip);
    }

    method.label(exit);

    method._catch(recovery);
    method.store(symbol);

    for (int i = 0; i < catchBlocks.size(); i++) {
        final Block catchBlock = catchBlocks.get(i);

        //TODO this is very ugly - try not to call enter/leave methods directly
        //better to use the implicit lexical context scoping given by the visitor's
        //accept method.
        lc.push(catchBlock);
        enterBlock(catchBlock);

        final CatchNode  catchNode          = (CatchNode)catchBlocks.get(i).getStatements().get(0);
        final IdentNode  exception          = catchNode.getException();
        final Expression exceptionCondition = catchNode.getExceptionCondition();
        final Block      catchBody          = catchNode.getBody();

        new Store<IdentNode>(exception) {
            @Override
            protected void storeNonDiscard() {
                return;
            }

            @Override
            protected void evaluate() {
                if (catchNode.isSyntheticRethrow()) {
                    method.load(symbol);
                    return;
                }
                /*
                 * If caught object is an instance of ECMAException, then
                 * bind obj.thrown to the script catch var. Or else bind the
                 * caught object itself to the script catch var.
                 */
                final Label notEcmaException = new Label("no_ecma_exception");
                method.load(symbol).dup()._instanceof(ECMAException.class).ifeq(notEcmaException);
                method.checkcast(ECMAException.class); //TODO is this necessary?
                method.getField(ECMAException.THROWN);
                method.label(notEcmaException);
            }
        }.store();

        final Label next;

        if (exceptionCondition != null) {
            next = new Label("next");
            load(exceptionCondition, Type.BOOLEAN).ifeq(next);
        } else {
            next = null;
        }

        catchBody.accept(this);

        if (i + 1 != catchBlocks.size() && !catchBody.hasTerminalFlags()) {
            method._goto(skip);
        }

        if (next != null) {
            if (i + 1 == catchBlocks.size()) {
                // no next catch block - rethrow if condition failed
                method._goto(skip);
                method.label(next);
                method.load(symbol).athrow();
            } else {
                method.label(next);
            }
        }

        leaveBlock(catchBlock);
        lc.pop(catchBlock);
    }

    method.label(skip);
    method._try(entry, exit, recovery, Throwable.class);

    // Finally body is always inlined elsewhere so it doesn't need to be emitted

    return false;
}
 

private void enterTestFirstLoop(final LoopNode loopNode, final JoinPredecessorExpression modify,
        final Expression iteratorValues, final boolean iteratorValuesAreObject) {
    final JoinPredecessorExpression test = loopNode.getTest();
    if(isAlwaysFalse(test)) {
        visitExpressionOnEmptyStack(test);
        return;
    }

    final Label continueLabel = loopNode.getContinueLabel();
    final Label breakLabel = loopNode.getBreakLabel();

    final Label repeatLabel = modify == null ? continueLabel : new Label("");
    final Map<Symbol, LvarType> beforeLoopTypes = localVariableTypes;
    for(;;) {
        jumpToLabel(loopNode, repeatLabel, beforeLoopTypes);
        final Map<Symbol, LvarType> beforeRepeatTypes = localVariableTypes;
        if(test != null) {
            visitExpressionOnEmptyStack(test);
        }
        if(!isAlwaysTrue(test)) {
            jumpToLabel(test, breakLabel);
        }
        if(iteratorValues instanceof IdentNode) {
            final IdentNode ident = (IdentNode)iteratorValues;
            // Receives iterator values; the optimistic type of the iterator values is tracked on the
            // identifier, but we override optimism if it's known that the object being iterated over will
            // never have primitive property names.
            onAssignment(ident, iteratorValuesAreObject ? LvarType.OBJECT :
                toLvarType(compiler.getOptimisticType(ident)));
        }
        final Block body = loopNode.getBody();
        body.accept(this);
        if(reachable) {
            jumpToLabel(body, continueLabel);
        }
        joinOnLabel(continueLabel);
        if(!reachable) {
            break;
        }
        if(modify != null) {
            visitExpressionOnEmptyStack(modify);
            jumpToLabel(modify, repeatLabel);
            joinOnLabel(repeatLabel);
        }
        if(localVariableTypes.equals(beforeRepeatTypes)) {
            break;
        }
        // Reset the join points and repeat the analysis
        resetJoinPoint(continueLabel);
        resetJoinPoint(breakLabel);
        resetJoinPoint(repeatLabel);
    }

    if(isAlwaysTrue(test) && iteratorValues == null) {
        doesNotContinueSequentially();
    }

    leaveBreakable(loopNode);
}