private void checkClassFields(ClassTree classTree) { classTree.members().stream() .filter(member -> member.is(Tree.Kind.VARIABLE)) .map(VariableTree.class::cast) .forEach(this::checkIfUnused); }
private static Optional<MethodTree> findMethod(ClassTree classTree, MethodMatcher methodMatcher) { return classTree.members() .stream() .filter(m -> m.is(Tree.Kind.METHOD)) .map(MethodTree.class::cast) .filter(methodMatcher::matches) .findFirst(); } }
@Override public void visitClass(ClassTree tree) { // skip modifiers, parameters, simple name and superclass/interface scan(tree.members()); }
private static Boolean hasSynchronizedMethod(ClassTree tree) { return tree.members().stream() .filter(member -> member.is(Tree.Kind.METHOD)) .map(MethodTree.class::cast) .map(MethodTree::modifiers) .anyMatch(modifiers -> ModifiersUtils.hasModifier(modifiers, Modifier.SYNCHRONIZED)); }
private static boolean containsMainMethod(ClassTree classTree) { return classTree.members().stream() .filter(member -> member.is(Tree.Kind.METHOD)) .anyMatch(method -> ((MethodTreeImpl) method).isMainMethod()); }
private static boolean usedForEmptyEnum(Tree tree) { Tree parent = tree.parent(); if (parent.is(Tree.Kind.ENUM)) { return ((ClassTree) parent).members().indexOf(tree) == 0; } return false; }
private static boolean hasPrivateMethod(ClassTree tree) { return tree.members().stream() .filter(member -> member.is(Tree.Kind.METHOD)) .anyMatch(member -> ModifiersUtils.hasModifier(((MethodTree) member).modifiers(), Modifier.PRIVATE)); }
@Override public void visitNode(Tree tree) { ClassTree classBody = ((NewClassTree) tree).classBody(); if (classBody != null) { List<Tree> members = classBody.members(); if (members.size() == 1 && members.get(0).is(Tree.Kind.INITIALIZER)) { reportIssue(classBody, "Use another way to initialize this instance."); } } }
@Override public void visitNode(Tree tree) { List<Tree> members = ((ClassTree) tree).members(); for (Tree member : members) { if (member.is(Kind.VARIABLE)) { checkVariable((VariableTree) member); } } }
@Override public void visitClass(ClassTree tree) { super.visitClass(tree); for (Tree member : tree.members()) { if (member.is(Tree.Kind.VARIABLE)) { variableTypes.remove(((VariableTree) member).type()); } } }
private static boolean hasOnlyStaticMembers(ClassTree classTree) { List<Tree> members = classTree.members(); if (noStaticMember(members)) { return false; } return members.stream().allMatch(member -> isConstructor(member) || isStatic(member) || member.is(Tree.Kind.EMPTY_STATEMENT)); }
@Override public void visitNode(Tree tree) { if (isJunit3Class((ClassTree) tree)) { for (Tree member : ((ClassTree) tree).members()) { if (member.is(Tree.Kind.METHOD)) { visitMethod((MethodTree) member); } } } }
@Override public void visitNode(Tree tree) { ((ClassTree) tree).members() .stream() .filter(m -> m.is(Tree.Kind.VARIABLE)) .map(m -> ((VariableTree) m)) .filter(v -> ModifiersUtils.hasModifier(v.modifiers(), Modifier.VOLATILE)) .filter(v -> !v.type().symbolType().isPrimitive()) .forEach(v -> reportIssue(ModifiersUtils.getModifier(v.modifiers(), Modifier.VOLATILE), v.type(), getMessage(v))); }
@Override public void visitClass(ClassTree tree) { for (Tree member : tree.members()) { if (member.is(Tree.Kind.VARIABLE)) { // skip check of field scan(((VariableTree) member).initializer()); } else { scan(member); } } }
@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); } } }
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) { nestedClassesLevel++; for (Tree member : ((ClassTree) tree).members()) { if (member.is(Tree.Kind.VARIABLE)) { VariableTree variableTree = (VariableTree) member; if (staticNonFinal(variableTree) && hasConstantInitializer(variableTree) && !isObjectInInnerClass(variableTree)) { reportIssue(variableTree.simpleName(), "Make this final field static too."); } } } }
@Override public void visitNode(Tree tree) { if (tree.is(Kind.INTERFACE, Kind.CLASS, Kind.ENUM, Kind.ANNOTATION_TYPE)) { // Field class declaration checkVariables(((ClassTree) tree).members()); } else if (tree.is(Kind.BLOCK, Kind.STATIC_INITIALIZER)) { // Local variable declaration (in method, static initialization, ...) checkVariables(((BlockTree) tree).body()); } else if (tree.is(Kind.CASE_GROUP)) { checkVariables(((CaseGroupTree) tree).body()); } }
@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()); }
@Override public void visitClass(ClassTree tree) { scan(tree.modifiers()); scan(tree.simpleName()); scan(tree.typeParameters()); scan(tree.superClass()); scan(tree.superInterfaces()); scan(tree.members()); }