Refine search
@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))); }
@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(); }
@Override public Description matchSwitch(SwitchTree tree, VisitorState state) { Type switchType = ASTHelpers.getType(tree.getExpression()); if (switchType.asElement().getKind() == ElementKind.ENUM) { 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() || Reachability.canCompleteNormally(Iterables.getLast(lastCase.getStatements()))) { replacement = "\nbreak;\ndefault: // fall out\n"; } else { 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 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; }
SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); if (sourcePositions.getStartPosition(root, st.getExpression()) < offset) { CaseTree lastCase = null; for (CaseTree t : st.getCases()) { int pos = (int) sourcePositions.getStartPosition(root, t); if (pos == Diagnostic.NOPOS || offset <= pos) { for (StatementTree stat : lastCase.getStatements()) { int pos = (int) sourcePositions.getStartPosition(root, stat); if (pos == Diagnostic.NOPOS || offset <= pos) {
@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 String visitSwitch(SwitchTree node, Void v) { StringBuilder out = new StringBuilder(); List<? extends CaseTree> cases = node.getCases(); ExpressionTree expression = node.getExpression(); out.append("switch "); out.append(expression.accept(this, v)); out.append(" {\n"); pushIndent(); symTable.pushLocalScope(); for (CaseTree c : cases) { out.append(c.accept(this, v)); out.append("\n"); } symTable.popLocalScope(); popIndent(); appendIndent(out); out.append("}\n"); return out.toString(); }
private void addEnumConstants(Env env, TypeElement elem) { Elements elements = env.getController().getElements(); Trees trees = env.getController().getTrees(); TreePath path = env.getPath().getParentPath(); Set<Element> alreadyUsed = new HashSet<>(); if (path != null && path.getLeaf().getKind() == Tree.Kind.SWITCH) { SwitchTree st = (SwitchTree)path.getLeaf(); for (CaseTree ct : st.getCases()) { Element e = trees.getElement(new TreePath(path, ct.getExpression())); if (e != null && e.getKind() == ENUM_CONSTANT) { alreadyUsed.add(e); } } } for (Element e : elem.getEnclosedElements()) { if (e.getKind() == ENUM_CONSTANT && !alreadyUsed.contains(e)) { String name = e.getSimpleName().toString(); if (startsWith(env, name) && (Utilities.isShowDeprecatedMembers() || !elements.isDeprecated(e))) { results.add(itemFactory.createVariableItem(env.getController(), (VariableElement) e, e.asType(), anchorOffset, null, false, elements.isDeprecated(e), false, env.assignToVarPos())); } } } }
private void insideCase(Env env) throws IOException { int offset = env.getOffset(); TreePath path = env.getPath(); CaseTree cst = (CaseTree) path.getLeaf(); SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); CompilationController controller = env.getController(); if (cst.getExpression() != null && ((sourcePositions.getStartPosition(root, cst.getExpression()) >= offset) || (cst.getExpression().getKind() == Tree.Kind.ERRONEOUS && ((ErroneousTree) cst.getExpression()).getErrorTrees().isEmpty() && sourcePositions.getEndPosition(root, cst.getExpression()) >= offset))) { TreePath path1 = path.getParentPath(); if (path1.getLeaf().getKind() == Tree.Kind.SWITCH) { TypeMirror tm = controller.getTrees().getTypeMirror(new TreePath(path1, ((SwitchTree) path1.getLeaf()).getExpression())); if (tm.getKind() == TypeKind.DECLARED && ((DeclaredType) tm).asElement().getKind() == ENUM) { addEnumConstants(env, (TypeElement) ((DeclaredType) tm).asElement()); } else { addLocalConstantsAndTypes(env); } } } else { TokenSequence<JavaTokenId> ts = findLastNonWhitespaceToken(env, cst, offset); if (ts != null && ts.token().id() != JavaTokenId.DEFAULT) { localResult(env); addKeywordsForBlock(env); } } }
case SWITCH: CaseTree lastCase = null; for (CaseTree caseTree : ((SwitchTree) path.getLeaf()).getCases()) { lastCase = caseTree; stmts = lastCase.getStatements(); stmts = ((CaseTree) path.getLeaf()).getStatements(); break; case SWITCH: CaseTree lastCase = null; for (CaseTree caseTree : ((SwitchTree) path.getLeaf()).getCases()) { lastCase = caseTree; stmts = lastCase.getStatements();
private SwitchBuilder(SwitchTree tree, Void p) { this.switchTree = tree; this.caseBodyLabels = new Label[switchTree.getCases().size() + 1]; this.p = p; }
@Nullable @Override public Type visitSwitch(SwitchTree node, Void unused) { if (current == node.getExpression()) { return state.getTypes().unboxedTypeOrType(getType(current)); } else { return null; } }
@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(); defaultStatementGroup.add(caseTree); if (caseTree.getExpression() == null) { while (it.hasNext() && caseTree.getStatements().isEmpty()) { caseTree = it.next(); defaultStatementGroup.add(caseTree); 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 Description matchSwitch(SwitchTree tree, VisitorState state) { Type switchType = ASTHelpers.getType(tree.getExpression()); if (switchType.asElement().getKind() == ElementKind.ENUM) { 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() || Reachability.canCompleteNormally(Iterables.getLast(lastCase.getStatements()))) { replacement = "\nbreak;\ndefault: // fall out\n"; } else { 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) { 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(); }
@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 String visitSwitch( SwitchTree node, Object v ) { StringBuilder out = new StringBuilder(); appendComment( node, out ); List<? extends CaseTree> cases = node.getCases(); ExpressionTree expression = node.getExpression(); out.append( "switch " ); out.append( expression.accept( this, v ) ); out.append( " {\n" ); pushIndent(); _symTable.pushLocalScope(); for( CaseTree c : cases ) { out.append( c.accept( this, v ) ); out.append( "\n" ); } _symTable.popLocalScope(); popIndent(); appendIndent( out ); out.append( "}\n" ); return out.toString(); }
CompilationUnitTree root = env.getRoot(); SourcePositions sourcePositions = env.getSourcePositions(); for (CaseTree t : ((SwitchTree) tp.getLeaf()).getCases()) { if (sourcePositions.getStartPosition(root, t) >= env.getOffset()) { break; if (!caseAdded && (lastCase == null || lastCase.getExpression() != null)) { caseAdded = true; if (Utilities.startsWith(CASE_KEYWORD, prefix)) {
case SWITCH: SwitchTree sw = (SwitchTree) tree; if (sw.getExpression() != lastTree && sw.getExpression().getKind() != Tree.Kind.ERRONEOUS) { return null; case CASE: CaseTree ct = (CaseTree) tree; ExpressionTree exp = ct.getExpression(); if (exp != null && env.getSourcePositions().getEndPosition(env.getRoot(), exp) >= offset) { parentPath = path.getParentPath(); if (parentPath.getLeaf().getKind() == Tree.Kind.SWITCH) { exp = ((SwitchTree) parentPath.getLeaf()).getExpression(); type = controller.getTrees().getTypeMirror(new TreePath(parentPath, exp)); return type != null ? Collections.singleton(type) : null;
private boolean hasDefaultCase(SwitchTree tree) { return tree.getCases().stream() .map(CaseTree::getExpression) .anyMatch(Objects::isNull); } }