private boolean isDeprecatedType(Type symbolType) { if (symbolType.isClass()) { for (String deprecatedType : REPLACEMENTS.keySet()) { if (symbolType.is(deprecatedType)) { return !exclusions.peek().contains(deprecatedType); } } } return false; } }
private static boolean classHasNoAutoValueOrImmutableAnnotation(ClassTree tree) { return tree.modifiers().annotations().stream() .map(AnnotationTree::annotationType) .map(TypeTree::symbolType) .noneMatch(type -> type.is("com.google.auto.value.AutoValue") || type.is("org.immutables.value.Value$Immutable")); } }
private void checkTimeTypeArgument(MethodInvocationTree mit, Type argType) { if (!(argType.isNumerical() || argType.is("java.lang.Long") || isSubtypeOfAny(argType, "java.util.Date", "java.util.Calendar", "java.time.temporal.TemporalAccessor"))) { reportIssue(mit, "Time argument is expected (long, Long, Calendar, Date and TemporalAccessor)."); } }
private static boolean isJavaSecurityMessageDigestSubClass(ClassTree tree) { Symbol.TypeSymbol classSymbol = tree.symbol(); // Corner case: A type is a subtype of itself return classSymbol != null && !classSymbol.type().is(MESSAGE_DIGEST_QUALIFIED_NAME) && classSymbol.type().isSubtypeOf(MESSAGE_DIGEST_QUALIFIED_NAME); } }
private void checkCast(Type type, MethodInvocationTree mit) { if (type.isArray() && !type.is("java.lang.Object[]")) { Type elementType = ((Type.ArrayType) type).elementType(); if (!((JavaType) elementType).isTagged(JavaType.TYPEVAR)) { reportIssue(mit, "Pass \"new " + elementType.name() + "[0]\" as argument to \"toArray\"."); } } } }
private boolean checkForbiddenTypes(Tree reportTree, Type symbolType) { for (String forbiddenType : FORBIDDEN_TYPES) { if (symbolType.is(forbiddenType)) { reportIssue(reportTree, "Remove this use of \"" + forbiddenType + "\""); return true; } } return false; }
private static boolean isAllowingNull(MethodTree methodTree) { for (AnnotationTree annotation : methodTree.modifiers().annotations()) { Type type = annotation.annotationType().symbolType(); if (type.is("javax.annotation.Nullable") || type.is("javax.annotation.CheckForNull")) { return true; } } return false; } }
private static boolean isComparable(ClassTree tree) { for (Type type : tree.symbol().interfaces()) { if (type.is("java.lang.Comparable")) { return true; } } return false; }
private static Tree toReportTree(Tree member) { Stream<AnnotationTree> stream = Stream.empty(); if (member.is(Kind.VARIABLE)) { stream = ((VariableTree) member).modifiers().annotations().stream(); } else if (member.is(Kind.METHOD)) { stream = ((MethodTree) member).modifiers().annotations().stream(); } return stream .filter(a -> a.annotationType().symbolType().is("org.springframework.beans.factory.annotation.Autowired")) .findFirst() .orElseThrow(() -> new IllegalStateException("Mapping a tree to something unexpected")); }
private void checkExtendsObject(ClassTree classTree) { TypeTree superClassTree = classTree.superClass(); if (superClassTree != null && superClassTree.symbolType().is("java.lang.Object")) { reportIssue(superClassTree, "\"Object\" should not be explicitly extended."); } }
private void checkConfigurationFactoryExtension(ClassTree tree) { TypeTree superClass = tree.superClass(); if (superClass != null && superClass.symbolType().is("org.apache.logging.log4j.core.config.ConfigurationFactory")) { reportIssue(superClass, MESSAGE); } }
private SymbolicValue createIdentifierSymbolicValue(IdentifierTree identifier) { final Type type = identifier.symbol().type(); if (type != null && type.is("java.lang.Boolean")) { if ("TRUE".equals(identifier.name())) { return SymbolicValue.TRUE_LITERAL; } else if ("FALSE".equals(identifier.name())) { return SymbolicValue.FALSE_LITERAL; } } return createDefaultSymbolicValue(); }
@Override public void visitNode(Tree tree) { NewClassTree newClassTree = (NewClassTree) tree; if (newClassTree.symbolType().is("javax.crypto.NullCipher")) { reportIssue(newClassTree.identifier(), "Remove this use of the \"NullCipher\" class."); } }
private void checkForUselessUnboxing(Type targetType, Tree reportTree, ExpressionTree arg0) { Type argType = arg0.symbolType(); if (argType.is(targetType.fullyQualifiedName())) { reportIssue(reportTree, String.format("Remove the boxing to \"%s\"; The argument is already of the same type.", argType.name())); } }
private void handleClassTree(ClassTree tree) { tree.superInterfaces().stream() .filter(superInterface -> INTERFACES.stream().anyMatch(superInterface.symbolType()::is)) .forEach(this::reportIssue); TypeTree superClass = tree.superClass(); if (superClass != null && superClass.symbolType().is(GLOBAL_METHOD_SECURITY_CONFIGURATION)) { reportIssue(superClass); } checkAnnotations(tree.modifiers(), JSR_250_ANNOTATIONS); }
@Override public boolean apply(MethodTree methodTree) { return methodTree.simpleName().name().startsWith(getStartName()) && methodTree.parameters().isEmpty() && !methodTree.returnType().symbolType().is("void"); } };
private void visitInstanceOf(InstanceOfTree instanceOfTree) { ExpressionTree expression = instanceOfTree.expression(); if (expression.is(Tree.Kind.IDENTIFIER) && instanceOfTree.type().symbolType().is("java.io.Serializable")) { testedSymbols.add(((IdentifierTree) expression).symbol()); } }
private static ProgramState handleOpenOptionAppend(ProgramState programState, IdentifierTree identifier) { if (identifier.symbolType().is("java.nio.file.StandardOpenOption") && "APPEND".equals(identifier.name())) { return programState.addConstraint(programState.peekValue(), new FileOutputStreamAppendConstraint(identifier)); } return programState; }
@Override public void visitClass(ClassTree tree) { TypeTree superClass = tree.superClass(); if (superClass != null && superClass.symbolType().is(JAVA_LANG_THREADGROUP)) { context.reportIssue(this, superClass, MESSAGE); } super.visitClass(tree); }
private static boolean isGetPropertyWithDefaultValue(MethodInvocationTree mit) { Symbol symbol = mit.symbol(); if (symbol.isMethodSymbol() && symbol.owner().type().is("java.util.Properties")) { return "getProperty".equals(symbol.name()) && mit.arguments().size() == 2; } return false; } }