Recognize that it's safe to migrate from == to isEqualTo() for enums.

Add a negative test case I should have written for the first CL.

RELNOTES: none

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=243168106

core/src/main/java/com/google/errorprone/bugpatterns/ImplementAssertionWithChaining.java

@@ -25,6 +25,7 @@
 import static com.google.errorprone.matchers.Matchers.instanceMethod;
 import static com.google.errorprone.matchers.Matchers.staticMethod;
 import static com.google.errorprone.util.ASTHelpers.getType;
+import static com.google.errorprone.util.ASTHelpers.isSubtype;
 import static com.google.errorprone.util.ASTHelpers.stripParentheses;
 import static com.sun.source.tree.Tree.Kind.BLOCK;
 import static com.sun.source.tree.Tree.Kind.EXPRESSION_STATEMENT;
@@ -120,7 +121,7 @@ private static ImmutableList<ExpressionTree> findActualAndExpected(
             stripParentheses(((UnaryTree) condition).getExpression()), state);
 
       case NOT_EQUAL_TO:
-        return findActualAndExpectedForBinaryOp((BinaryTree) condition);
+        return findActualAndExpectedForBinaryOp((BinaryTree) condition, state);
 
       default:
         return null;
@@ -143,15 +144,30 @@ private static ImmutableList<ExpressionTree> findActualAndExpectedForPossibleEqu
   }
 
   private static ImmutableList<ExpressionTree> findActualAndExpectedForBinaryOp(
-      BinaryTree binaryTree) {
-    if (!getType(binaryTree.getLeftOperand()).isPrimitive()
-        || !getType(binaryTree.getRightOperand()).isPrimitive()) {
+      BinaryTree binaryTree, VisitorState state) {
+    /*
+     * It's actually enough for *either* to be a primitive, thanks to autounboxing (and enough for
+     * *either* to be an enum, since equals() is symmetric). However, it turns out that handling
+     * those cases catches almost nothing new in practice, and I'm seeing some evidence that "null"
+     * is considered to be a primitive? or something? That seems wrong, but given the low payoff,
+     * I'm not going to investigate further.
+     */
+    boolean bothPrimitives =
+        getType(binaryTree.getLeftOperand()).isPrimitive()
+            && getType(binaryTree.getRightOperand()).isPrimitive();
+    boolean bothEnums =
+        isEnum(binaryTree.getLeftOperand(), state) && isEnum(binaryTree.getRightOperand(), state);
+    if (!bothPrimitives && !bothEnums) {
       // TODO(cpovirk): Generate an isSameAs() check (if that is what users really want).
       return null;
     }
     return ImmutableList.of(binaryTree.getLeftOperand(), binaryTree.getRightOperand());
   }
 
+  private static boolean isEnum(ExpressionTree tree, VisitorState state) {
+    return isSubtype(getType(tree), state.getTypeFromString("java.lang.Enum"), state);
+  }
+
   /**
    * Checks that the statement, after unwrapping any braces, consists of a single call to a {@code
    * fail} method.

core/src/test/java/com/google/errorprone/bugpatterns/testdata/ImplementAssertionWithChainingNegativeCases.java

@@ -37,15 +37,23 @@ void doesNotHaveInteger(int other) {
         fail("had unexpected integer");
       }
     }
+
+    void hasBoxedIntegerSameInstance(Integer expected) {
+      if (actual().boxedInteger() != expected) {
+        fail("didn't match expected string instance");
+      }
+    }
   }
 
   private static final class Foo {
     final String string;
     final int integer;
+    final Integer boxedInteger;
 
-    Foo(String string, int integer) {
+    Foo(String string, int integer, Integer boxedInteger) {
       this.string = string;
       this.integer = integer;
+      this.boxedInteger = boxedInteger;
     }
 
     String string() {
@@ -56,6 +64,10 @@ int integer() {
       return integer;
     }
 
+    Integer boxedInteger() {
+      return boxedInteger;
+    }
+
     Foo otherFoo() {
       return this;
     }

core/src/test/java/com/google/errorprone/bugpatterns/testdata/ImplementAssertionWithChainingPositiveCases.java

@@ -54,6 +54,13 @@ void hasInteger(int expected) {
       }
     }
 
+    void hasKind(Kind expected) {
+      // BUG: Diagnostic contains: check("kind()").that(actual().kind()).isEqualTo(expected)
+      if (actual().kind() != expected) {
+        fail("has kind %s", expected);
+      }
+    }
+
     void hasOtherFooInteger(int expected) {
       // BUG: Diagnostic contains:
       // check("otherFoo().integer()").that(actual().otherFoo().integer()).isEqualTo(expected)
@@ -66,10 +73,12 @@ void hasOtherFooInteger(int expected) {
   private static final class Foo {
     final String string;
     final int integer;
+    final Kind kind;
 
-    Foo(String string, int integer) {
+    Foo(String string, int integer, Kind kind) {
       this.string = string;
       this.integer = integer;
+      this.kind = kind;
     }
 
     String string() {
@@ -80,8 +89,14 @@ int integer() {
       return integer;
     }
 
+    Kind kind() {
+      return kind;
+    }
+
     Foo otherFoo() {
       return this;
     }
   }
+
+  private enum Kind {}
 }