@Override public void visitVariable(VariableTree tree) { variableTypes.add(tree.type()); super.visitVariable(tree); }
private static Optional<Type> findInterruptingType(VariableTree parameter) { if (parameter.type().is(Tree.Kind.UNION_TYPE)) { return ((UnionTypeTree) parameter.type()).typeAlternatives().stream() .map(TypeTree::symbolType) .filter(INTERRUPTING_TYPE_PREDICATE) .findFirst(); } return Optional.of(parameter) .map(VariableTree::symbol) .map(Symbol::type) .filter(INTERRUPTING_TYPE_PREDICATE); }
private static List<Type> getCatchedExceptions(List<CatchTree> catches) { List<Type> result = new ArrayList<>(); for (CatchTree element : catches) { result.add(element.parameter().type().symbolType()); } return result; }
@Override public void visitMethod(MethodTree tree) { super.visitMethod(tree); for (VariableTree variableTree : tree.parameters()) { variableTypes.remove(variableTree.type()); } }
private void checkTypeToReplace(VariableTree variableTree) { String fullyQualifiedTypeName = variableTree.type().symbolType().fullyQualifiedName(); if (GUAVA_TO_JAVA_UTIL_TYPES.containsKey(fullyQualifiedTypeName)) { reportIssue(variableTree.type(), replacementMessage(GUAVA_TO_JAVA_UTIL_TYPES.get(fullyQualifiedTypeName))); } }
private static boolean isReadObject(MethodTree methodTree) { return "readObject".equals(methodTree.simpleName().name()) && methodTree.parameters().size() == 1 && methodTree.parameters().get(0).type().symbolType().is("java.io.ObjectInputStream"); }
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()); } }
@Override public void visitVariable(VariableTree tree) { Type varType = tree.type().symbolType(); checkExpression(varType, tree.initializer()); super.visitVariable(tree); }
@Override public void visitVariable(VariableTree tree) { TypeTree type = tree.type(); if (type.symbolType().is(JAVA_LANG_THREADGROUP)) { context.reportIssue(this, type, MESSAGE); } 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"); }
@Override public void visitVariable(VariableTree variable) { if (variable.type().symbolType().is(OPTIONAL)) { checkNullableAnnotation(variable.modifiers(), "\"Optional\" variables should not be \"@Nullable\"."); } super.visitVariable(variable); }
@Override public void visitNode(Tree tree) { TryStatementTree tryStatement = (TryStatementTree) tree; for (CatchTree catchTree : tryStatement.catches()) { TypeTree catchType = catchTree.parameter().type(); if (catchesException(catchType, tryStatement.block())) { reportIssue(catchType, "Catch a list of specific exception subtypes instead."); } } }
@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) { Symbol symbol = tree.symbol(); if (symbol != null && !symbol.isStatic()) { scan(tree.modifiers()); scan(tree.type()); // skip the simple name scan(tree.initializer()); } }
@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 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."); } } }
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 visitForEachStatement(ForEachStatement tree) { scan(tree.variable()); scan(tree.expression()); TypeTree typeTree = tree.variable().type(); if (typeTree.is(Tree.Kind.VAR_TYPE)) { JavaType iteratedObjectType = getIteratedObjectType((JavaType) tree.expression().symbolType()); setInferedType(upwardProjection(iteratedObjectType), (DeferredType) typeTree.symbolType()); } // scan the body only after handling type of variable scan(tree.statement()); }