private static Optional<MethodSymbol> lookupFunctionalMethod(ClassTree interfaceTree) { return interfaceTree.symbol().memberSymbols().stream() .filter(Symbol::isMethodSymbol) .map(MethodSymbol.class::cast) .filter(MethodSymbol::isAbstract) .filter(StandardFunctionalInterfaceCheck::isNotObjectMethod) .findFirst(); }
private static boolean hasUniqueConstructor(ClassTree clazzTree) { return clazzTree.symbol().memberSymbols().stream() .filter(Symbol::isMethodSymbol) .map(s -> (Symbol.MethodSymbol) s) .filter(m -> m.name().equals("<init>")) .filter(m -> m.declaration() != null) .count() == 1; }
private static boolean isComparable(ClassTree tree) { for (Type type : tree.symbol().interfaces()) { if (type.is("java.lang.Comparable")) { return true; } } return false; }
private static boolean usesAnnotation(ClassTree classTree, List<String> annotations) { SymbolMetadata metadata = classTree.symbol().metadata(); for (String annotation : annotations) { if (metadata.isAnnotatedWith(annotation)) { return true; } } return false; }
@Override public void visitNode(Tree tree) { TypeSymbol classSymbol = ((ClassTree) tree).symbol(); Set<Symbol> fieldsReadOnAnotherInstance = FieldsReadOnAnotherInstanceVisitor.getFrom(tree); classSymbol.memberSymbols().stream() .filter(PrivateFieldUsedLocallyCheck::isPrivateField) .filter(s -> !(s.isFinal() && s.isStatic())) .filter(s -> !hasAnnotation(s)) .filter(s -> !s.usages().isEmpty()) .filter(s -> !fieldsReadOnAnotherInstance.contains(s)) .forEach(s -> checkPrivateField(s, classSymbol)); }
private static boolean isDefaultConstructorForJpa(MethodTree methodTree) { if (!methodTree.block().body().isEmpty()) { // Constructor does something. return false; } SymbolMetadata symbolMetadata = ((ClassTree) methodTree.parent()).symbol().metadata(); return Stream.of(JPA_ANNOTATIONS).anyMatch(symbolMetadata::isAnnotatedWith); }
@Override public void visitNode(Tree tree) { ClassTree classTree = (ClassTree) tree; Symbol.TypeSymbol classSymbol = classTree.symbol(); if (isInnerClass(classSymbol)) { methodInvocationVisitor.setClassSymbol(classSymbol); classTree.accept(methodInvocationVisitor); } }
private static boolean useThisInstance(ClassTree body) { UsesThisInstanceVisitor visitor = new UsesThisInstanceVisitor(body.symbol().type()); body.accept(visitor); return visitor.usesThisInstance; }
private void checkSuperType(ClassTree tree, @Nullable Type superType) { if (superType != null && superType.symbol().name().equals(tree.symbol().name())) { String classOrInterface = tree.is(Tree.Kind.CLASS) ? "class" : "interface"; reportIssue(tree.simpleName(), "Rename this " + classOrInterface + "."); } }
private boolean invocationOfMethodFromOtherClass(MethodInvocationTree mit) { Symbol methodClass = mit.symbol().owner(); Tree enclosingType = mit; while (!enclosingType.is(Tree.Kind.CLASS, Tree.Kind.ENUM, Tree.Kind.INTERFACE)) { enclosingType = enclosingType.parent(); } return ((ClassTree) enclosingType).symbol() != methodClass; } }
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); } }
@Override public void visitNode(Tree tree) { ClassTree classTree = (ClassTree) tree; Symbol.TypeSymbol classSymbol = classTree.symbol(); if (classSymbol != null && isInnerClass(classSymbol) && !extendsOuterClass(classSymbol)) { classTree.accept(new MethodInvocationVisitor(classSymbol)); } }
@Override public void visitNode(Tree tree) { if(!hasSemantic()) { return; } ClassTree classTree = (ClassTree) tree; Symbol.TypeSymbol classSymbol = classTree.symbol(); if(classSymbol.isPrivate() && classSymbol.usages().isEmpty()) { reportIssue(classTree.simpleName(), "Remove this unused private \""+ classSymbol.name()+"\" class."); } } }
@Override public void visitClass(ClassTree tree) { for (Tree member : tree.members()) { if (!tree.symbol().type().isSubtypeOf(JAVA_UTIL_COLLECTION) || !member.is(Tree.Kind.METHOD)) { scan(member); } } }
@Override public void visitNode(Tree tree) { ClassTree clazzTree = (ClassTree) tree; SymbolMetadata clazzMeta = clazzTree.symbol().metadata(); if (isSpringComponent(clazzMeta) && clazzMeta.isAnnotatedWith(SCOPE_ANNOTATION_FQN) && !isScopeSingleton(clazzMeta)) { checkScopeAnnotation(clazzTree); } }
private static boolean isSAM(ClassTree classBody) { if (hasOnlyOneMethod(classBody.members())) { // When overriding only one method of a functional interface, it can only be the single abstract method // and not one of the default methods. No need to check that the method signature matches. JavaSymbol.TypeJavaSymbol symbol = (JavaSymbol.TypeJavaSymbol) classBody.symbol(); // should be anonymous class of interface and not abstract class return symbol.getInterfaces().size() == 1 && symbol.getSuperclass().is(JAVA_LANG_OBJECT) && hasSingleAbstractMethodInHierarchy(symbol.superTypes()); } return false; }
@Override public void visitNode(Tree tree) { ClassTree node = (ClassTree) tree; Symbol.TypeSymbol symbol = node.symbol(); if (isServletOrEjb(symbol)) { for (Tree member : node.members()) { if (member.is(Tree.Kind.METHOD) && ((MethodTreeImpl) member).isMainMethod()) { reportIssue(((MethodTree) member).simpleName(), "Remove this unwanted \"main\" method."); } } } }
@Override public void visitClass(ClassTree tree) { IdentifierTree simpleName = tree.simpleName(); if (simpleName != null) { createSymbol(simpleName, tree.symbol().usages()); } for (TypeParameterTree typeParameterTree : tree.typeParameters()) { createSymbol(typeParameterTree.identifier(), typeParameterTree); } super.visitClass(tree); }
@Override public void visitClass(ClassTree tree) { //skip superclass and interfaces : visited in second pass. scan(tree.modifiers()); completeMetadata((JavaSymbol) tree.symbol(), tree.modifiers().annotations()); scan(tree.typeParameters()); scan(tree.members()); }
private static boolean isSerializable(Tree tree) { if (tree.is(Tree.Kind.ENUM, Tree.Kind.PRIMITIVE_TYPE)) { return true; } else if (tree.is(Tree.Kind.CLASS)) { Symbol.TypeSymbol symbol = ((ClassTree) tree).symbol(); return implementsSerializable(symbol.type()); } else if (tree.is(Tree.Kind.EXTENDS_WILDCARD, Tree.Kind.SUPER_WILDCARD, Tree.Kind.UNBOUNDED_WILDCARD)) { TypeTree bound = ((WildcardTree) tree).bound(); return bound != null && implementsSerializable(bound.symbolType()); } return implementsSerializable(((TypeTree) tree).symbolType()); }