@Override public void visitVariable(VariableTree tree) { scan(tree.modifiers()); scan(tree.type()); scan(tree.simpleName()); scan(tree.initializer()); }
@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 complete(JavaSymbol.VariableJavaSymbol symbol) { VariableTree variableTree = symbol.declaration; Resolve.Env env = semanticModel.getEnv(symbol); if (variableTree.is(Tree.Kind.ENUM_CONSTANT)) { symbol.type = env.enclosingClass.type; } else { symbol.type = resolveType(env, variableTree.type()); } }
private void checkCookieBuilder(VariableTree declaration) { if (declaration.initializer() != null && declaration.initializer().is(Tree.Kind.METHOD_INVOCATION)) { MethodInvocationTree mit = (MethodInvocationTree) declaration.initializer(); addToIgnoredVariables((VariableSymbol) declaration.symbol(), mit); } }
private void handleVariable(Set<Symbol> out, VariableTree localVar) { Symbol symbol = localVar.symbol(); ExpressionTree initializer = localVar.initializer(); if (initializer != null && !isUsualDefaultValue(initializer) && !out.contains(symbol)) { createIssue(localVar.equalToken(), initializer, symbol); } out.remove(symbol); }
@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 static boolean shouldVerify(VariableTree variableDeclaration) { ExpressionTree initializer = variableDeclaration.initializer(); if (initializer != null && initializer.is(Tree.Kind.NEW_CLASS)) { boolean isSupportedClass = CLASSES.stream().anyMatch(variableDeclaration.type().symbolType()::isSubtypeOf) || CLASSES.stream().anyMatch(initializer.symbolType()::isSubtypeOf); return variableDeclaration.symbol().owner().isMethodSymbol() && isSupportedClass; } return false; }
@Override public void visitVariable(VariableTree tree) { scan(tree.modifiers()); scan(tree.type()); scan(tree.initializer()); }
public void checkVariableTypeAndInitializer(VariableTree variableTree) { ExpressionTree initializer = variableTree.initializer(); if ((variableTree.symbol().owner().isMethodSymbol() && !variableTree.parent().is(Tree.Kind.LAMBDA_EXPRESSION)) || (initializer != null && (initializer.is(Tree.Kind.LAMBDA_EXPRESSION) || isAnonymousClass(initializer)))) { matchFunctionalInterface((variableTree.symbol().type())).ifPresent(reportString -> { TypeTree variableType = variableTree.type(); reportIssue(variableType, reportMessage(new InterfaceTreeAndStringPairReport(reportString, variableType))); }); } }
@Override public void visitVariable(VariableTree tree) { declareVariable(computeFlags(tree.modifiers(), tree), tree.simpleName(), (VariableTreeImpl) tree); super.visitVariable(tree); }
@Override public void visitVariable(VariableTree tree) { super.visitVariable(tree); if (isPublic(tree.modifiers())) { checkIfAllowed(tree.type(), "The type of the \"" + tree.simpleName() + "\" object "); } }
private void checkVariable(VariableTree tree) { if (isFileNameVariable(tree.simpleName())) { checkExpression(tree.initializer()); } }
private void checkVariableUsages() { for (VariableTree variableTree : variables) { Symbol symbol = variableTree.symbol(); if (symbol.usages().size() == assignments.get(symbol).size()) { IdentifierTree simpleName = variableTree.simpleName(); reportIssue(simpleName, "Remove this unused \"" + simpleName + "\" local variable."); } } }
@Override public void visitVariable(VariableTree tree) { variableTypes.add(tree.type()); super.visitVariable(tree); }
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"); }
private void reportIssuesOnVariable() { issuableVariables.removeAll(excludedVariables); for (VariableTree variable : issuableVariables) { reportIssue(variable.simpleName(), "Remove this misleading mutable servlet instance field or make it \"static\" and/or \"final\""); } issuableVariables.clear(); excludedVariables.clear(); }
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 visitCatch(CatchTree tree) { if (!isExcludedType(tree.parameter().type()) && !excludedCatchTrees.contains(tree)) { Symbol exception = tree.parameter().symbol(); validUsagesStack.addFirst(Lists.newArrayList(exception.usages())); super.visitCatch(tree); Collection<IdentifierTree> usages = validUsagesStack.pop(); if (usages.isEmpty()) { context.reportIssue(this, tree.parameter(), "Either log or rethrow this exception."); } } }
@Override public void visitMethod(MethodTree tree) { ArrayList<Symbol> parameters = new ArrayList<>(); for (VariableTree variableTree : tree.parameters()) { parameters.add(variableTree.symbol()); } parametersStack.push(parameters); super.visitMethod(tree); parametersStack.pop(); }