private boolean isNotStatic(VariableTree field) { for (Modifier modifier : field.modifiers().modifiers()) { if (modifier == Modifier.STATIC) { return false; } } return true; }
private static ModifierKeywordTree isTransient(Tree tree) { if (tree.is(Tree.Kind.VARIABLE)) { VariableTree variable = (VariableTree) tree; return ModifiersUtils.getModifier(variable.modifiers(), Modifier.TRANSIENT); } return null; }
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) { ((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 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); }
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")); }
@Override public void visitVariable(VariableTree tree) { handleSuppressWarning(tree.modifiers().annotations(), tree); super.visitVariable(tree); }
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 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 visitVariable(VariableTree tree) { declareVariable(computeFlags(tree.modifiers(), tree), tree.simpleName(), (VariableTreeImpl) tree); super.visitVariable(tree); }
@Override public void visitNode(Tree tree) { ClassTree classTree = (ClassTree) tree; for (Tree member : classTree.members()) { if (member.is(Tree.Kind.VARIABLE)) { VariableTree field = (VariableTree) member; if (isFieldModifierConcernedByRule(field.modifiers()) && !pattern.matcher(field.simpleName().name()).matches()) { reportIssue(field.simpleName(), String.format("Rename this field \"%s\" to match the regular expression '%s'.", field.simpleName().name(), getFormat())); } } } }
@Override public void visitVariable(VariableTree variable) { if (variable.type().symbolType().is(OPTIONAL)) { checkNullableAnnotation(variable.modifiers(), "\"Optional\" variables should not be \"@Nullable\"."); } super.visitVariable(variable); }
private static ModifiersTree getModifierTrees(Tree tree) { ModifiersTree modifiersTree = null; if (tree.is(CLASS_KINDS)) { modifiersTree = ((ClassTree) tree).modifiers(); } else if (tree.is(METHOD_KINDS)) { modifiersTree = ((MethodTree) tree).modifiers(); } else if (tree.is(Kind.VARIABLE)) { modifiersTree = ((VariableTree) tree).modifiers(); } return modifiersTree; }
@Override public void visitVariable(VariableTree tree) { super.visitVariable(tree); if (isPublic(tree.modifiers())) { checkIfAllowed(tree.type(), "The type of the \"" + tree.simpleName() + "\" object "); } }
@Override public void visitVariable(VariableTree tree) { ModifiersTree modifiers = tree.modifiers(); List<AnnotationTree> annotations = modifiers.annotations(); if (isClass() && isPublic(modifiers) && !(isFinal(modifiers) || !annotations.isEmpty())) { context.reportIssue(this, tree.simpleName(), "Make " + tree.simpleName() + " a static final constant or non-public and provide accessors if needed."); } super.visitVariable(tree); }
private void checkParameter(VariableTree parameter, Symbol overrideeParamSymbol) { Tree reportTree = parameter; if (nonNullVsNull(parameter.symbol(), overrideeParamSymbol)) { for (AnnotationTree annotationTree : parameter.modifiers().annotations()) { if(annotationTree.symbolType().is(JAVAX_ANNOTATION_NONNULL)) { reportTree = annotationTree; } } reportIssue(reportTree, "Remove this \"Nonnull\" annotation to honor the overridden method's contract."); } }
@Override public void visitVariable(VariableTree tree) { scan(tree.modifiers()); scan(tree.type()); scan(tree.simpleName()); scan(tree.initializer()); }
@Override public void visitVariable(VariableTree tree) { Symbol symbol = tree.symbol(); if (symbol != null && !symbol.isStatic()) { scan(tree.modifiers()); scan(tree.type()); // skip the simple name scan(tree.initializer()); } }
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"); }