/** Returns true if the default is empty, or contains only a break statement. */ private boolean trivialDefault(List<? extends StatementTree> defaultStatements) { if (defaultStatements.isEmpty()) { return true; } return (defaultStatements.size() == 1 && getOnlyElement(defaultStatements).getKind() == Tree.Kind.BREAK); }
public Fix build(List<? extends StatementTree> throwingStatements) { if (throwingStatements.isEmpty()) { return baseFix; } SuggestedFix.Builder fix = SuggestedFix.builder().merge(baseFix); fix.addStaticImport("org.junit.Assert.assertThrows"); StringBuilder fixPrefix = new StringBuilder(); if (!newAsserts.isEmpty()) { fixPrefix.append(String.format("%s thrown = ", exceptionClassName)); } fixPrefix.append("assertThrows"); fixPrefix.append(String.format("(%s, () -> ", exceptionClassExpr)); boolean useExpressionLambda = throwingStatements.size() == 1 && getOnlyElement(throwingStatements).getKind() == Kind.EXPRESSION_STATEMENT; if (!useExpressionLambda) { fixPrefix.append("{"); } fix.prefixWith(throwingStatements.get(0), fixPrefix.toString()); if (useExpressionLambda) { fix.postfixWith(((ExpressionStatementTree) throwingStatements.get(0)).getExpression(), ")"); fix.postfixWith(getLast(throwingStatements), '\n' + Joiner.on('\n').join(newAsserts)); } else { fix.postfixWith(getLast(throwingStatements), "});\n" + Joiner.on('\n').join(newAsserts)); } return fix.build(); } }
@Override public Description matchForLoop(ForLoopTree forLoopTree, VisitorState visitorState) { List<? extends ExpressionStatementTree> updates = forLoopTree.getUpdate(); // keep track of all the symbols that are updated in the for loop header final Set<Symbol> incrementedSymbols = updates.stream() .filter(expStateTree -> expStateTree.getExpression() instanceof UnaryTree) .map( expStateTree -> ASTHelpers.getSymbol( ((UnaryTree) expStateTree.getExpression()).getExpression())) .collect(Collectors.toCollection(HashSet::new)); // track if they are updated in the body without a conditional surrounding them StatementTree body = forLoopTree.getStatement(); List<? extends StatementTree> statementTrees = body instanceof BlockTree ? ((BlockTree) body).getStatements() : ImmutableList.of(body); for (StatementTree s : statementTrees) { if (!CONDITIONALS.contains(s.getKind())) { Optional<Symbol> opSymbol = returnUnarySym(s); if (opSymbol.isPresent() && incrementedSymbols.contains(opSymbol.get())) { // both ++ and -- return describeMatch(forLoopTree); } } } return Description.NO_MATCH; }
private static boolean blockEndsInBreakOrReturn(VisitorState state) { TreePath statementPath = state.findPathToEnclosing(StatementTree.class); if (statementPath == null) { return false; } Tree parent = statementPath.getParentPath().getLeaf(); if (!(parent instanceof BlockTree)) { return false; } StatementTree statement = (StatementTree) statementPath.getLeaf(); List<? extends StatementTree> statements = ((BlockTree) parent).getStatements(); int idx = statements.indexOf(statement); if (idx == -1 || idx == statements.size()) { return false; } switch (getLast(statements).getKind()) { case BREAK: case RETURN: return true; default: return false; } }
@Override public boolean matches(MethodTree method, VisitorState state) { List<? extends VariableTree> parameters = method.getParameters(); if (!parameters.isEmpty()) { return false; } BlockTree body = method.getBody(); if (body == null) { return false; } List<? extends StatementTree> statements = body.getStatements(); if (statements.size() != 1) { return false; } StatementTree onlyStatement = Iterables.getOnlyElement(statements); if (!onlyStatement.getKind().equals(RETURN)) { return false; } return EMPTY_SET.matches(((ReturnTree) onlyStatement).getExpression(), state); } };
@Override public boolean matches(MethodTree t, VisitorState state) { List<? extends VariableTree> parameters = t.getParameters(); if (parameters.size() != 1) { return false; } final VariableTree onlyParameter = Iterables.getOnlyElement(parameters); BlockTree body = t.getBody(); if (body == null) { return false; } List<? extends StatementTree> statements = body.getStatements(); if (statements.size() != 1) { return false; } StatementTree onlyStatement = Iterables.getOnlyElement(statements); if (!onlyStatement.getKind().equals(RETURN)) { return false; } Symbol returnedSymbol = getSymbol(((ReturnTree) onlyStatement).getExpression()); if (returnedSymbol == null) { return false; } return getSymbol(onlyParameter).equals(returnedSymbol); } };
private boolean isThisCall(StatementTree statementTree, VisitorState state) { if (statementTree.getKind().equals(EXPRESSION_STATEMENT)) { ExpressionTree expression = ((ExpressionStatementTree) statementTree).getExpression(); return Matchers.methodInvocation(THIS_MATCHER).matches(expression, state); } return false; }
if (stmt.getKind().equals(Tree.Kind.TRY)) { TryTree tryTree = (TryTree) stmt; if (tryTree.getCatches().size() == 0) {
boolean useExpressionLambda = throwingStatements.size() == 1 && getOnlyElement(throwingStatements).getKind() == Kind.EXPRESSION_STATEMENT; if (!useExpressionLambda) { fixPrefix.append("{");
&& Iterables.getOnlyElement(bodyStatements).getKind() == Kind.RETURN && context.get(REQUIRE_BLOCK_KEY) == null) { ExpressionTree expression =
if (stmt.getKind().equals(EXPRESSION_STATEMENT)) { ExpressionTree expression = ((ExpressionStatementTree) stmt).getExpression(); if (invokeMatcher.matches(expression, state)) {
if (curStmt.getKind().equals(Tree.Kind.TRY)) { TryTree tryTree = (TryTree) curStmt;
for (TreePath usagePath : usagePaths) { StatementTree statement = (StatementTree) usagePath.getLeaf(); if (statement.getKind() == Kind.VARIABLE) { VariableTree variableTree = (VariableTree) statement; ExpressionTree initializer = variableTree.getInitializer(); } else if (statement.getKind() == Kind.EXPRESSION_STATEMENT) { JCTree tree = (JCTree) ((ExpressionStatementTree) statement).getExpression();
&& tree.getBody().getStatements().get(0).getKind() == Kind.RETURN) { ReturnTree returnTree = (ReturnTree) tree.getBody().getStatements().get(0); if (returnTree.getExpression().getKind() == Kind.CONDITIONAL_EXPRESSION) {
unconsumedStatements.subList(1, unconsumedStatements.size()); StatementTree firstStatement = unconsumedStatements.get(0); if (firstStatement.getKind() != Kind.IF) { return Choice.none();
/** Returns true if the default is empty, or contains only a break statement. */ private boolean trivialDefault(List<? extends StatementTree> defaultStatements) { if (defaultStatements.isEmpty()) { return true; } return (defaultStatements.size() == 1 && getOnlyElement(defaultStatements).getKind() == Tree.Kind.BREAK); }
public IfTree If(ExpressionTree condition, StatementTree thenStatement, StatementTree elseStatement) { if (thenStatement != null && thenStatement.getKind() == Tree.Kind.IF && elseStatement != null && ((IfTree)thenStatement).getElseStatement() == null) { // Issue #257910: special case - if `thenStatement' is just inserted into the source. // If the nested if contains `else' clause, it gets paired correctly. thenStatement = Block(Collections.singletonList(thenStatement), false); } return make.at(NOPOS).If((JCExpression)condition, (JCStatement)thenStatement, (JCStatement)elseStatement); }
public Object run(CompilationInfo cinfo) { ExecutableElement execElement = execElementHandle.resolve(cinfo); BlockTree block = cinfo.getTrees().getTree(execElement).getBody(); for(StatementTree stmtTree : block.getStatements()){ if(stmtTree.getKind() == Tree.Kind.TRY) { return true; } } return false; } }, javaClass.getFileObject());
public static boolean IsPropertySetter(CompilationInfo cinfo, StatementTree stmtTree) { if(stmtTree.getKind() == Tree.Kind.EXPRESSION_STATEMENT) { ExpressionStatementTree exprStmtTree = (ExpressionStatementTree)stmtTree; if(exprStmtTree.getExpression().getKind() == Tree.Kind.METHOD_INVOCATION) { MethodInvocationTree methInvkTree = (MethodInvocationTree)exprStmtTree.getExpression(); if(methInvkTree.getMethodSelect().getKind() == Tree.Kind.MEMBER_SELECT) { MemberSelectTree memSelTree = (MemberSelectTree)methInvkTree.getMethodSelect(); if(methInvkTree.getArguments().size() == 1 && memSelTree.getExpression().getKind() == Tree.Kind.IDENTIFIER) { return true; } } } } return false; }
/** * Creates a new BlockTree for provided <tt>bodyText</tt>. * * @param method figures out the scope for attribution. * @param bodyText text which will be used for method body creation. * @return a new tree for <tt>bodyText</tt>. */ public BlockTree createMethodBody(MethodTree method, String bodyText) { SourcePositions[] positions = new SourcePositions[1]; final TreeUtilities treeUtils = copy.getTreeUtilities(); StatementTree body = treeUtils.parseStatement(bodyText, positions); assert Tree.Kind.BLOCK == body.getKind() : "Not a statement block!"; Scope scope = copy.getTrees().getScope(TreePath.getPath(copy.getCompilationUnit(), method)); treeUtils.attributeTree(body, scope); mapComments((BlockTree) body, bodyText, copy, handler, positions[0]); new TreePosCleaner().scan(body, null); return (BlockTree) body; }