private static boolean isPrivateStaticFinal(ModifiersTree tree) { return ModifiersUtils.hasModifier(tree, Modifier.PRIVATE) && ModifiersUtils.hasModifier(tree, Modifier.STATIC) && ModifiersUtils.hasModifier(tree, Modifier.FINAL); }
private static boolean hasNoVisibilityModifier(VariableTree variableTree) { ModifiersTree modifiers = variableTree.modifiers(); return !(ModifiersUtils.hasModifier(modifiers, Modifier.PUBLIC) || ModifiersUtils.hasModifier(modifiers, Modifier.PRIVATE) || ModifiersUtils.hasModifier(modifiers, Modifier.PROTECTED)); }
private void checkIfNativeMethod(MethodTree method) { if (ModifiersUtils.hasModifier(method.modifiers(), Modifier.NATIVE)) { hasNativeMethod = true; } }
private void checkIfNativeMethod(MethodTree method) { if (ModifiersUtils.hasModifier(method.modifiers(), Modifier.NATIVE)) { hasNativeMethod = true; } }
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 isDesignedForExtension(MethodTree methodTree) { ModifiersTree modifiers = methodTree.modifiers(); if (ModifiersUtils.hasModifier(modifiers, Modifier.PRIVATE)) { return false; } return ModifiersUtils.hasModifier(modifiers, Modifier.DEFAULT) || emptyBody(methodTree) || onlyReturnLiteralsOrThrowException(methodTree); }
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 visitMethod(MethodTree tree) { if(ModifiersUtils.hasModifier(tree.modifiers(), Modifier.DEFAULT)) { //Ignore default methods to avoid catch-22 with S1214 return; } super.visitMethod(tree); }
private static boolean isConstant(VariableTree variableTree) { return ModifiersUtils.hasModifier(variableTree.modifiers(), Modifier.STATIC) && ModifiersUtils.hasModifier(variableTree.modifiers(), Modifier.FINAL) && variableTree.initializer().is(BOOLEAN_LITERAL, STRING_LITERAL, LONG_LITERAL, CHAR_LITERAL, INT_LITERAL, FLOAT_LITERAL, DOUBLE_LITERAL, NULL_LITERAL); }
@Override public void visitNode(Tree tree) { if (!hasSemantic()) { return; } ClassTree classTree = (ClassTree) tree; if (ModifiersUtils.hasModifier(classTree.modifiers(), Modifier.FINAL)) { classTree.members().forEach(this::checkMember); } }
@Override public void visitVariable(VariableTree tree) { ExpressionTree initializer = tree.initializer(); if (initializer != null && initializer.is(Tree.Kind.STRING_LITERAL) && ModifiersUtils.hasModifier(tree.modifiers(), Modifier.STATIC) && ModifiersUtils.hasModifier(tree.modifiers(), Modifier.FINAL)) { constants.putIfAbsent(((LiteralTree) initializer).value(), tree); return; } super.visitVariable(tree); }
@Override public void visitMethod(MethodTree methodTree) { if (ModifiersUtils.hasModifier(methodTree.modifiers(), Modifier.ABSTRACT)) { return; } containsAssertThatWithoutAssertAll.push(false); super.visitMethod(methodTree); if (Boolean.TRUE.equals(containsAssertThatWithoutAssertAll.pop())) { context.reportIssue(this, methodTree.block().closeBraceToken(), "Add a call to 'assertAll' after all 'assertThat'."); } }
@Override public void visitMethod(MethodTree methodTree) { if (ModifiersUtils.hasModifier(methodTree.modifiers(), Modifier.ABSTRACT)) { return; } containsAssertThatWithoutAssertAll.push(false); super.visitMethod(methodTree); if (Boolean.TRUE.equals(containsAssertThatWithoutAssertAll.pop())) { context.reportIssue(this, methodTree.block().closeBraceToken(), "Add a call to 'assertAll' after all 'assertThat'."); } }
@Override public void visitNode(Tree tree) { if (tree.is(Tree.Kind.METHOD_INVOCATION)) { super.visitNode(tree); } else if (tree.is(Tree.Kind.METHOD)) { withinSynchronizedBlock.push(ModifiersUtils.hasModifier(((MethodTree) tree).modifiers(), Modifier.SYNCHRONIZED)); } else if (tree.is(Tree.Kind.SYNCHRONIZED_STATEMENT)) { withinSynchronizedBlock.push(true); } }
private static boolean referencePrivateProperty(String variableName, ClassTree classTree) { for (Tree member : classTree.members()) { if (member.is(Tree.Kind.VARIABLE)) { VariableTree variableTree = (VariableTree) member; if (ModifiersUtils.hasModifier(variableTree.modifiers(), Modifier.PRIVATE) && variableTree.simpleName().name().equals(variableName)) { return true; } } } return false; }
@Override public void visitNode(Tree tree) { ClassTree classTree = (ClassTree) tree; if (!ModifiersUtils.hasModifier(classTree.modifiers(), Modifier.ABSTRACT)) { List<Tree> members = classTree.members(); checkMethods(members); checkSingleNoArgPublicConstructor(members); } }
@Override public void visitNode(Tree tree) { if (!hasSemantic()) { return; } ClassTree classTree = (ClassTree) tree; if (hasOnlyPrivateConstructors(classTree) && !isExtended(classTree) && !ModifiersUtils.hasModifier(classTree.modifiers(), Modifier.FINAL)) { reportIssue(classTree.simpleName(), "Make this class \"final\" or add a public constructor."); } }
@Override public void visitNode(Tree tree) { VariableTree variableTree = (VariableTree) tree; Type type = variableTree.type().symbolType(); if (ModifiersUtils.hasModifier(variableTree.modifiers(), Modifier.STATIC) && isForbiddenType(variableTree)) { if (type.isSubtypeOf(JAVA_TEXT_SIMPLE_DATE_FORMAT) && onlySynchronizedUsages((Symbol.VariableSymbol) variableTree.symbol())) { return; } IdentifierTree identifierTree = variableTree.simpleName(); reportIssue(identifierTree, String.format("Make \"%s\" an instance variable.", identifierTree.name())); } }
private void checkVariable(VariableTree member) { if (ModifiersUtils.hasModifier(member.modifiers(), Modifier.FINAL)) { return; } ExpressionTree initializer = member.initializer(); if (initializer != null) { initializer = ExpressionUtils.skipParentheses(initializer); if (isDefault(initializer, member.type().symbolType().isPrimitive())) { reportIssue(initializer, "Remove this initialization to \"" + ((LiteralTree) initializer).value() + "\", the compiler will do that for you."); } } }
private static boolean isTransientSerializableOrInjected(VariableTree member) { if (ModifiersUtils.hasModifier(member.modifiers(), Modifier.TRANSIENT) || (isSerializable(member.type()) && !isSubtypeOfCollectionApi(member.type().symbolType()))) { return true; } SymbolMetadata metadata = member.symbol().metadata(); return metadata.isAnnotatedWith("javax.inject.Inject") || metadata.isAnnotatedWith("javax.ejb.EJB"); }