com.sun.source.tree.BreakTree Java Examples

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

@Override
public Optional<TreePath> visitBreak(@Nullable BreakTree node, Void v) {
  if (node == null) {
    return Optional.absent();
  }

  return isMatch(node, node.getLabel()) ? currentPathPlus(node) : Optional.<TreePath>absent();
}
 

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

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

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

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

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

@Override
public Boolean visitBreak(BreakTree node, Void p) {
    Tree target = info.getTreeUtilities().getBreakContinueTarget(getCurrentPath());
    boolean known = seenTrees.contains(target);
    if (known) {
        targetTrees.add(target);
    }
    return !known;
}
 

@Override
public Void visitBreak(BreakTree node, Void p) {
    if (isMethodCode() && phase == PHASE_INSIDE_SELECTION && !treesSeensInSelection.contains(info.getTreeUtilities().getBreakContinueTargetTree(getCurrentPath()))) {
        selectionExits.add(getCurrentPath());
        hasBreaks = true;
    }
    return super.visitBreak(node, p);
}
 

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

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

@Override
public Object visitBreak(BreakTree node, Object p) {
    // do not count the break, if it is nested in a switch 'case' statement.
    if (node.getLabel() != null || !switchCase) {
        complexity++;
    }
    return super.visitBreak(node, p);
}
 

public void testBreak166327() throws Exception {
    String test =
            "public class Test {" +
            "    public static void test(int y) {" +
            "        for (int u = y;;) {" +
            "            if (y == 0)" +
            "                br|eak;" +
            "            else" +
            "                y++;" +
            "        }" +
            "    }" +
            "}";
    String golden = 
            "public class Test {" +
            "    public static void test(int y) {" +
            "        for (int u = y;;) {" +
            "            if (y == 0)" +
            "                break;" +
            "            else" +
            "                y++;" +
            "        }" +
            "    }" +
            "}";

    testHelper(test, golden, Kind.BREAK, new Delegate() {

        public void run(WorkingCopy copy, Tree tree) {
            BreakTree oldBt = (BreakTree) tree;
            BreakTree newBt = copy.getTreeMaker().Break(null);
            copy.rewrite(oldBt, newBt);
        }
        
    });
}
 

public void testBreak158130() throws Exception {
    String test = "public class Test { void m(int p) { loop: while (true) { if (p == 0) { b|reak loop; } } } }";
    String golden = "public class Test { void m(int p) { loop: while (true) { if (p == 0) { break; } } } }";
    testHelper(test, golden, Kind.BREAK, new Delegate() {

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

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

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

    //XXX: check labels
    return true;
}
 

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

@Override
public Tree visitBreak(BreakTree that, Trees trees) {
    this.hasBreaks = true;
    return super.visitBreak(that, trees);

}
 

@Override
public State visitBreak(BreakTree node, Void p) {
    Tree target = ci.getTreeUtilities().getBreakContinueTargetTree(getCurrentPath());
    breakContinueJumps.add(target);
    return State.NO;
}
 

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

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

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

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

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

public Boolean visitBreak(BreakTree node, ConstructorData p) {
    super.visitBreak(node, p);

    Tree target = info.getTreeUtilities().getBreakContinueTargetTree(getCurrentPath());
    
    resumeAfter(target, variable2State);

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

@Override public Object visitBreak(BreakTree node, Object p) { return null; }