@Override public Boolean visitSwitch(SwitchTree tree, Void unused) { // (1) if (tree.getCases().stream().allMatch(c -> c.getStatements().isEmpty())) { return true; } // (2) boolean lastCompletes = true; for (CaseTree c : tree.getCases()) { lastCompletes = scan(c.getStatements()); } if (lastCompletes) { return true; } // (3) if (getLast(tree.getCases()).getStatements().isEmpty()) { return true; } // (4) if (tree.getCases().stream().noneMatch(c -> c.getExpression() == null)) { return true; } // (5) if (breaks.contains(tree)) { return true; } return false; }
@Override public Description matchSwitch(SwitchTree tree, VisitorState state) { Type switchType = ASTHelpers.getType(tree.getExpression()); if (switchType.asElement().getKind() != ElementKind.ENUM) { return Description.NO_MATCH; } // default case is present if (tree.getCases().stream().anyMatch(c -> c.getExpression() == null)) { return Description.NO_MATCH; } ImmutableSet<String> handled = tree.getCases().stream() .map(CaseTree::getExpression) .filter(IdentifierTree.class::isInstance) .map(e -> ((IdentifierTree) e).getName().toString()) .collect(toImmutableSet()); Set<String> unhandled = Sets.difference(ASTHelpers.enumValues(switchType.asElement()), handled); if (unhandled.isEmpty()) { return Description.NO_MATCH; } return buildDescription(tree).setMessage(buildMessage(unhandled)).build(); }
tree.getCases().stream().filter(c -> c.getExpression() == null).findFirst(); if (!maybeDefault.isPresent()) { Description.Builder description = buildDescription(tree); if (!tree.getCases().isEmpty()) { CaseTree lastCase = getLast(tree.getCases()); String replacement; if (lastCase.getStatements().isEmpty() replacement = "\ndefault: // fall out\n"; description.addFix(SuggestedFix.postfixWith(getLast(tree.getCases()), replacement)); int idx = tree.getCases().indexOf(defaultCase); if (idx != tree.getCases().size() - 1) { return NO_MATCH;
@Override public Description matchSwitch(SwitchTree tree, VisitorState state) { Optional<? extends CaseTree> maybeDefault = tree.getCases().stream().filter(c -> c.getExpression() == null).findAny(); if (!maybeDefault.isPresent()) { return NO_MATCH; Iterator<? extends CaseTree> it = tree.getCases().iterator(); while (it.hasNext()) { CaseTree caseTree = it.next(); CaseTree last = getLast(tree.getCases()); if (last.getExpression() == null || Reachability.canCompleteNormally(last)) { replacement = "break;\n" + replacement; fix.replace(start, end, "").postfixWith(getLast(tree.getCases()), replacement);
@Override public Result visitSwitch(SwitchTree node, BreakContext cxt) { Result result = null; boolean seenDefault = false; cxt.loopDepth++; try { for (CaseTree caseTree : node.getCases()) { if (caseTree.getExpression() == null) { seenDefault = true; } if (result == null) { result = caseTree.accept(this, cxt); } else { result = result.or(caseTree.accept(this, cxt)); } } if (!seenDefault) { result = result.or(NEVER_EXITS); } return result; } finally { cxt.loopDepth--; } }
@Override public Choice<State<JCSwitch>> visitSwitch(final SwitchTree node, State<?> state) { return chooseSubtrees( state, s -> unifyExpression(node.getExpression(), s), s -> unify(node.getCases(), s), (expr, cases) -> maker().Switch(expr, List.convert(JCCase.class, cases))); }
private SwitchBuilder(SwitchTree tree, Void p) { this.switchTree = tree; this.caseBodyLabels = new Label[switchTree.getCases().size() + 1]; this.p = p; }
@Override public Void visitSwitch(SwitchTree expected, Tree actual) { Optional<SwitchTree> other = checkTypeAndCast(expected, actual); if (!other.isPresent()) { addTypeMismatch(expected, actual); return null; } scan(expected.getExpression(), other.get().getExpression()); parallelScan(expected.getCases(), other.get().getCases()); return null; }
@Override public Void visitSwitch(SwitchTree expected, Tree actual) { Optional<SwitchTree> other = checkTypeAndCast(expected, actual); if (!other.isPresent()) { addTypeMismatch(expected, actual); return null; } scan(expected.getExpression(), other.get().getExpression()); parallelScan(expected.getCases(), other.get().getCases()); return null; }
@Override public Void visitSwitch(SwitchTree node, EnumSet<UseTypes> p) { scan(node.getExpression(), EnumSet.of(UseTypes.READ)); for (CaseTree ct : node.getCases()) { scan(ct, null); } return null; }
public R visitSwitch(SwitchTree node, P p) { R r = scan(node.getExpression(), p); r = scanAndReduce(node.getCases(), p, r); return r; }
private SwitchTree modifySwitchCase(SwitchTree swic, int index, CaseTree kejs, Operation op) { SwitchTree copy = Switch( swic.getExpression(), c(swic.getCases(), index, kejs, op) ); return copy; }
public R visitSwitch(SwitchTree node, P p) { R r = scan(node.getExpression(), p); r = scanAndReduce(node.getCases(), p, r); return r; }
protected final SwitchTree rewriteChildren(SwitchTree tree) { ExpressionTree selector = (ExpressionTree)translate(tree.getExpression()); List<? extends CaseTree> cases = translateStable(tree.getCases()); if (selector!=tree.getExpression() || !cases.equals(tree.getCases())) { SwitchTree n = make.Switch(selector, cases); model.setType(n, model.getType(tree)); copyCommentTo(tree,n); copyPosTo(tree,n); tree = n; } return tree; }
public List<Tree> visitSwitch(SwitchTree node, ExpressionScanner.ExpressionsInfo p) { List<Tree> result = null; if (acceptsTree(node)) { result = scan(node.getExpression(), p); } return reduce(result, scan(node.getCases(), p)); }
@Override public List<Tree> visitSwitch(SwitchTree node, ExpressionScanner.ExpressionsInfo p) { List<Tree> result = null; if (acceptsTree(node)) { result = scan(node.getExpression(), p); } return reduce(result, scan(node.getCases(), p)); }
@Override public Tree visitSwitch(SwitchTree tree, Void p) { SwitchTree n = make.Switch(tree.getExpression(), tree.getCases()); model.setType(n, model.getType(tree)); comments.copyComments(tree, n); model.setPos(n, model.getPos(tree)); return n; }
@Override public Choice<State<JCSwitch>> visitSwitch(final SwitchTree node, State<?> state) { return chooseSubtrees( state, s -> unifyExpression(node.getExpression(), s), s -> unify(node.getCases(), s), (expr, cases) -> maker().Switch(expr, List.convert(JCCase.class, cases))); }