Java ForLoopTree.getUpdate方法代码示例

import com.sun.source.tree.ForLoopTree; //导入方法依赖的package包/类
@Override
public List<? extends TypeMirror> visitForLoop(ForLoopTree node, Object p) {
    if (theExpression == null) {
        // ambigous
        return null;
    }
    if (theExpression.getLeaf() == node.getCondition()) {
        return booleanType();
    } else {
        if (!((node.getInitializer() != null && node.getInitializer().contains(theExpression.getLeaf())) || (node.getUpdate() != null && node.getUpdate().contains(theExpression.getLeaf())))) {
            return null;
        }
        // initializer and update operation can have any result type, including none
        TypeElement tel = info.getElements().getTypeElement("java.lang.Void");
        if (tel == null) {
            return null;
        }
        return Collections.singletonList(tel.asType()); // NOI18N
    }
}
 

import com.sun.source.tree.ForLoopTree; //导入方法依赖的package包/类
@Override
public Mirror visitForLoop(ForLoopTree arg0, EvaluationContext evaluationContext) {
    try {
        evaluationContext.pushBlock();
        for (StatementTree st : arg0.getInitializer()) {
            st.accept(this, evaluationContext);
        }
        Mirror result = null;
        ExpressionTree condition = arg0.getCondition();
        List<? extends ExpressionStatementTree> updateList = arg0.getUpdate();
        StatementTree statement = arg0.getStatement();
        while (condition == null || evaluateCondition(arg0, evaluationContext, condition)) {
            Mirror value = null;
            try {
                evaluationContext.pushBlock();
                value = statement.accept(this, evaluationContext);
                if (value instanceof Break) {
                    break;
                } else if (value instanceof Continue) {
                    continue;
                }
                if (value != null) {
                    result = value;
                }
            } finally {
                evaluationContext.popBlock();
                if ((value instanceof Continue) || !(value instanceof CommandMirror)) {
                    for (Tree tree : updateList) {
                        tree.accept(this, evaluationContext);
                    } // for
                } // if
            } // finally
        } // while
        return result;
    } finally {
        evaluationContext.popBlock();
    }
}
 

import com.sun.source.tree.ForLoopTree; //导入方法依赖的package包/类
@Override
public Description matchForLoop(ForLoopTree forLoopTree, VisitorState visitorState) {
  List<? extends ExpressionStatementTree> updates = forLoopTree.getUpdate();

  // keep track of all the symbols that are updated in the for loop header
  final Set<Symbol> incrementedSymbols =
      updates
          .stream()
          .filter(expStateTree -> expStateTree.getExpression() instanceof UnaryTree)
          .map(
              expStateTree ->
                  ASTHelpers.getSymbol(
                      ((UnaryTree) expStateTree.getExpression()).getExpression()))
          .collect(Collectors.toCollection(HashSet::new));

  // track if they are updated in the body without a conditional surrounding them
  StatementTree body = forLoopTree.getStatement();
  List<? extends StatementTree> statementTrees =
      body instanceof BlockTree ? ((BlockTree) body).getStatements() : ImmutableList.of(body);
  for (StatementTree s : statementTrees) {
    if (!CONDITIONALS.contains(s.getKind())) {
      Optional<Symbol> opSymbol = returnUnarySym(s);
      if (opSymbol.isPresent() && incrementedSymbols.contains(opSymbol.get())) {
        // both ++ and --
        return describeMatch(forLoopTree);
      }
    }
  }
  return Description.NO_MATCH;
}
 

import com.sun.source.tree.ForLoopTree; //导入方法依赖的package包/类
public Boolean visitContinue(ContinueTree node, ConstructorData p) {
    StatementTree loop = info.getTreeUtilities().getBreakContinueTarget(getCurrentPath());

    if (loop == null) {
        super.visitContinue(node, p);
        return null;
    }

    Tree resumePoint;

    if (loop.getKind() == Kind.LABELED_STATEMENT) {
        loop = ((LabeledStatementTree) loop).getStatement();
    }
    
    switch (loop.getKind()) {
        case WHILE_LOOP:
            resumePoint = ((WhileLoopTree) loop).getCondition();
            break;
        case FOR_LOOP: {
                ForLoopTree flt = (ForLoopTree)loop;
                resumePoint = null;
                if (flt.getUpdate() != null && !flt.getUpdate().isEmpty()) {
                    // resume will react on the 1st Tree of the update statement (always processed left to right)
                    resumePoint = flt.getUpdate().get(0);
                } 
                if (resumePoint == null) {
                    resumePoint = flt.getCondition();
                }
                if (resumePoint == null) {
                    resumePoint = flt.getStatement();
                }
        }
            break;
        case DO_WHILE_LOOP:
            resumePoint = ((DoWhileLoopTree) loop).getCondition();
            break;
        case ENHANCED_FOR_LOOP:
            resumePoint = ((EnhancedForLoopTree) loop).getStatement();
            break;
        default:
            resumePoint = null;
            break;
    }

    if (resumePoint != null) {
        recordResume(resumeBefore, resumePoint, variable2State);
    }

    variable2State = new HashMap< Element, State>();

    super.visitContinue(node, p);
    return null;
}
 

