Add a propertyTypes() method to AutoValueExtension.Context, to allow extensions to see the true type of every property. Use it in the @memoized extension.

RELNOTES=Add a propertyTypes() method to AutoValueExtension.Context, to allow extensions to see the true type of every property.

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

Author: eamonnmcmanus

value/src/main/java/com/google/auto/value/extension/AutoValueExtension.java

@@ -23,6 +23,7 @@
 import javax.annotation.processing.SupportedOptions;
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
 
 /**
  * An AutoValueExtension allows for extra functionality to be created during the generation of an
@@ -58,13 +59,13 @@
  * <p>The first generated class in the hierarchy will always be the one generated by the AutoValue
  * processor and the last one will always be the one generated by the Extension that {@code
  * mustBeFinal}, if any. Other than that, the order of the classes in the hierarchy is unspecified.
- * The * last class in the hierarchy is {@code AutoValue_Foo} and that is the one that the
+ * The last class in the hierarchy is {@code AutoValue_Foo} and that is the one that the
  * {@code Foo} class will reference, for example with {@code new AutoValue_Foo(...)}.
  *
  * <p>Each Extension must also be sure to generate a constructor with arguments corresponding to all
- * properties in {@link com.google.auto.value.extension.AutoValueExtension.Context#properties()}, in
- * order, and to call the superclass constructor with the same arguments. This constructor must have
- * at least package visibility.
+ * properties in {@link com.google.auto.value.extension.AutoValueExtension.Context#propertyTypes()},
+ * in order, and to call the superclass constructor with the same arguments. This constructor must
+ * have at least package visibility.
  *
  * <p>Because the class generated by the AutoValue processor is at the top of the generated
  * hierarchy, Extensions can override its methods, for example {@code hashCode()},
@@ -98,9 +99,42 @@ public interface Context {
      * example, if property {@code bar} is defined by {@code abstract String getBar()} then this map
      * will have an entry mapping {@code "bar"} to the {@code ExecutableElement} for {@code
      * getBar()}.
+     *
+     * <p>To determine the type of a property, it is best to use {@link #propertyTypes()} rather
+     * than looking at the return type of the {@link ExecutableElement} in this map. The reason is
+     * that the final type of the property might be different because of type variables. For
+     * example, if you have...
+     *
+     * <pre>
+     *   interface Parent<T> {
+     *     T bar();
+     *   }
+     *
+     *  {@code @AutoValue abstract class Foo implements Parent<String> {...}}
+     * </pre>
+     *
+     * ...then the type of the {@code bar} property in {@code Foo} is actually {@code String}, but
+     * the {@code ExecutableElement} will be the the method in {@code Parent}, whose return type is
+     * {@code T}.
      */
     Map<String, ExecutableElement> properties();
 
