@Override public ExpressionTree visitReturn(ReturnTree tree, Void unused) { return tree.getExpression(); } },
@Override public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) { if (!MATCHER.matches(tree, state)) { return NO_MATCH; } ReturnTree returnTree = state.findEnclosing(ReturnTree.class); if (returnTree == null) { return NO_MATCH; } AtomicBoolean isTerminalCondition = new AtomicBoolean(false); returnTree.accept( new TreeScanner<Void, Void>() { @Override public Void visitMethodInvocation(MethodInvocationTree methodTree, Void unused) { if (methodTree.equals(tree)) { isTerminalCondition.set(true); } return super.visitMethodInvocation(methodTree, null); } @Override public Void visitBinary(BinaryTree binaryTree, Void unused) { return scan(binaryTree.getRightOperand(), null); } }, null); return isTerminalCondition.get() ? describeMatch(tree) : NO_MATCH; } }
@Override public Void visitReturn(ReturnTree node, VisitorState state) { return node.getExpression().accept(visitReturnExpression, state); } },
@Override public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) { if (!MATCHER.matches(tree, state)) { return NO_MATCH; } ReturnTree returnTree = state.findEnclosing(ReturnTree.class); if (returnTree == null) { return NO_MATCH; } AtomicBoolean isTerminalCondition = new AtomicBoolean(false); returnTree.accept( new TreeScanner<Void, Void>() { @Override public Void visitMethodInvocation(MethodInvocationTree methodTree, Void unused) { if (methodTree.equals(tree)) { isTerminalCondition.set(true); } return super.visitMethodInvocation(methodTree, null); } @Override public Void visitBinary(BinaryTree binaryTree, Void unused) { return scan(binaryTree.getRightOperand(), null); } }, null); return isTerminalCondition.get() ? describeMatch(tree) : NO_MATCH; } }
@Override public Boolean visitReturn(ReturnTree node, Void unused) { ExpressionTree returnExpression = node.getExpression(); Boolean returnValue = constValue(returnExpression, Boolean.class); return firstNonNull(returnValue, false); }
@Override public Void visitReturn(ReturnTree node, Void unused) { Type type = ASTHelpers.getType(node.getExpression()); if (type instanceof ClassType) { returnTypes.add((ClassType) type); } return null; }
@Override public boolean matches(StatementTree expressionTree, VisitorState state) { if (!(expressionTree instanceof ReturnTree)) { return false; } return returnedMatcher.matches(((ReturnTree) expressionTree).getExpression(), state); } }
@Override public Boolean visitReturn(ReturnTree tree, Void unused) { return scan(tree.getExpression(), null); }
@Override public Boolean visitReturn(ReturnTree node, VisitorState state) { return node.getExpression().accept(this, state); }
@Override public Boolean visitReturn(ReturnTree node, Void unused) { return node.getExpression().getKind() == NULL_LITERAL; }
@Override public MethodInvocationTree visitReturn(ReturnTree returnTree, Void unused) { return visit(returnTree.getExpression(), null); }
@Override @Nullable public Choice<Unifier> visitReturn(ReturnTree ret, @Nullable Unifier unifier) { return unifyNullable(unifier, getExpression(), ret.getExpression()); } }
@Override public UStatement visitReturn(ReturnTree tree, Void v) { PlaceholderMethod placeholderMethod = placeholder(tree.getExpression()); if (placeholderMethod != null) { MethodInvocationTree invocation = (MethodInvocationTree) tree.getExpression(); return UPlaceholderStatement.create( placeholderMethod, templateExpressions(invocation.getArguments()), ControlFlowVisitor.Result.ALWAYS_RETURNS); } return UReturn.create((tree.getExpression() == null) ? null : template(tree.getExpression())); }
@Override public void onDataflowVisitReturn( ReturnTree tree, NullnessStore thenStore, NullnessStore elseStore) { if (returnToEnclosingMethodOrLambda.containsKey(tree)) { Tree filterTree = returnToEnclosingMethodOrLambda.get(tree); assert (filterTree instanceof MethodTree || filterTree instanceof LambdaExpressionTree); ExpressionTree retExpression = tree.getExpression(); if (canBooleanExpressionEvalToTrue(retExpression)) { if (filterToNSMap.containsKey(filterTree)) { filterToNSMap.put(filterTree, filterToNSMap.get(filterTree).leastUpperBound(thenStore)); } else { filterToNSMap.put(filterTree, thenStore); } } } }
@Override public Void visitReturn(ReturnTree node, Void unused) { if (node.getExpression() != null && currentMethodOrInitializerOrLambda instanceof MethodTree) { Type returnType = ((MethodSymbol) TreeInfo.symbolFor((JCTree) currentMethodOrInitializerOrLambda)) .getReturnType(); generateConstraintsForWrite(returnType, node.getExpression(), node); } return super.visitReturn(node, unused); }
@Override public Choice<State<JCReturn>> visitReturn(ReturnTree node, State<?> state) { return chooseSubtrees(state, s -> unifyExpression(node.getExpression(), s), maker()::Return); }
@Override public Boolean visitBlock(BlockTree node, VisitorState state) { if (inBoxedVoidReturningMethod) { // Must have exactly 2 statements if (node.getStatements().size() != 2) { return false; } // Where the first one is a call to the methodToCall if (!node.getStatements().get(0).accept(this, state)) { return false; } // And the second one is "return null;" if (node.getStatements().get(1) instanceof ReturnTree) { ReturnTree returnTree = (ReturnTree) node.getStatements().get(1); if (returnTree.getExpression() instanceof LiteralTree) { Object returnValue = ((LiteralTree) returnTree.getExpression()).getValue(); return returnValue == null; } } return false; } else { return node.getStatements().size() == 1 && Iterables.getOnlyElement(node.getStatements()).accept(this, state); } }
private static boolean callsSuperEquals(MethodTree method, VisitorState state) { if (method.getBody() == null) { return false; } List<? extends Tree> statements = method.getBody().getStatements(); if (statements.size() != 1) { return false; } Tree statement = getOnlyElement(statements); if (!(statement instanceof ReturnTree)) { return false; } ExpressionTree expression = ((ReturnTree) statement).getExpression(); if (expression == null) { return false; } return instanceEqualsInvocation().matches(expression, state); } }
@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); } };