import com.sun.source.tree.ForLoopTree; //导入方法依赖的package包/类
@Override
public Void visitForLoop(ForLoopTree node, Void unused) {
    sync(node);
    token("for");
    builder.space();
    token("(");
    builder.open(plusFour);
    builder.open(
            node.getInitializer().size() > 1
                    && node.getInitializer().get(0).getKind() == Tree.Kind.EXPRESSION_STATEMENT
                    ? plusFour
                    : ZERO);
    if (!node.getInitializer().isEmpty()) {
        if (node.getInitializer().get(0).getKind() == VARIABLE) {
            PeekingIterator<StatementTree> it =
                    Iterators.<StatementTree>peekingIterator(node.getInitializer().iterator());
            visitVariables(
                    variableFragments(it, it.next()), DeclarationKind.NONE, Direction.HORIZONTAL);
        } else {
            boolean first = true;
            builder.open(ZERO);
            for (StatementTree t : node.getInitializer()) {
                if (!first) {
                    token(",");
                    builder.breakOp(" ");
                }
                scan(((ExpressionStatementTree) t).getExpression(), null);
                first = false;
            }
            token(";");
            builder.close();
        }
    } else {
        token(";");
    }
    builder.close();
    builder.breakOp(" ");
    if (node.getCondition() != null) {
        scan(node.getCondition(), null);
    }
    token(";");
    if (!node.getUpdate().isEmpty()) {
        builder.breakOp(" ");
        builder.open(node.getUpdate().size() <= 1 ? ZERO : plusFour);
        boolean firstUpdater = true;
        for (ExpressionStatementTree updater : node.getUpdate()) {
            if (!firstUpdater) {
                token(",");
                builder.breakToFill(" ");
            }
            scan(updater.getExpression(), null);
            firstUpdater = false;
        }
        builder.guessToken(";");
        builder.close();
    } else {
        builder.space();
    }
    builder.close();
    token(")");
    visitStatement(
            node.getStatement(),
            CollapseEmptyOrNot.YES,
            AllowLeadingBlankLine.YES,
            AllowTrailingBlankLine.NO);
    return null;
}
 

import com.sun.source.tree.ForLoopTree; //导入方法依赖的package包/类
@Override
public Node visitForLoop(ForLoopTree tree, Void p) {
    Name parentLabel = getLabel(getCurrentPath());

    Label conditionStart = new Label();
    Label loopEntry = new Label();
    Label loopExit = new Label();

    // If the loop is a labeled statement, then its continue
    // target is identical for continues with no label and
    // continues with the loop's label.
    Label updateStart;
    if (parentLabel != null) {
        updateStart = continueLabels.get(parentLabel);
    } else {
        updateStart = new Label();
    }

    Label oldBreakTargetL = breakTargetL;
    breakTargetL = loopExit;

    Label oldContinueTargetL = continueTargetL;
    continueTargetL = updateStart;

    // Initializer
    for (StatementTree init : tree.getInitializer()) {
        scan(init, p);
    }

    // Condition
    addLabelForNextNode(conditionStart);
    if (tree.getCondition() != null) {
        unbox(scan(tree.getCondition(), p));
        ConditionalJump cjump = new ConditionalJump(loopEntry, loopExit);
        extendWithExtendedNode(cjump);
    }

    // Loop body
    addLabelForNextNode(loopEntry);
    if (tree.getStatement() != null) {
        scan(tree.getStatement(), p);
    }

    // Update
    addLabelForNextNode(updateStart);
    for (ExpressionStatementTree update : tree.getUpdate()) {
        scan(update, p);
    }

    extendWithExtendedNode(new UnconditionalJump(conditionStart));

    // Loop exit
    addLabelForNextNode(loopExit);

    breakTargetL = oldBreakTargetL;
    continueTargetL = oldContinueTargetL;

    return null;
}