+    /**
+     * Returns the properties to be generated by AutoValue, with their types. Each key is a property
+     * name, and the corresponding value is the type of that property. The order of the map entries
+     * is the same as the order of the {@code @AutoValue} properties.
+     *
+     * <p>For example, if property {@code bar} is defined by {@code abstract String getBar()} then
+     * this map will have an entry mapping {@code "bar"} to the {@code TypeMirror} for {@code
+     * String}.
+     *
+     * <p>For compatibility reasons, this method has a default implementation that throws an
+     * exception. The AutoValue processor supplies an implementation that behaves as documented.
+     */
+    default Map<String, TypeMirror> propertyTypes() {
+      throw new UnsupportedOperationException();
+    }
+
     /**
      * Returns the complete set of abstract methods defined in or inherited by the
      * {@code @AutoValue} class. This includes all methods that define properties (like {@code
@@ -269,13 +303,20 @@ public Set<ExecutableElement> consumeMethods(Context context) {
    * <pre>{@code
    * package <package>;
    * ...
-   * <finalOrAbstract> class <className> extends <classToExtend> {...}
+   * <finalOrAbstract> class <className> extends <classToExtend> {
+   *   // Constructor
+   *   <className>(<constructorParameters>) {
+   *     super(<constructorParameterNames>);
+   *     ...
+   *   }
+   *   ...
    * }</pre>
    *
    * <p>Here, {@code <package>} is {@link Context#packageName()}; {@code <finalOrAbstract>} is the
    * keyword {@code final} if {@code isFinal} is true or {@code abstract} otherwise; and {@code
    * <className>} and {@code <classToExtend>} are the values of this method's parameters of the same
-   * name.
+   * name. The {@code <constructorParameters>} and {@code <constructorParameterNames>} are typically
+   * derived from {@link Context#propertyTypes()}.
    *
    * @param context The {@link Context} of the code generation for this class.
    * @param className The simple name of the resulting class. The returned code will be written to a

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

@@ -53,6 +53,7 @@
 import com.google.common.base.Joiner;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.FormatMethod;
 import com.squareup.javapoet.AnnotationSpec;
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
@@ -198,8 +199,8 @@ private ImmutableList<TypeVariableName> typeVariableNames() {
 
     private MethodSpec constructor() {
       MethodSpec.Builder constructor = constructorBuilder();
-      for (Map.Entry<String, ExecutableElement> property : context.properties().entrySet()) {
-        constructor.addParameter(annotatedReturnType(property.getValue()), property.getKey() + "$");
+      for (Map.Entry<String, TypeMirror> property : context.propertyTypes().entrySet()) {
+        constructor.addParameter(annotatedType(property.getValue()), property.getKey() + "$");
       }
       List<String> namesWithDollars = new ArrayList<String>();
       for (String property : context.properties().keySet()) {
@@ -399,7 +400,8 @@ private final class MethodOverrider {
         this.method = method;
         validate();
         cacheField =
-            buildCacheField(annotatedReturnType(method), method.getSimpleName().toString());
+            buildCacheField(
+                annotatedType(method.getReturnType()), method.getSimpleName().toString());
         fields.add(cacheField);
         override =
             methodBuilder(method.getSimpleName().toString())
@@ -457,10 +459,11 @@ private void validate() {
 
       private void checkIllegalModifier(Modifier modifier) {
         if (method.getModifiers().contains(modifier)) {
-          printMessage(ERROR, "@Memoized methods cannot be " + modifier.toString());
+          printMessage(ERROR, "@Memoized methods cannot be %s", modifier.toString());
         }
       }
 
+      @FormatMethod
       private void printMessage(Kind kind, String format, Object... args) {
         if (kind.equals(ERROR)) {
           hasErrors = true;
@@ -585,13 +588,12 @@ private static boolean containsNullable(List<? extends AnnotationMirror> annotat
         .anyMatch(n -> n.contentEquals("Nullable"));
   }
 
-  /** The return type of the given method, including type annotations. */
-  private static TypeName annotatedReturnType(ExecutableElement method) {
-    TypeMirror returnType = method.getReturnType();
+  /** Translate a {@link TypeMirror} into a {@link TypeName}, including type annotations. */
+  private static TypeName annotatedType(TypeMirror type) {
     List<AnnotationSpec> annotations =
-        returnType.getAnnotationMirrors().stream()
+        type.getAnnotationMirrors().stream()
             .map(AnnotationSpec::get)
             .collect(toList());
-    return TypeName.get(returnType).annotated(annotations);
+    return TypeName.get(type).annotated(annotations);
   }
 }

value/src/main/java/com/google/auto/value/processor/AutoOneOfProcessor.java

