@Override public ExpressionTree visitReturn(ReturnTree tree, Void unused) { return tree.getExpression(); } },
@Override public Void visitReturn(ReturnTree node, VisitorState state) { return node.getExpression().accept(visitReturnExpression, state); } },
@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 MethodInvocationTree visitReturn(ReturnTree returnTree, Void unused) { return visit(returnTree.getExpression(), null); }
@Override public Boolean visitReturn(ReturnTree node, Void unused) { return node.getExpression().getKind() == NULL_LITERAL; }
@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); }
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 final Description matchReturn(ReturnTree tree, VisitorState state) { if (tree.getExpression() == null || tree.getExpression().getKind() != NULL_LITERAL) { return NO_MATCH; } TreePath path = state.getPath(); while (path != null && path.getLeaf() instanceof StatementTree) { path = path.getParentPath(); } if (path == null || !(path.getLeaf() instanceof MethodTree)) { return NO_MATCH; } if (!implementsAsyncTypeMethod.matches((MethodTree) path.getLeaf(), state)) { return NO_MATCH; } return describeMatch( tree, SuggestedFix.builder() .replace(tree.getExpression(), "immediateFuture(null)") .addStaticImport(Futures.class.getName() + ".immediateFuture") .build()); }
@Override public Description matchReturn(ReturnTree tree, VisitorState state) { if (tree.getExpression() == null) { return NO_MATCH; } Type type = null; outer: for (Tree parent : state.getPath()) { switch (parent.getKind()) { case METHOD: type = ASTHelpers.getType(((MethodTree) parent).getReturnType()); break outer; case LAMBDA_EXPRESSION: type = state.getTypes().findDescriptorType(ASTHelpers.getType(parent)).getReturnType(); break outer; default: // fall out } } if (type == null) { return NO_MATCH; } return check(type, tree.getExpression()); }
@Override public boolean matches(ReturnTree tree, VisitorState state) { return allOf( not(withinThrowOrAnnotation), enclosingMethod( allOf(noAllocationMethodMatcher, methodReturnsNonPrimitiveType())), isPrimitiveType()) .matches(tree.getExpression(), state); } };
@Override public Boolean visitReturn(ReturnTree node, Void v) { if (node.getExpression() != null) { TreePath tp = verifier.getTreeUtils().getPath(verifier.getCompilationUnit(), node); while (tp != null) { tp = tp.getParentPath(); Tree leaf = tp.getLeaf(); if (leaf.getKind() == Tree.Kind.METHOD) { if (isAnnotated((MethodTree)leaf)) { return reportError("return.type.should.be.void", node); } else { return super.visitReturn(node, v); } } } } return super.visitReturn(node, v); }