@Override public void visitMemberSelectExpression(MemberSelectExpressionTree tree) { scan(tree.expression()); // ignore identifier, because if it is this, it is a qualified this. }
private void buildMemberSelect(MemberSelectExpressionTree mse) { currentBlock.elements.add(mse); // int.class or String[].class are memberSelectExpression which expression part is not an expression. if (!"class".equals(mse.identifier().name())) { build(mse.expression()); } }
@Override public void visitMemberSelectExpression(MemberSelectExpressionTree tree) { super.visitMemberSelectExpression(tree); String identifier = tree.identifier().name(); boolean isCollectionsCall = tree.expression().is(Kind.IDENTIFIER) && "Collections".equals(((IdentifierTree) tree.expression()).name()); boolean callEmptyConstant = identifier.startsWith("EMPTY_"); if (isCollectionsCall && callEmptyConstant) { context.reportIssue(this, tree, "Replace \"Collections." + identifier + "\" by \"Collections." + IDENTIFIER_REPLACEMENT.get(identifier) + "\"."); } }
private static boolean isMethodInvocationOnParameter(Symbol parameter, MethodInvocationTree mit) { if (mit.methodSelect().is(Tree.Kind.MEMBER_SELECT)) { MemberSelectExpressionTree mset = (MemberSelectExpressionTree) mit.methodSelect(); if (mset.expression().is(Tree.Kind.IDENTIFIER)) { Symbol symbol = ((IdentifierTree) mset.expression()).symbol(); return symbol == parameter; } } return false; }
private static Stream<MethodInvocationTree> getMethodChain(MethodInvocationTree mit) { if (mit.methodSelect().is(Tree.Kind.MEMBER_SELECT)) { ExpressionTree expressionTree = ((MemberSelectExpressionTree) mit.methodSelect()).expression(); if (expressionTree.is(Tree.Kind.METHOD_INVOCATION)) { return Stream.concat(Stream.of(mit), getMethodChain((MethodInvocationTree) expressionTree)); } } return Stream.of(mit); }
private void checkMethodInvocation(MethodInvocationTree methodInvocationTree) { if (unboxingInvocationMatcher.matches(methodInvocationTree)) { MemberSelectExpressionTree methodSelect = (MemberSelectExpressionTree) methodInvocationTree.methodSelect(); checkInstantiation(methodSelect.expression()); } }
private static String fullQualifiedName(Tree tree) { if (tree.is(Tree.Kind.IDENTIFIER)) { return ((IdentifierTree) tree).name(); } else if (tree.is(Tree.Kind.MEMBER_SELECT)) { MemberSelectExpressionTree m = (MemberSelectExpressionTree) tree; return fullQualifiedName(m.expression()) + "." + m.identifier().name(); } throw new UnsupportedOperationException(String.format("Kind/Class '%s' not supported", tree.getClass())); } }
@Override public void visitMethodInvocation(MethodInvocationTree tree) { if (tree.methodSelect().is(Tree.Kind.MEMBER_SELECT)) { MemberSelectExpressionTree mse = (MemberSelectExpressionTree) tree.methodSelect(); if (mse.expression().is(Tree.Kind.IDENTIFIER) && "super".equals(((IdentifierTree) mse.expression()).name()) && mse.identifier().name().equals(methodName)) { superCallOnOverride |= !((IdentifierTree) mse.expression()).symbol().type().is(JUNIT_FRAMEWORK_TEST_CASE); } } super.visitMethodInvocation(tree); }
@Override public void visitMemberSelectExpression(MemberSelectExpressionTree tree) { scan(tree.annotations()); scan(tree.identifier().annotations()); pendingReferences.add(ExpressionsHelper.concatenate(tree)); //Don't visit identifiers of a member select expression. if (!tree.expression().is(Tree.Kind.IDENTIFIER)) { scan(tree.expression()); } }
private static boolean isSecurityAuthenticationConstant(ExpressionTree tree) { if (tree.is(Kind.MEMBER_SELECT)) { MemberSelectExpressionTree constantExpression = (MemberSelectExpressionTree) tree; return "javax.naming.Context".equals(constantExpression.expression().symbolType().fullyQualifiedName()) && "SECURITY_AUTHENTICATION".equals(constantExpression.identifier().name()); } return LiteralUtils.hasValue(tree, "java.naming.security.authentication"); } }
private static boolean isFileSeparator(ExpressionTree firstArg) { if (firstArg.is(Tree.Kind.MEMBER_SELECT)) { MemberSelectExpressionTree mse = (MemberSelectExpressionTree) firstArg; return "separator".equals(mse.identifier().name()) && mse.expression().symbolType().is("java.io.File"); } return false; }
private void checkSymbol(Symbol symbol) { for (IdentifierTree usageIdentifier : symbol.usages()) { Tree parent = usageIdentifier.parent(); if (parent.is(Kind.MEMBER_SELECT) && ((MemberSelectExpressionTree) parent).expression().is(Kind.MEMBER_SELECT)) { reportIssue(parent, String.format(MESSAGE, symbol.name())); } } }
private void reportIssue(MethodInvocationTree mit) { String identifier = getIdentifierPart(mit.methodSelect()); String issueMsg = identifier.isEmpty() ? "Optional#" : (identifier + "."); Tree reportTree = mit.methodSelect().is(Tree.Kind.MEMBER_SELECT) ? ((MemberSelectExpressionTree) mit.methodSelect()).expression() : mit; context.reportIssue(reportTree, check, "Call \""+ issueMsg + "isPresent()\" before accessing the value."); }
private void checkArrayLength(MemberSelectExpressionTree testedValue, BinaryExpressionTree bet, boolean leftIsZero) { if (!"length".equals(testedValue.identifier().name())) { return; } ExpressionTree expression = testedValue.expression(); if (!expression.symbolType().isArray()) { return; } reportIssue(bet, leftIsZero, ARRAY_ISSUE_MSG, arrayName(expression)); }
@Override public void visitMethodInvocation(MethodInvocationTree tree) { if (TO_STRING_MATCHERS.anyMatch(tree)) { ExpressionTree abstractTypedTree = ((MemberSelectExpressionTree) tree.methodSelect()).expression(); if (abstractTypedTree.is(Kind.NEW_CLASS) || isValueOfInvocation(abstractTypedTree)) { String typeName = abstractTypedTree.symbolType().toString(); createIssue(tree, typeName); } } super.visitMethodInvocation(tree); }
private void buildMethodInvocation(MethodInvocationTree mit) { handleExceptionalPaths(mit.symbol()); currentBlock.elements.add(mit); build(mit.arguments()); if (mit.methodSelect().is(Tree.Kind.MEMBER_SELECT)) { MemberSelectExpressionTree memberSelect = (MemberSelectExpressionTree) mit.methodSelect(); build(memberSelect.expression()); } else { build(mit.methodSelect()); } }
private static Type getMethodOwner(MethodInvocationTree mit) { if (mit.methodSelect().is(Kind.MEMBER_SELECT)) { return ((MemberSelectExpressionTree) mit.methodSelect()).expression().symbolType(); } return mit.symbol().owner().type(); }
@Override protected void onMethodInvocationFound(MethodInvocationTree mit) { if (mit.methodSelect().is(Tree.Kind.MEMBER_SELECT)) { MemberSelectExpressionTree mse = (MemberSelectExpressionTree) mit.methodSelect(); if (isEnum(mse.expression()) || isEnum(mit.arguments().get(0))) { reportIssue(mse.identifier(), "Use \"==\" to perform this enum comparison instead of using \"equals\""); } } }
@Override public void visitMethodInvocation(MethodInvocationTree tree) { if (tree.methodSelect().is(Tree.Kind.MEMBER_SELECT)) { MemberSelectExpressionTree memberSelect = (MemberSelectExpressionTree) tree.methodSelect(); boolean issue = ("equals".equals(memberSelect.identifier().name())) && (isToUpperCaseOrToLowerCase(memberSelect.expression()) || (tree.arguments().size() == 1 && isToUpperCaseOrToLowerCase(tree.arguments().get(0)))); if (issue) { context.reportIssue(this, tree, "Replace these toUpperCase()/toLowerCase() and equals() calls with a single equalsIgnoreCase() call."); } } super.visitMethodInvocation(tree); }
@Override protected void onMethodInvocationFound(MethodInvocationTree mit) { if (hasSemantic() && mit.methodSelect().is(Kind.MEMBER_SELECT)) { ExpressionTree expressionTree = ((MemberSelectExpressionTree) mit.methodSelect()).expression(); if (expressionTree.is(Kind.NEW_CLASS)) { reportIssue(expressionTree); } else if (expressionTree.is(Kind.IDENTIFIER) && variableUsedOnlyToGetClass((IdentifierTree) expressionTree)) { reportIssue(getInitializer((IdentifierTree) expressionTree)); } } }