When hashCode() is @memoized, check the hash code before checking equality as an optimization

RELNOTES=When `hashCode()` is `@Memoized`, `equals()` will be optimized to check hash codes first before other properies

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

Author: ronshapiro

value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizeExtension.java

@@ -21,13 +21,15 @@
 import static com.google.common.base.Predicates.equalTo;
 import static com.google.common.base.Predicates.not;
 import static com.google.common.collect.Iterables.filter;
+import static com.google.common.collect.Iterables.getOnlyElement;
 import static com.squareup.javapoet.MethodSpec.constructorBuilder;
 import static com.squareup.javapoet.MethodSpec.methodBuilder;
 import static com.squareup.javapoet.TypeSpec.classBuilder;
 import static java.util.stream.Collectors.toList;
 import static javax.lang.model.element.Modifier.ABSTRACT;
 import static javax.lang.model.element.Modifier.FINAL;
 import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
 import static javax.lang.model.element.Modifier.STATIC;
 import static javax.lang.model.element.Modifier.VOLATILE;
 import static javax.lang.model.type.TypeKind.VOID;
@@ -64,6 +66,7 @@
 import javax.lang.model.element.TypeParameterElement;
 import javax.lang.model.type.TypeMirror;
 import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
 import javax.tools.Diagnostic.Kind;
 
 /** An extension that implements the {@link Memoized} contract. */