@@ -99,9 +99,11 @@ void processType(TypeElement autoOneOfType) {
     Set<ExecutableElement> otherMethods = new LinkedHashSet<>(abstractMethods);
     otherMethods.remove(kindGetter);
 
-    ImmutableSet<ExecutableElement> propertyMethods = propertyMethodsIn(otherMethods);
-    ImmutableBiMap<String, ExecutableElement> properties = propertyNameToMethodMap(propertyMethods);
-    validateMethods(autoOneOfType, abstractMethods, propertyMethods, kindGetter);
+    ImmutableMap<ExecutableElement, TypeMirror> propertyMethodsAndTypes =
+        propertyMethodsIn(otherMethods, autoOneOfType);
+    ImmutableBiMap<String, ExecutableElement> properties =
+        propertyNameToMethodMap(propertyMethodsAndTypes.keySet());
+    validateMethods(autoOneOfType, abstractMethods, propertyMethodsAndTypes.keySet(), kindGetter);
     ImmutableMap<String, String> propertyToKind =
         propertyToKindMap(kindMirror, properties.keySet());
 
@@ -110,7 +112,7 @@ void processType(TypeElement autoOneOfType) {
     vars.generatedClass = TypeSimplifier.simpleNameOf(subclass);
     vars.propertyToKind = propertyToKind;
     defineSharedVarsForType(autoOneOfType, methods, vars);
-    defineVarsForType(autoOneOfType, vars, propertyMethods, kindGetter);
+    defineVarsForType(autoOneOfType, vars, propertyMethodsAndTypes, kindGetter);
 
     String text = vars.toText();
     text = TypeEncoder.decode(text, processingEnv, vars.pkg, autoOneOfType.asType());
@@ -244,7 +246,7 @@ && objectMethodToOverride(method) == ObjectMethod.NONE) {
         // implement this alien method.
         errorReporter()
             .reportWarning(
-                "Abstract methods in @AutoOneOf classes must be non-void with no parameters",
+                "Abstract methods in @AutoOneOf classes must have no parameters",
                 method);
       }
     }
