private void reportAll(CheckerContext context) { CheckerDispatcher checkerDispatcher = (CheckerDispatcher) context; methodInvocations.pop().stream() .filter(mit -> mit.symbol().isMethodSymbol()) .forEach(mit -> reportYields(mit, checkerDispatcher)); }
private void checkIdentifier(IdentifierTree tree) { Symbol reference = tree.symbol(); String name = tree.name(); if (reference.isMethodSymbol()) { name += "()"; } conditionNames.add(name); if (updateSymbols.contains(reference)) { shouldRaiseIssue = false; } } }
private boolean declaresCloneMethod(Symbol.TypeSymbol classSymbol) { for (Symbol memberSymbol : classSymbol.lookupSymbols("clone")) { if (memberSymbol.isMethodSymbol()) { Symbol.MethodSymbol methodSymbol = (Symbol.MethodSymbol) memberSymbol; if (methodSymbol.parameterTypes().isEmpty()) { return true; } } } return false; }
private void checkNonConstructor(Symbol scopeOwner) { if (scopeOwner.isMethodSymbol()) { return; } if (hasLocalAccess(methodScopeOwner, scopeOwner)) { setNonStaticReference(); } }
@CheckForNull private static String nonNullReturnTypeAnnotation(Symbol symbol) { if (symbol.isMethodSymbol() && !isUsingNullable(symbol)) { Symbol.MethodSymbol methodSymbol = (Symbol.MethodSymbol) symbol; if (isGloballyAnnotatedWithEclipseNonNullByDefault(methodSymbol, "RETURN_TYPE")) { return ORG_ECLIPSE_JDT_ANNOTATION_NON_NULL_BY_DEFAULT; } else if (valuesForGlobalAnnotation(methodSymbol, ORG_SPRINGFRAMEWORK_LANG_NON_NULL_API) != null) { return ORG_SPRINGFRAMEWORK_LANG_NON_NULL_API; } } return null; }
private static boolean hasNonPrivateNoArgConstructor(Type type) { Collection<Symbol> constructors = type.symbol().lookupSymbols("<init>"); for (Symbol member : constructors) { if (member.isMethodSymbol()) { Symbol.MethodSymbol method = (Symbol.MethodSymbol) member; if (method.parameterTypes().isEmpty() && !method.isPrivate()) { return true; } } } return constructors.isEmpty(); }
private static boolean isMethodInvocationThrowingCheckedException(ExpressionTree expr) { return expr.is(Tree.Kind.METHOD_INVOCATION) && ((MethodInvocationTree) expr).symbol().isMethodSymbol() && ((JavaSymbol.MethodJavaSymbol) ((MethodInvocationTree) expr).symbol()).thrownTypes().stream().anyMatch(t-> !t.isSubtypeOf("java.lang.RuntimeException")); }
private static boolean isMethodInvocationThrowingCheckedException(ExpressionTree expr) { return expr.is(Tree.Kind.METHOD_INVOCATION) && ((MethodInvocationTree) expr).symbol().isMethodSymbol() && ((JavaSymbol.MethodJavaSymbol) ((MethodInvocationTree) expr).symbol()).thrownTypes().stream().anyMatch(t-> !t.isSubtypeOf("java.lang.RuntimeException")); }
private boolean isOverridableMethod(Symbol symbol) { if (symbol.isMethodSymbol() && !symbol.isPrivate() && !symbol.isFinal() && !symbol.isStatic()) { return true; } return false; }
private void checkMethodInvocationArgument(Arguments arguments, Symbol symbol) { if (symbol.isMethodSymbol()) { List<Type> parametersTypes = ((Symbol.MethodSymbol) symbol).parameterTypes(); if (arguments.size() == parametersTypes.size()) { int i = 0; for (Type argType : parametersTypes) { checkExpression(argType, arguments.get(i)); i++; } } } }
private static boolean invalidMethodAndVariable(Symbol currentMember, Symbol knownMember) { if (!sameVisibilityNotPrivate(currentMember, knownMember)) { return false; } Symbol methodSymbol = currentMember.isMethodSymbol() ? currentMember : knownMember; Symbol variableSymbol = methodSymbol == currentMember ? knownMember : currentMember; return !methodReturningVariableWithSameName(methodSymbol, variableSymbol) && !isBuilderPattern(methodSymbol, variableSymbol); }
@Override public void visitMethodInvocation(MethodInvocationTree tree) { if (tree.symbol().isMethodSymbol()) { for (Type thrownType : ((Symbol.MethodSymbol) tree.symbol()).thrownTypes()) { exceptionsThrownByMethodInvocations.add(thrownType); } } super.visitMethodInvocation(tree); }
@Override public void visitNewClass(NewClassTree syntaxTree) { Symbol symbol = syntaxTree.constructorSymbol(); if (symbol.isMethodSymbol()) { int peekSize = syntaxTree.arguments().size(); List<SymbolicValue> argumentValues = Lists.reverse(programState.peekValues(peekSize)); checkNullArguments(syntaxTree, (JavaSymbol.MethodJavaSymbol) symbol, argumentValues); } }
@Override protected void onConstructorFound(NewClassTree newClassTree) { Symbol symbol = newClassTree.constructorSymbol(); if (symbol.isMethodSymbol()) { Symbol.MethodSymbol constructor = (Symbol.MethodSymbol) symbol; String signature = constructor.owner().name() + "(" + Joiner.on(',').join(constructor.parameterTypes()) + ")"; reportIssue(newClassTree.identifier(), "Remove this use of constructor \"" + signature + "\""); } }
private void checkMethodInvocation(MethodInvocationTree node) { Symbol symbol = node.symbol(); if (symbol.isMethodSymbol()) { List<Type> types = ((Symbol.MethodSymbol) symbol).thrownTypes(); if (!types.isEmpty()) { addIssueIfNotCatched(types, ExpressionUtils.methodName(node), "Add a \"try/catch\" block for \"" + symbol.name() + "\"."); } } }
private static boolean isExpectedSetter(MethodInvocationTree mit) { return mit.arguments().size() == 1 && mit.symbol().isMethodSymbol() && CLASSES.stream().anyMatch(mit.symbol().owner().type()::isSubtypeOf) && SETTER_NAMES.contains(getIdentifier(mit).name()) && isIgnoredBuilder(mit); }
private static boolean shouldVerify(AssignmentExpressionTree assignment) { if (assignment.expression().is(Tree.Kind.NEW_CLASS) && assignment.variable().is(Tree.Kind.IDENTIFIER)) { IdentifierTree identifier = (IdentifierTree) assignment.variable(); boolean isMethodVariable = identifier.symbol().isVariableSymbol() && identifier.symbol().owner().isMethodSymbol(); boolean isSupportedClass = CLASSES.stream().anyMatch(identifier.symbolType()::isSubtypeOf) || CLASSES.stream().anyMatch(assignment.expression().symbolType()::isSubtypeOf); return isMethodVariable && isSupportedClass; } return false; }
private boolean checkStaticMethod(Tree reportTree, Symbol.MethodSymbol methodSymbol, Type superClass) { for (Symbol methodWithSameName : superClass.symbol().lookupSymbols(methodSymbol.name())) { if (methodWithSameName.isMethodSymbol() && hideStaticMethod(methodSymbol, superClass, methodWithSameName)) { reportIssue(reportTree, "Rename this method or make it \"static\"."); return true; } } return false; }
private void addToUnsecuredCookies(VariableTree variableTree) { ExpressionTree initializer = variableTree.initializer(); Symbol variableTreeSymbol = variableTree.symbol(); // Ignore field variables if (initializer != null && variableTreeSymbol.isVariableSymbol() && variableTreeSymbol.owner().isMethodSymbol()) { boolean isInitializedWithConstructor = initializer.is(Tree.Kind.NEW_CLASS); boolean isMatchedType = isCookieClass(variableTreeSymbol.type()) || isCookieClass(initializer.symbolType()); if (isInitializedWithConstructor && isMatchedType && isSecureParamFalse((NewClassTree) initializer)) { unsecuredCookies.add((Symbol.VariableSymbol) variableTreeSymbol); } } }
private static boolean throwsNoSuchElementException(MethodInvocationTree methodInvocationTree) { Symbol symbol = methodInvocationTree.symbol(); if (!symbol.isMethodSymbol()) { return false; } if (throwsNoSuchElementException(((Symbol.MethodSymbol) symbol).thrownTypes())) { return true; } MethodJavaType methodJavaType = (MethodJavaType) ExpressionUtils.methodName(methodInvocationTree).symbolType(); return throwsNoSuchElementException(methodJavaType.thrownTypes()); }