@Override
public Description matchMethodInvocation(
MethodInvocationTree methodInvocationTree, VisitorState state) {
if (methodInvocationTree.getArguments().isEmpty()) {
return Description.NO_MATCH;
}
if (!TRUTH_SUBJECT_CALL.matches(methodInvocationTree, state)) {
return Description.NO_MATCH;
}
ExpressionTree rec = ASTHelpers.getReceiver(methodInvocationTree);
if (rec == null) {
return Description.NO_MATCH;
}
if (!ASSERT_THAT.matches(rec, state)) {
return Description.NO_MATCH;
}
ExpressionTree expr = getOnlyElement(((MethodInvocationTree) rec).getArguments());
if (expr == null) {
return Description.NO_MATCH;
}
// check that argument of assertThat is a constant
if (ASTHelpers.constValue(expr) == null) {
return Description.NO_MATCH;
}
// check that expectation isn't a constant
ExpressionTree expectation = getOnlyElement(methodInvocationTree.getArguments());
if (ASTHelpers.constValue(expectation) != null) {
return Description.NO_MATCH;
}
SuggestedFix fix = SuggestedFix.swap(expr, expectation);
return buildDescription(methodInvocationTree).addFix(fix).build();
}
@Override
public Description matchClass(ClassTree classTree, VisitorState state) {
TypeSymbol symbol = ASTHelpers.getSymbol(classTree);
if (symbol.getKind() != ElementKind.CLASS) {
return Description.NO_MATCH;
}
MethodTree equals = null;
for (Tree member : classTree.getMembers()) {
if (!(member instanceof MethodTree)) {
continue;
}
MethodTree methodTree = (MethodTree) member;
if (EQUALS_MATCHER.matches(methodTree, state)) {
equals = methodTree;
}
}
if (equals == null) {
return Description.NO_MATCH;
}
MethodSymbol hashCodeSym =
ASTHelpers.resolveExistingMethod(
state,
symbol,
state.getName("hashCode"),
ImmutableList.<Type>of(),
ImmutableList.<Type>of());
if (hashCodeSym.owner.equals(state.getSymtab().objectType.tsym)) {
return describeMatch(equals);
}
return Description.NO_MATCH;
}
private boolean anyCatchBlockMatches(TryTree tree, VisitorState state, Matcher<Tree> matcher) {
for (CatchTree catchTree : tree.getCatches()) {
if (matcher.matches(catchTree.getBlock(), state)) {
return true;
}
}
return false;
}
private boolean isInapplicableExceptionType(TryTree tree, VisitorState state) {
for (CatchTree catchTree : tree.getCatches()) {
if (INAPPLICABLE_EXCEPTION.matches(catchTree.getParameter(), state)) {
return true;
}
}
return false;
}
/**
* Suggests replacing with Arrays.equals(a, b). Also adds the necessary import statement for
* java.util.Arrays.
*/
@Override
public Description matchMethodInvocation(MethodInvocationTree t, VisitorState state) {
String arg1;
String arg2;
if (instanceEqualsMatcher.matches(t, state)) {
arg1 = ((JCFieldAccess) t.getMethodSelect()).getExpression().toString();
arg2 = t.getArguments().get(0).toString();
} else if (staticEqualsMatcher.matches(t, state)) {
arg1 = t.getArguments().get(0).toString();
arg2 = t.getArguments().get(1).toString();
} else {
return NO_MATCH;
}
Fix fix =
SuggestedFix.builder()
.replace(t, "Arrays.equals(" + arg1 + ", " + arg2 + ")")
.addImport("java.util.Arrays")
.build();
return describeMatch(t, fix);
}
@Override
public boolean matches(MethodInvocationTree methodInvocationTree, VisitorState state) {
return methodSelectMatcher.matches(methodInvocationTree, state)
&& matches(methodInvocationTree.getArguments());
}
private boolean hasThrowOrFail(TryTree tree, VisitorState state) {
return THROW_OR_FAIL_IN_BLOCK.matches(tree, state);
}
private boolean isInInapplicableMethod(TryTree tree, VisitorState state) {
return NON_TEST_METHOD.matches(tree, state);
}
private boolean returnsInTryCatchOrAfter(TryTree tree, VisitorState state) {
return RETURN_IN_BLOCK.matches(tree, state) || RETURN_AFTER.matches(tree, state);
}
private boolean hasContinue(TryTree tree, VisitorState state) {
return CONTINUE_IN_BLOCK.matches(tree, state);
}
private boolean hasWhileTrue(TryTree tree, VisitorState state) {
return WHILE_TRUE_IN_BLOCK.matches(tree, state);
}
