private static Optional<String> findNullableAnnotation(MethodTree methodTree) { SymbolMetadata methodMetadata = methodTree.symbol().metadata(); if (methodMetadata.isAnnotatedWith("javax.annotation.CheckForNull")) { return Optional.of("@CheckForNull"); } else if (methodMetadata.isAnnotatedWith("javax.annotation.Nullable")) { return Optional.of("@Nullable"); } return Optional.empty(); }
private static List<String> getThrownCheckedExceptions(MethodTree methodTree) { ImmutableList.Builder<String> builder = ImmutableList.builder(); for (Type thrownClass : methodTree.symbol().thrownTypes()) { if (!thrownClass.isUnknown() && !isSubClassOfRuntimeException(thrownClass)) { builder.add(thrownClass.fullyQualifiedName()); } } return builder.build(); }
public static CFG build(MethodTree tree) { BlockTree block = tree.block(); Preconditions.checkArgument(block != null, "Cannot build CFG for method with no body."); return new CFG(block.body(), tree.symbol(), false); }
private static boolean isTestMethod(MethodTree methodTree) { SymbolMetadata metadata = methodTree.symbol().metadata(); return metadata.isAnnotatedWith("org.junit.Test") || metadata.isAnnotatedWith("org.testng.annotations.Test"); } }
@Override public void visitNode(Tree tree) { MethodTree methodTree = (MethodTree) tree; if(methodTree.symbol().metadata().isAnnotatedWith("org.junit.Ignore")) { addIssue(tree, "Fix or remove this skipped unit test"); } } }
private static boolean isAnnotatedWithCheckForNull(MethodTree methodTree) { SymbolMetadata methodMetadata = methodTree.symbol().metadata(); return methodMetadata.isAnnotatedWith("javax.annotation.CheckForNull") || methodMetadata.isAnnotatedWith("javax.annotation.Nullable"); }
private void checkNotStatic(MethodTree methodTree) { Symbol.MethodSymbol methodSymbol = methodTree.symbol(); if (methodSymbol.isStatic()) { reportIssue(methodTree.simpleName(), "The \"static\" modifier should not be applied to \"" + methodSymbol.name() + "\"."); } }
private void throwTooManyBooleanStates(MethodTree tree, TooManyNestedBooleanStatesException e) { String message = String.format("reached maximum number of %d branched states for method %s in class %s", MAX_NESTED_BOOLEAN_STATES, tree.simpleName().name(), tree.symbol().owner().name()); MaximumStepsReachedException cause = new MaximumStepsReachedException(message, e); interrupted(cause); throw cause; }
private void throwTooManyBooleanStates(MethodTree tree, TooManyNestedBooleanStatesException e) { String message = String.format("reached maximum number of %d branched states for method %s in class %s", MAX_NESTED_BOOLEAN_STATES, tree.simpleName().name(), tree.symbol().owner().name()); MaximumStepsReachedException cause = new MaximumStepsReachedException(message, e); interrupted(cause); throw cause; }
private void checkExplodedGraphTooBig(ProgramState programState) { // Arbitrary formula to avoid out of memory errors if (steps + workList.size() > MAX_STEPS / 2 && programState.constraintsSize() > 75) { throw new ExplodedGraphTooBigException("Program state constraints are too big : stopping Symbolic Execution for method " + methodTree.simpleName().name() + " in class " + methodTree.symbol().owner().name()); } }
@Override public void visitNode(Tree tree) { if (!hasSemantic()) { return; } MethodTree methodTree = (MethodTree) tree; methodTree.block().accept(new ConstructorBodyVisitor(methodTree.symbol().owner())); }
private static boolean isMemberAutowired(Tree member) { Symbol s = null; if (member.is(Kind.VARIABLE)) { s = ((VariableTree) member).symbol(); } else if (member.is(Kind.METHOD)) { s = ((MethodTree) member).symbol(); } return s != null && !s.isStatic() && isAutowired(s); }
private static boolean isOwnedBySerializableExtensibleClass(MethodTree method) { Symbol owner = method.symbol().owner(); return !owner.isPrivate() && !owner.isFinal() && owner.type().isSubtypeOf("java.io.Serializable"); } }
private static boolean hasArgs4JAnnotation(Tree tree) { if (tree.is(Tree.Kind.METHOD)) { return hasArgs4JAnnotation(((MethodTree) tree).symbol()); } else if (tree.is(Tree.Kind.VARIABLE)) { return hasArgs4JAnnotation(((VariableTree) tree).symbol()); } return false; }
@Override public void visitNode(Tree tree) { if (!hasSemantic()) { return; } Symbol.MethodSymbol method = ((MethodTree) tree).symbol(); if (method.isAbstract() && method.owner().isAbstract()) { checkMethod((JavaSymbol.MethodJavaSymbol) method); } }
@Override public void visitNode(Tree tree) { MethodTree methodTree = (MethodTree) tree; Symbol.MethodSymbol methodSymbol = methodTree.symbol(); boolean isMethodInJunit3 = isWithinJunit3TestCase(methodSymbol) && isSetUpOrTearDown(methodSymbol); if (isMethodInJunit3 && requiresSuperCall(methodSymbol) && !callSuperOnOverride(methodTree.block(), methodSymbol)) { reportIssue(methodTree.simpleName(), String.format("Add a \"super.%s()\" call to this method.", methodSymbol.name())); } }
private static boolean isUselessSuperCall(MethodTree methodTree) { ExpressionTree callToSuper = null; StatementTree statementTree = methodTree.block().body().get(0); if (returnsVoid(methodTree) && statementTree.is(Tree.Kind.EXPRESSION_STATEMENT)) { callToSuper = ((ExpressionStatementTree) statementTree).expression(); } else if (statementTree.is(Tree.Kind.RETURN_STATEMENT)) { callToSuper = ((ReturnStatementTree) statementTree).expression(); } return callToSuper != null && isCallToSuper(methodTree, callToSuper) && sameVisibility(methodTree.symbol(), ((MethodInvocationTree) callToSuper).symbol()); }
@Override public void visitNode(Tree tree) { MethodTree methodTree = (MethodTree) tree; if (!hasSemantic()) { return; } if (methodTree.block() != null && isHasNextMethod(methodTree)) { hasNextBodyVisitor.setHasNextOwner(methodTree.symbol().owner()); methodTree.block().accept(hasNextBodyVisitor); } }
@Override public void visitMethod(MethodTree tree) { //skip return type, and throw clauses : visited in second pass. scan(tree.modifiers()); completeMetadata((JavaSymbol.MethodJavaSymbol) tree.symbol(), tree.modifiers().annotations()); scan(tree.typeParameters()); // revisits the parameters to resolve their annotations. scan(tree.parameters()); scan(tree.defaultValue()); scan(tree.block()); }
@Override public void visitMethod(MethodTree tree) { //skip return type, and throw clauses : visited in second pass. scan(tree.modifiers()); completeMetadata((JavaSymbol.MethodJavaSymbol) tree.symbol(), tree.modifiers().annotations()); scan(tree.typeParameters()); // revisits the parameters to resolve their annotations. scan(tree.parameters()); scan(tree.defaultValue()); scan(tree.block()); }