@@ -110,6 +113,7 @@ static final class Generator {
     private final String classToExtend;
     private final boolean isFinal;
     private final Elements elements;
+    private final Types types;
     private final SourceVersion sourceVersion;
     private final Messager messager;
     private final Optional<AnnotationSpec> lazyInitAnnotation;
@@ -121,6 +125,7 @@ static final class Generator {
       this.classToExtend = classToExtend;
       this.isFinal = isFinal;
       this.elements = context.processingEnvironment().getElementUtils();
+      this.types = context.processingEnvironment().getTypeUtils();
       this.sourceVersion = context.processingEnvironment().getSourceVersion();
       this.messager = context.processingEnvironment().getMessager();
       this.lazyInitAnnotation = getLazyInitAnnotation(elements);
@@ -140,6 +145,9 @@ String generate() {
         generated.addFields(methodOverrider.fields());
         generated.addMethod(methodOverrider.method());
       }
+      if (isHashCodeMemoized() && !isEqualsFinal()) {
+        generated.addMethod(equalsWithHashCodeCheck());
+      }
       if (hasErrors) {
         return null;
       }
@@ -176,6 +184,40 @@ private MethodSpec constructor() {
       return constructor.build();
     }
 
+    private boolean isHashCodeMemoized() {
+      return memoizedMethods(context).stream()
+          .anyMatch(method -> method.getSimpleName().contentEquals("hashCode"));
+    }
+
+    private boolean isEqualsFinal() {
+      TypeMirror objectType = elements.getTypeElement(Object.class.getCanonicalName()).asType();
+      ExecutableElement equals =
+          MoreElements.getLocalAndInheritedMethods(context.autoValueClass(), types, elements)
+              .stream()
+              .filter(method -> method.getSimpleName().contentEquals("equals"))
+              .filter(method -> method.getParameters().size() == 1)
+              .filter(
+                  method ->
+                      types.isSameType(getOnlyElement(method.getParameters()).asType(), objectType))
+              .findFirst()
+              .get();
+      return equals.getModifiers().contains(FINAL);
+    }
+
+    private MethodSpec equalsWithHashCodeCheck() {
+      return methodBuilder("equals")
+          .addModifiers(PUBLIC)
+          .returns(TypeName.BOOLEAN)
+          .addAnnotation(Override.class)
+          .addParameter(TypeName.OBJECT, "that")
+          .addStatement(
+              "return that instanceof $N "
+                  + "&& this.hashCode() == that.hashCode() "
+                  + "&& super.equals(that)",
+              className)
+          .build();
+    }
+
     /**
      * Determines the required fields and overriding method for a {@link Memoized @Memoized} method.
      */

value/src/test/java/com/google/auto/value/extension/memoized/MemoizedTest.java

@@ -19,6 +19,7 @@
 import static org.junit.Assert.fail;
 
 import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.MemoizedTest.HashCodeEqualsOptimization.EqualsCounter;
 import com.google.common.collect.ImmutableList;
 import java.lang.reflect.AnnotatedType;
 import java.lang.reflect.Constructor;
@@ -160,6 +161,53 @@ public String toString() {
     }
   }
 
+  @AutoValue
+  abstract static class HashCodeEqualsOptimization {
+    int overrideHashCode;
+    int hashCodeCount;
+
+    abstract EqualsCounter equalsCounter();
+
+    @Memoized
+    @Override
+    public int hashCode() {
+      hashCodeCount++;
+      return overrideHashCode;
+    }
+
+    static class EqualsCounter {
+      int equalsCount;
+
+      @Override
+      public int hashCode() {
+        return 0;
+      }
+
+      @Override
+      public boolean equals(Object obj) {
+        equalsCount++;
+        return true;
+      }
+    }
+  }
+
+  @AutoValue
+  abstract static class HashCodeEqualsOptimizationOffWhenEqualsIsFinal {
+    int hashCodeCount;
+
+    @Override
+    @Memoized
+    public int hashCode() {
+      hashCodeCount++;
+      return 1;
+    }
+
+    @Override
+    public final boolean equals(Object that) {
+      return that instanceof HashCodeEqualsOptimizationOffWhenEqualsIsFinal;
+    }
+  }
+
   @Before
   public void setUp() {
     value = new AutoValue_MemoizedTest_Value(
@@ -300,4 +348,51 @@ public void nullableConstructorParameter() throws ReflectiveOperationException {
                    org.checkerframework.checker.nullness.qual.Nullable.class))
         .isTrue();
   }
+
+  @Test
+  public void hashCodeEqualsOptimization() {
+    HashCodeEqualsOptimization first =
+        new AutoValue_MemoizedTest_HashCodeEqualsOptimization(new EqualsCounter());
+    HashCodeEqualsOptimization second =
+        new AutoValue_MemoizedTest_HashCodeEqualsOptimization(new EqualsCounter());
+
+    first.overrideHashCode = 2;
+    second.overrideHashCode = 2;
+    assertThat(first.equals(second)).isTrue();
+    assertThat(first.equalsCounter().equalsCount).isEqualTo(1);
+
+    HashCodeEqualsOptimization otherwiseEqualsButDifferentHashCode =
+        new AutoValue_MemoizedTest_HashCodeEqualsOptimization(new EqualsCounter());
+    otherwiseEqualsButDifferentHashCode.overrideHashCode = 4;
+
+    assertThat(otherwiseEqualsButDifferentHashCode.equals(first)).isFalse();
+    assertThat(otherwiseEqualsButDifferentHashCode.equalsCounter().equalsCount).isEqualTo(0);
+  }
+
+  @Test
+  public void hashCodeEqualsOptimization_otherTypes() {
+    HashCodeEqualsOptimization optimizedEquals =
+        new AutoValue_MemoizedTest_HashCodeEqualsOptimization(new EqualsCounter());
+
+    assertThat(optimizedEquals.equals(new Object())).isFalse();
+    assertThat(optimizedEquals.equals(null)).isFalse();
+
+    assertThat(optimizedEquals.equalsCounter().equalsCount).isEqualTo(0);
+    assertThat(optimizedEquals.hashCodeCount).isEqualTo(0);
+  }
+
+  @Test
+  public void hashCodeEqualsOptimization_offWhenEqualsIsFinal() {
+    HashCodeEqualsOptimizationOffWhenEqualsIsFinal memoizedHashCodeAndFinalEqualsMethod =
+        new AutoValue_MemoizedTest_HashCodeEqualsOptimizationOffWhenEqualsIsFinal();
+    HashCodeEqualsOptimizationOffWhenEqualsIsFinal second =
+        new AutoValue_MemoizedTest_HashCodeEqualsOptimizationOffWhenEqualsIsFinal();
+
+    assertThat(memoizedHashCodeAndFinalEqualsMethod.equals(second)).isTrue();
+    assertThat(memoizedHashCodeAndFinalEqualsMethod.hashCodeCount).isEqualTo(0);
+
+    memoizedHashCodeAndFinalEqualsMethod.hashCode();
+    memoizedHashCodeAndFinalEqualsMethod.hashCode();
+    assertThat(memoizedHashCodeAndFinalEqualsMethod.hashCodeCount).isEqualTo(1);
+  }
 }