com.sun.source.tree.ContinueTree Java Examples

@Override
    public Tree visitContinue(ContinueTree tree, Void p) {
        ContinueTree n = make.Continue(tree.getLabel());
//        model.setType(n, model.getType(tree));
        comments.copyComments(tree, n);
        model.setPos(n, model.getPos(tree));
        return n;
    }
 

@Override
public Optional<TreePath> visitContinue(@Nullable ContinueTree node, Void v) {
  if (node == null) {
    return Optional.absent();
  } else if (isMatch(node, node.getLabel())) {
    return currentPathPlus(node);
  }

  return super.visitContinue(node, v);
}
 

@Override
public Void visitContinue(ContinueTree expected, Tree actual) {
  Optional<ContinueTree> other = checkTypeAndCast(expected, actual);
  if (!other.isPresent()) {
    addTypeMismatch(expected, actual);
    return null;
  }

  checkForDiff(namesEqual(expected.getLabel(), other.get().getLabel()),
      "Expected label on continue statement to be <%s> but was <%s>.",
      expected.getLabel(), other.get().getLabel());
  return null;
}
 

private TreeNode convertContinueStatement(ContinueTree node) {
  ContinueStatement newNode = new ContinueStatement();
  Object label = node.getLabel();
  if (label != null) {
    newNode.setLabel(
        (SimpleName) new SimpleName(label.toString()).setPosition(getPosition(node)));
  }
  return newNode;
}
 

@Override
public Void visitContinue(ContinueTree node, Void unused) {
  sync(node);
  builder.open(plusFour);
  token("continue");
  if (node.getLabel() != null) {
    builder.breakOp(" ");
    visit(node.getLabel());
  }
  token(";");
  builder.close();
  return null;
}
 

@Override
public Void visitContinue(ContinueTree node, Void unused) {
    sync(node);
    builder.open(plusFour);
    token("continue");
    if (node.getLabel() != null) {
        builder.breakOp(" ");
        visit(node.getLabel());
    }
    token(";");
    builder.close();
    return null;
}
 

@Override
public Void visitContinue(ContinueTree node, Void p) {
    if (isMethodCode() && phase == PHASE_INSIDE_SELECTION && !treesSeensInSelection.contains(info.getTreeUtilities().getBreakContinueTarget(getCurrentPath()))) {
        selectionExits.add(getCurrentPath());
        hasContinues = true;
    }
    return super.visitContinue(node, p);
}
 

@Override
public Void visitContinue(ContinueTree node, Collection<TreePath> trees) {
    if (!analyzeThrows && !seenTrees.contains(info.getTreeUtilities().getBreakContinueTarget(getCurrentPath()))) {
        trees.add(getCurrentPath());
    }
    return null;
}
 

private boolean isIfWithContinueOnly(ContinueTree that) {
    TreePath currentTreePath = this.getCurrentPath();
    TreePath parentPath = currentTreePath.getParentPath();
    Tree parentTree = parentPath.getLeaf();
    if (parentTree.getKind() == Tree.Kind.IF) {
        return true;
    } else if (parentTree.getKind() == Tree.Kind.BLOCK) {
        BlockTree parentBlock = (BlockTree) parentTree;
        if (parentBlock.getStatements().size() == 1) {
            return true;
        }
    }
    return false;
}
 

@Override
public Tree visitContinue(ContinueTree that, Trees trees) {
    if (that.getLabel() != null || !isIfWithContinueOnly(that)) {
        this.hasContinue = true;
    }
    return super.visitContinue(that, trees);
}
 

@Override
public Void visitContinue(ContinueTree tree, List<Node> d) {
    List<Node> below = new ArrayList<Node>();
    
    addCorrespondingType(below);
    addCorrespondingComments(below);
    super.visitContinue(tree, below);
    
    d.add(new TreeNode(info, getCurrentPath(), below));
    return null;
}
 

public void testContinue158130() throws Exception {
    String test = "public class Test { void m(int p) { loop: while (true) { if (p == 0) { con|tinue loop; } } } }";
    String golden = "public class Test { void m(int p) { loop: while (true) { if (p == 0) { continue; } } } }";
    testHelper(test, golden, Kind.CONTINUE, new Delegate() {

        public void run(WorkingCopy copy, Tree tree) {
            ContinueTree original = (ContinueTree) tree;
            TreeMaker make = copy.getTreeMaker();
            ContinueTree modified = make.Continue(null);
            copy.rewrite(original, modified);
        }
    });
}
 

public Void visitContinue(ContinueTree node, Object p) {
    System.err.println("visitContinue: " + node.getLabel());
    super.visitContinue(node, p);
    ContinueTree copy = make.setLabel(node, node.getLabel() + "0");
    this.copy.rewrite(node, copy);
    return null;
}
 

public Boolean visitContinue(ContinueTree node, TreePath p) {
    if (p == null) {
        super.visitContinue(node, p);
        return false;
    }

    //XXX: check labels
    return true;
}
 

@Override
public Void visitContinue(ContinueTree node, Void unused) {
    sync(node);
    builder.open(plusFour);
    token("continue");
    if (node.getLabel() != null) {
        builder.breakOp(" ");
        visit(node.getLabel());
    }
    token(";");
    builder.close();
    return null;
}
 

@Override
public State visitContinue(ContinueTree node, Void p) {
    StatementTree target = ci.getTreeUtilities().getBreakContinueTarget(getCurrentPath());
    breakContinueJumps.add(target);
    return State.NO;
}
 

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;
}
 

@Override
public Object visitContinue(ContinueTree node, Object p) {
    complexity++;
    return super.visitContinue(node, p);
}
 

@Override
public Boolean visitContinue(ContinueTree node, Void p) {
    return visitBreak(null, p);
}
 

@Override
public List<? extends TypeMirror> visitContinue(ContinueTree node, Object p) {
    return null;
}
 

@Override
public Object visitContinue(ContinueTree node, Object p) {
    statements++;
    return super.visitContinue(node, p);
}
 

private boolean isLegal(StatementTree st) {
    return !(st instanceof ReturnTree) &&
            !(st instanceof ContinueTree) && !(st instanceof BreakTree);
}
 

void visit(ContinueTree node, List<ErrMsg> errMsgs, GlobalContext globalCtx, Closure<List<Map<String, Long>>> resolveRowAndCol,
Closure<Void> setError);
 

@Override
public String visitContinue(ContinueTree reference, Void v) {
  return (reference != null) ? detailedKindString(reference, reference.getLabel()) : "";
}