for (StatementTree statement : block.getStatements()) { if (!mutateMatcher.matches(statement, state)) { return Optional.empty(); ((MethodInvocationTree) ((ExpressionStatementTree) statement).getExpression()) .getArguments()); .anyMatch(a -> a.getKind() == Kind.NULL_LITERAL)) { return Optional.empty();
private boolean isSynthetic(CompilationUnitTree cut, Tree leaf) { JCTree tree = (JCTree) leaf; if (tree.pos == (-1)) return true; if (leaf.getKind() == Tree.Kind.METHOD) { //check for synthetic constructor: return (((JCMethodDecl)leaf).mods.flags & Flags.GENERATEDCONSTR) != 0L; } //check for synthetic superconstructor call: if (leaf.getKind() == Tree.Kind.EXPRESSION_STATEMENT) { ExpressionStatementTree est = (ExpressionStatementTree) leaf; if (est.getExpression().getKind() == Tree.Kind.METHOD_INVOCATION) { MethodInvocationTree mit = (MethodInvocationTree) est.getExpression(); if (mit.getMethodSelect().getKind() == Tree.Kind.IDENTIFIER) { IdentifierTree it = (IdentifierTree) mit.getMethodSelect(); if ("super".equals(it.getName().toString())) { return sp.getEndPosition(cut, leaf) == (-1); } } } } return false; }
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) { Tree retTree = ((MethodTree) methodOrLambdaPath.getLeaf()).getReturnType(); if (retTree == null) { case SWITCH: SwitchTree sw = (SwitchTree) tree; if (sw.getExpression() != lastTree && sw.getExpression().getKind() != Tree.Kind.ERRONEOUS) { return null; if (!mi.getTypeArguments().isEmpty()) { return ret; case EXPRESSION_STATEMENT: exp = ((ExpressionStatementTree) tree).getExpression(); if (exp.getKind() == Tree.Kind.PARENTHESIZED) { text = controller.getText().substring((int) env.getSourcePositions().getStartPosition(env.getRoot(), exp), offset).trim(); if (text.endsWith(")")) //NOI18N
ClassTree clazz = null; for (Tree typeDecl : cu.getTypeDecls()) { if (TreeUtilities.CLASS_TREE_KINDS.contains(typeDecl.getKind())) { ClassTree candidate = (ClassTree) typeDecl; if (candidate.getModifiers().getFlags().contains(javax.lang.model.element.Modifier.PUBLIC)) { if (Tree.Kind.VARIABLE == member.getKind()) { VariableTree variable = (VariableTree)member; String type = variable.getType().toString(); if (clMember.getKind() == Tree.Kind.METHOD) { MethodTree method = (MethodTree)clMember; String methodName = method.getName().toString(); if (block.getStatements().size() != 1) continue; StatementTree statement = block.getStatements().get(0); if (statement.getKind() != Tree.Kind.EXPRESSION_STATEMENT) continue; ExpressionTree expression = ((ExpressionStatementTree)statement).getExpression(); if (expression.getKind() != Tree.Kind.ASSIGNMENT) continue; AssignmentTree assignment = (AssignmentTree)expression; String parName = assignment.getExpression().toString();
@Override public ExpressionTree visitExpressionStatement( ExpressionStatementTree tree, Void unused) { return tree.getExpression(); }
private Optional<Fix> rethrowFix(ImmutableList<CatchTree> catchBlocks, VisitorState state) { SuggestedFix.Builder fix = SuggestedFix.builder(); catchBlocks.forEach( c -> { // e.g. // fail("message") -> throw new AssertionError("message", cause); // assertWithMessage("message format %s", 42) -> // throw new AssertionError(String.format("message format %s", 42), cause); StatementTree statementTree = getOnlyElement(c.getBlock().getStatements()); MethodInvocationTree methodInvocationTree = (MethodInvocationTree) ((ExpressionStatementTree) statementTree).getExpression(); String message = null; if (message == null && !methodInvocationTree.getArguments().isEmpty()) { message = getMessageOrFormat(methodInvocationTree, state); } if (message != null) { // only catch and rethrow to add additional context, not for raw `fail()` calls fix.replace( statementTree, String.format( "throw new AssertionError(%s, %s);", message, c.getParameter().getName())); } }); return fix.isEmpty() ? Optional.empty() : Optional.of(fix.build()); }
private static boolean invokedConstructorMustBeClosed(VisitorState state, MethodTree methodTree) { // The first statement in a constructor should be an invocation of the super/this constructor. List<? extends StatementTree> statements = methodTree.getBody().getStatements(); if (statements.isEmpty()) { // Not sure how the body would be empty, but just filter it out in case. return false; } ExpressionStatementTree est = (ExpressionStatementTree) statements.get(0); MethodInvocationTree mit = (MethodInvocationTree) est.getExpression(); MethodSymbol invokedConstructorSymbol = ASTHelpers.getSymbol(mit); return ASTHelpers.hasAnnotation(invokedConstructorSymbol, MustBeClosed.class, state); } }
StatementTree findPropertyStatement(CompilationInfo cinfo, String beanName, String methodName) { ExecutableElement execElement = execElementHandle.resolve(cinfo); BlockTree block = cinfo.getTrees().getTree(execElement).getBody(); for(StatementTree statement : block.getStatements()) { if(statement.getKind() == Tree.Kind.EXPRESSION_STATEMENT) { ExpressionStatementTree exprStatTree = (ExpressionStatementTree)statement; if(exprStatTree.getExpression().getKind() == Tree.Kind.METHOD_INVOCATION) { MethodInvocationTree methInvkTree = (MethodInvocationTree)exprStatTree.getExpression(); if(methInvkTree.getMethodSelect().getKind() == Tree.Kind.MEMBER_SELECT) { MemberSelectTree memSelTree = (MemberSelectTree)methInvkTree.getMethodSelect(); ExpressionTree exprTree = memSelTree.getExpression(); if(exprTree.getKind() == Tree.Kind.IDENTIFIER && memSelTree.getIdentifier().toString().equals(methodName) && ((IdentifierTree)exprTree).getName().toString().equals(beanName)) { return statement; } } } } } return null; }
@Override public UStatement visitExpressionStatement(ExpressionStatementTree tree, Void v) { PlaceholderMethod placeholderMethod = placeholder(tree.getExpression()); if (placeholderMethod != null && placeholderMethod.returnType().equals(UPrimitiveType.VOID)) { MethodInvocationTree invocation = (MethodInvocationTree) tree.getExpression(); return UPlaceholderStatement.create( placeholderMethod, templateExpressions(invocation.getArguments()), ControlFlowVisitor.Result.NEVER_EXITS); } return UExpressionStatement.create(template(tree.getExpression())); }
private boolean isTopLevelClass(Tree tree, CompilationUnitTree root) { if (TreeUtilities.CLASS_TREE_KINDS.contains(tree.getKind()) || (tree.getKind() == Tree.Kind.EXPRESSION_STATEMENT && ((ExpressionStatementTree) tree).getExpression().getKind() == Tree.Kind.ERRONEOUS)) { for (Tree t : root.getTypeDecls()) { if (tree == t) { return true; } } } return false; }
ExpressionStatementTree est = (ExpressionStatementTree) path.getLeaf(); CompilationController controller = env.getController(); Tree t = est.getExpression(); if (t.getKind() == Tree.Kind.ERRONEOUS) { Iterator<? extends Tree> it = ((ErroneousTree) t).getErrorTrees().iterator(); if (it.hasNext()) { localResult(env); Tree parentTree = path.getParentPath().getLeaf(); switch (parentTree.getKind()) { case FOR_LOOP: if (((ForLoopTree) parentTree).getStatement() == est) { if (t.getKind() == Tree.Kind.MODIFIERS) { insideModifiers(env, tPath); } else if (t.getKind() == Tree.Kind.MEMBER_SELECT && ERROR.contentEquals(((MemberSelectTree) t).getIdentifier())) {
@Override public Description matchTry(TryTree tree, VisitorState state) { List<? extends StatementTree> body = tree.getBlock().getStatements(); if (body.isEmpty() || tree.getFinallyBlock() != null || tree.getCatches().size() != 1) { if (catchTree.getParameter().getType().getKind() == UNION_TYPE) { tree.getBlock().getStatements().subList(0, tree.getBlock().getStatements().size() - 1); if (throwingStatements.isEmpty()) { return NO_MATCH; if (useExpressionLambda) { fix.postfixWith( ((ExpressionStatementTree) throwingStatements.iterator().next()).getExpression(), ")"); } else { fix.postfixWith(getLast(throwingStatements), "});");
@Override public Description visitExpressionStatement(ExpressionStatementTree node, Void aVoid) { return node.getExpression().accept(this, null); } }
VariableTree variableTree = (VariableTree) statement; ExpressionTree initializer = variableTree.getInitializer(); if (hasSideEffect(initializer) && TOP_LEVEL_EXPRESSIONS.contains(initializer.getKind())) { encounteredSideEffects = true; if (varKind == ElementKind.FIELD) { JCTree tree = (JCTree) ((ExpressionStatementTree) statement).getExpression();
out.append("true"); } else { out.append(condition.accept(this, v)); symTable.pushLocalScope(); if (statement instanceof BlockTree) { List<? extends StatementTree> statements = ((BlockTree) statement).getStatements(); for (StatementTree stm : statements) { appendIndent(out); for (ExpressionStatementTree stm : update) { appendIndent(out); out.append(stm.accept(this, v)); out.append("\n");
private void addSyntheticTrees(DiffContext diffContext, Tree node) { if (node == null) return ; if (((JCTree) node).pos == (-1)) { diffContext.syntheticTrees.add(node); return ; } if (node.getKind() == Kind.EXPRESSION_STATEMENT) { ExpressionTree est = ((ExpressionStatementTree) node).getExpression(); if (est.getKind() == Kind.METHOD_INVOCATION) { ExpressionTree select = ((MethodInvocationTree) est).getMethodSelect(); if (select.getKind() == Kind.IDENTIFIER && ((IdentifierTree) select).getName().contentEquals("super")) { if (getTreeUtilities().isSynthetic(diffContext.origUnit, node)) { diffContext.syntheticTrees.add(node); } } } } }
@Override public Boolean visitBlock(BlockTree node, Void p) { if (node.isStatic()) accept(STATIC); CodeStyle.BracePlacement bracePlacement; boolean spaceBeforeLeftBrace = false; switch (getCurrentPath().getParentPath().getLeaf().getKind()) { case ANNOTATION_TYPE: case CLASS: case INTERFACE: bracePlacement = cs.getOtherBracePlacement(); if (node.isStatic()) spaceBeforeLeftBrace = cs.spaceBeforeStaticInitLeftBrace(); break; int lastMaxPreservedBlankLines = maxPreservedBlankLines; maxPreservedBlankLines = cs.getMaximumBlankLinesInCode(); for (StatementTree stat : node.getStatements()) { if (!isSynthetic(getCurrentPath().getCompilationUnit(), stat)) { isEmpty = false; appendToDiff(getNewlines(1) + getIndent()); col = indent(); } else if (stat.getKind() == Tree.Kind.EMPTY_STATEMENT || stat.getKind() == Tree.Kind.EXPRESSION_STATEMENT && ((ExpressionStatementTree)stat).getExpression().getKind() == Tree.Kind.ERRONEOUS) { spaces(0, true); } else if (!fieldGroup || stat.getKind() != Tree.Kind.VARIABLE) {
@Override public boolean matches(StatementTree statementTree, VisitorState state) { return statementTree instanceof ExpressionStatementTree && matcher.matches(((ExpressionStatementTree) statementTree).getExpression(), state); } };
return NO_MATCH; ExpressionTree arg = getLast(tree.getArguments()); if (!(arg instanceof LambdaExpressionTree)) { return NO_MATCH; return NO_MATCH; List<? extends StatementTree> statements = ((BlockTree) body).getStatements(); if (statements.size() <= 1) { return NO_MATCH; fix.replace(body, state.getSourceForNode(((ExpressionStatementTree) last).getExpression())); } else { fix.replace(startPosition, endPosition, "");
@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; }