Refine search
@Override public Void visitIdentifier(IdentifierTree tree, Void unused) { Symbol sym = ASTHelpers.getSymbol(tree); if (sym == null) { return null; } Tree parent = getCurrentPath().getParentPath().getLeaf(); if (parent.getKind() == Tree.Kind.CASE && ((CaseTree) parent).getExpression().equals(tree) && sym.owner.getKind() == ElementKind.ENUM) { // switch cases can refer to enum constants by simple name without importing them return null; } if (sym.owner.equals(owner) && unit.starImportScope.includes(sym)) { fix.prefixWith(tree, owner.getSimpleName() + "."); } return null; } }.scan(unit, null);
@Override public Choice<State<JCCase>> visitCase(final CaseTree node, State<?> state) { return chooseSubtrees( state, s -> unifyStatements(node.getStatements(), s), stmts -> maker().Case((JCExpression) node.getExpression(), stmts)); }
@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 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; }
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); } } }
public static List<? extends StatementTree> getStatements(TreePath firstLeaf) { switch (firstLeaf.getParentPath().getLeaf().getKind()) { case BLOCK: return ((BlockTree) firstLeaf.getParentPath().getLeaf()).getStatements(); case CASE: return ((CaseTree) firstLeaf.getParentPath().getLeaf()).getStatements(); default: return Collections.singletonList((StatementTree) firstLeaf.getLeaf()); } }
stmts = ((BlockTree) path.getLeaf()).getStatements(); break; case FOR_LOOP: case SWITCH: CaseTree lastCase = null; for (CaseTree caseTree : ((SwitchTree) path.getLeaf()).getCases()) { lastCase = caseTree; stmts = lastCase.getStatements(); stmts = ((CaseTree) path.getLeaf()).getStatements(); break; final StatementTree block = (((BlockTree) blockPath.getLeaf()).isStatic() ? tu.parseStaticBlock(blockText, sp) : tu.parseStatement(blockText, sp)); if (block == null) { return null; case SWITCH: CaseTree lastCase = null; for (CaseTree caseTree : ((SwitchTree) path.getLeaf()).getCases()) { lastCase = caseTree; stmts = lastCase.getStatements(); stmts = ((CaseTree) path.getLeaf()).getStatements(); break;
SourcePositions sourcePositions = info.getTrees().getSourcePositions(); TreePath path = pathFor(pos); CompilationUnitTree root = path.getCompilationUnit(); switch (path.getLeaf().getKind()) { case BLOCK: stmts = ((BlockTree)path.getLeaf()).getStatements(); break; case FOR_LOOP: break; case CASE: stmts = ((CaseTree)path.getLeaf()).getStatements(); break; case METHOD: if (TreeUtilities.CLASS_TREE_KINDS.contains(path.getLeaf().getKind())) { TokenSequence<JavaTokenId> ts = info.getTokenHierarchy().tokenSequence(JavaTokenId.language()); ts.move(pos);
for (CaseTree ct : ((SwitchTree)last).getCases()) { if (getEndPosition(ct) > startOffset) { break; if (nextTokenId == null || !EnumSet.of(JavaTokenId.CASE, JavaTokenId.DEFAULT).contains(nextTokenId)) { t = null; for (StatementTree st : ct.getStatements()) { if (getEndPosition(st) > startOffset) { break; currentIndent = i < 0 ? getStmtIndent(startOffset, endOffset, EnumSet.of(JavaTokenId.COLON), getEndPosition(ct.getExpression()), currentIndent) : i; } else { int i = getCurrentIndent(ct, path); currentIndent = i < 0 ? getStmtIndent(startOffset, endOffset, EnumSet.of(JavaTokenId.COLON), getEndPosition(ct.getExpression()), currentIndent) : i; currentIndent += cs.getIndentSize(); case CASE: t = null; for (StatementTree st : ((CaseTree)last).getStatements()) { if (getEndPosition(st) > startOffset) { break; currentIndent = i < 0 ? getStmtIndent(startOffset, endOffset, EnumSet.of(JavaTokenId.COLON), getEndPosition(((CaseTree)last).getExpression()), currentIndent) : i; } else { currentIndent = getStmtIndent(startOffset, endOffset, EnumSet.of(JavaTokenId.COLON), getEndPosition(((CaseTree)last).getExpression()), currentIndent);
private java.util.List<? extends StatementTree> getStatements(Tree tree) { switch (tree.getKind()) { case BLOCK: return ((BlockTree) tree).getStatements(); case CASE: return ((CaseTree) tree).getStatements(); default: return null; } }
public Boolean visitCase(CaseTree node, TreePath p) { if (p == null) { super.visitCase(node, p); return false; } CaseTree ct = (CaseTree) p.getLeaf(); if (!scan(node.getExpression(), ct.getExpression(), p)) return false; return checkLists(node.getStatements(), ct.getStatements(), p); }
@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 { if (!defaultCase.getStatements().isEmpty()) { return NO_MATCH;
private void insideSwitch(Env env) throws IOException { int offset = env.getOffset(); TreePath path = env.getPath(); SwitchTree st = (SwitchTree) path.getLeaf(); 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 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 protected Iterable<? extends StatementTree> getChildNodes(T tree, VisitorState state) { Tree enclosing = state.findEnclosing(CaseTree.class, BlockTree.class); if (enclosing == null) { return ImmutableList.of(); } if (enclosing instanceof BlockTree) { return ((BlockTree) enclosing).getStatements(); } else if (enclosing instanceof CaseTree) { return ((CaseTree) enclosing).getStatements(); } else { // findEnclosing given two types must return something of one of those types throw new IllegalStateException("enclosing tree not a BlockTree or CaseTree"); } } }
@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(); }
@Override public Void visitCase(CaseTree tree, EnumSet<UseTypes> p) { if (tree.getExpression() != null && tree.getExpression().getKind() == Kind.IDENTIFIER) { handlePossibleIdentifier(new TreePath(getCurrentPath(), tree.getExpression()), EnumSet.of(UseTypes.READ)); } return super.visitCase(tree, null); }
@Override public Result visitCase(CaseTree node, BreakContext cxt) { return visitStatements(node.getStatements(), cxt); }
public CaseNode(CaseTree tree, Node switchExpr, Node caseExpr, Types types) { super(types.getNoType(TypeKind.NONE)); assert tree.getKind().equals(Kind.CASE); this.tree = tree; this.switchExpr = switchExpr; this.caseExpr = caseExpr; }
type = controller.getTrees().getTypeMirror(new TreePath(path, ((AssignmentTree) tree).getVariable())); if (type == null) { return null; if (parentPath != null && parentPath.getLeaf().getKind() == Tree.Kind.ANNOTATION && type.getKind() == TypeKind.EXECUTABLE) { type = ((ExecutableType) type).getReturnType(); while (dim-- > 0) { return null; if (methodOrLambdaPath.getLeaf().getKind() == Tree.Kind.METHOD) { case SWITCH: SwitchTree sw = (SwitchTree) tree; if (sw.getExpression() != lastTree && sw.getExpression().getKind() != Tree.Kind.ERRONEOUS) { return null; final Trees trs = controller.getTrees(); final TypeElement enclClass = scope.getEnclosingClass(); final boolean isStatic = enclClass != null ? (tu.isStaticContext(scope) || (env.getPath().getLeaf().getKind() == Tree.Kind.BLOCK && ((BlockTree) env.getPath().getLeaf()).isStatic())) : false; if (SUPER_KEYWORD.equals(name) && enclClass != null) { ElementUtilities.ElementAcceptor acceptor = new ElementUtilities.ElementAcceptor() { case CASE: CaseTree ct = (CaseTree) tree; ExpressionTree exp = ct.getExpression(); exp = ((SwitchTree) parentPath.getLeaf()).getExpression();