@@ -254,10 +256,10 @@ && objectMethodToOverride(method) == ObjectMethod.NONE) {
   private void defineVarsForType(
       TypeElement type,
       AutoOneOfTemplateVars vars,
-      ImmutableSet<ExecutableElement> propertyMethods,
+      ImmutableMap<ExecutableElement, TypeMirror> propertyMethodsAndTypes,
       ExecutableElement kindGetter) {
-    vars.props =
-        propertySet(type, propertyMethods, ImmutableListMultimap.of(), ImmutableListMultimap.of());
+    vars.props = propertySet(
+        propertyMethodsAndTypes, ImmutableListMultimap.of(), ImmutableListMultimap.of());
     vars.kindGetter = kindGetter.getSimpleName().toString();
     vars.kindType = TypeEncoder.encode(kindGetter.getReturnType());
     TypeElement javaIoSerializable = elementUtils().getTypeElement("java.io.Serializable");

value/src/main/java/com/google/auto/value/processor/AutoValueOrOneOfProcessor.java

@@ -359,46 +359,41 @@ public final boolean process(Set<? extends TypeElement> annotations, RoundEnviro
    *     AutoValue.CopyAnnotations} also do not appear here.
    */
   final ImmutableSet<Property> propertySet(
-      TypeElement type,
-      ImmutableSet<ExecutableElement> propertyMethods,
+      ImmutableMap<ExecutableElement, TypeMirror> propertyMethodsAndTypes,
       ImmutableListMultimap<ExecutableElement, AnnotationMirror> annotatedPropertyFields,
       ImmutableListMultimap<ExecutableElement, AnnotationMirror> annotatedPropertyMethods) {
     ImmutableBiMap<ExecutableElement, String> methodToPropertyName =
-        propertyNameToMethodMap(propertyMethods).inverse();
+        propertyNameToMethodMap(propertyMethodsAndTypes.keySet()).inverse();
     Map<ExecutableElement, String> methodToIdentifier = new LinkedHashMap<>(methodToPropertyName);
     fixReservedIdentifiers(methodToIdentifier);
-    EclipseHack eclipseHack = new EclipseHack(processingEnv);
-    DeclaredType declaredType = MoreTypes.asDeclared(type.asType());
-    ImmutableMap<ExecutableElement, TypeMirror> returnTypes =
-        eclipseHack.methodReturnTypes(propertyMethods, declaredType);
 
     ImmutableSet.Builder<Property> props = ImmutableSet.builder();
-    for (ExecutableElement propertyMethod : propertyMethods) {
-      TypeMirror returnType = returnTypes.get(propertyMethod);
-      String propertyType =
-          TypeEncoder.encodeWithAnnotations(returnType, getExcludedAnnotationTypes(propertyMethod));
-      String propertyName = methodToPropertyName.get(propertyMethod);
-      String identifier = methodToIdentifier.get(propertyMethod);
-      ImmutableList<String> fieldAnnotations =
-          annotationStrings(annotatedPropertyFields.get(propertyMethod));
-      ImmutableList<AnnotationMirror> methodAnnotationMirrors =
-          annotatedPropertyMethods.get(propertyMethod);
-      ImmutableList<String> methodAnnotations = annotationStrings(methodAnnotationMirrors);
-      Optional<String> nullableAnnotation = nullableAnnotationForMethod(propertyMethod);
-      Property p =
-          new Property(
-              propertyName,
-              identifier,
-              propertyMethod,
-              propertyType,
-              fieldAnnotations,
-              methodAnnotations,
-              nullableAnnotation);
-      props.add(p);
-      if (p.isNullable() && returnType.getKind().isPrimitive()) {
-        errorReporter().reportError("Primitive types cannot be @Nullable", propertyMethod);
-      }
-    }
+    propertyMethodsAndTypes.forEach(
+        (propertyMethod, returnType) -> {
+          String propertyType = TypeEncoder.encodeWithAnnotations(
+              returnType, getExcludedAnnotationTypes(propertyMethod));
+          String propertyName = methodToPropertyName.get(propertyMethod);
+          String identifier = methodToIdentifier.get(propertyMethod);
+          ImmutableList<String> fieldAnnotations =
+              annotationStrings(annotatedPropertyFields.get(propertyMethod));
+          ImmutableList<AnnotationMirror> methodAnnotationMirrors =
+              annotatedPropertyMethods.get(propertyMethod);
+          ImmutableList<String> methodAnnotations = annotationStrings(methodAnnotationMirrors);
+          Optional<String> nullableAnnotation = nullableAnnotationForMethod(propertyMethod);
+          Property p =
+              new Property(
+                  propertyName,
+                  identifier,
+                  propertyMethod,
+                  propertyType,
+                  fieldAnnotations,
+                  methodAnnotations,
+                  nullableAnnotation);
+          props.add(p);
+          if (p.isNullable() && returnType.getKind().isPrimitive()) {
+            errorReporter().reportError("Primitive types cannot be @Nullable", propertyMethod);
+          }
+        });
     return props.build();
   }
 
@@ -716,10 +711,14 @@ static ImmutableSet<ExecutableElement> abstractMethodsIn(
   }
 
   /**
-   * Returns the subset of property methods in the given set of abstract methods. A property method
-   * has no arguments, is not void, and is not {@code hashCode()} or {@code toString()}.
+   * Returns the subset of property methods in the given set of abstract methods, with their actual
+   * return types. A property method has no arguments, is not void, and is not {@code hashCode()} or
+   * {@code toString()}.
    */
-  ImmutableSet<ExecutableElement> propertyMethodsIn(Set<ExecutableElement> abstractMethods) {
+  ImmutableMap<ExecutableElement, TypeMirror> propertyMethodsIn(
+      Set<ExecutableElement> abstractMethods,
+      TypeElement autoValueOrOneOfType) {
+    DeclaredType declaredType = MoreTypes.asDeclared(autoValueOrOneOfType.asType());
     ImmutableSet.Builder<ExecutableElement> properties = ImmutableSet.builder();
     for (ExecutableElement method : abstractMethods) {
       if (method.getParameters().isEmpty()
@@ -728,7 +727,7 @@ && objectMethodToOverride(method) == ObjectMethod.NONE) {
         properties.add(method);
       }
     }
-    return properties.build();
+    return new EclipseHack(processingEnv).methodReturnTypes(properties.build(), declaredType);
   }
 
   /** True if void properties are allowed. */