Add [tags] to AutoValue error messages. This will enable them to be correlated so that we can potentially see which ones are commonest.

RELNOTES=AutoValue error messages now have short `[tags]` so they can be correlated by tools.

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

Author: eamonnmcmanus

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

@@ -72,7 +72,9 @@ boolean propertiesCanBeVoid() {
   void processType(TypeElement autoOneOfType) {
     if (autoOneOfType.getKind() != ElementKind.CLASS) {
       errorReporter()
-          .abortWithError(autoOneOfType, "@" + AUTO_ONE_OF_NAME + " only applies to classes");
+          .abortWithError(
+              autoOneOfType,
+              "[AutoOneOfNotClass] @" + AUTO_ONE_OF_NAME + " only applies to classes");
     }
     checkModifiersIfNested(autoOneOfType);
     DeclaredType kindMirror = mirrorForKindType(autoOneOfType);
@@ -129,7 +131,7 @@ private DeclaredType mirrorForKindType(TypeElement autoOneOfType) {
       errorReporter()
           .abortWithError(
               autoOneOfType,
-              "annotation processor for @AutoOneOf was invoked with a type"
+              "[AutoOneOfCompilerBug] annotation processor for @AutoOneOf was invoked with a type"
                   + " that does not have that annotation; this is probably a compiler bug");
     }
     AnnotationValue kindValue =
@@ -184,7 +186,8 @@ private ImmutableMap<String, String> propertyToKindMap(
             errorReporter()
                 .reportError(
                     kindElement,
-                    "Enum has no constant with name corresponding to property '%s'",
+                    "[AutoOneOfNoEnumConstant] Enum has no constant with name corresponding to"
+                        + " property '%s'",
                     property);
           }
         });
@@ -195,7 +198,8 @@ private ImmutableMap<String, String> propertyToKindMap(
             errorReporter()
                 .reportError(
                     constant,
-                    "Name of enum constant '%s' does not correspond to any property name",
+                    "[AutoOneOfBadEnumConstant] Name of enum constant '%s' does not correspond to"
+                        + " any property name",
                     constant.getSimpleName());
           }
         });
@@ -221,7 +225,7 @@ private ExecutableElement findKindGetterOrAbort(
         errorReporter()
             .reportError(
                 autoOneOfType,
-                "%s must have a no-arg abstract method returning %s",
+                "[AutoOneOfNoKindGetter] %s must have a no-arg abstract method returning %s",
                 autoOneOfType,
                 kindMirror);
         break;
@@ -230,7 +234,10 @@ private ExecutableElement findKindGetterOrAbort(
       default:
         for (ExecutableElement getter : kindGetters) {
           errorReporter()
-              .reportError(getter, "More than one abstract method returns %s", kindMirror);
+              .reportError(
+                  getter,
+                  "[AutoOneOfTwoKindGetters] More than one abstract method returns %s",
+                  kindMirror);
         }
     }
     throw new AbortProcessingException();
@@ -254,7 +261,8 @@ && objectMethodToOverride(method) == ObjectMethod.NONE) {
         // implement this alien method.
         errorReporter()
             .reportWarning(
-                method, "Abstract methods in @AutoOneOf classes must have no parameters");
+                method,
+                "[AutoOneOfParams] Abstract methods in @AutoOneOf classes must have no parameters");
       }
     }
     errorReporter().abortIfAnyError();
@@ -278,7 +286,9 @@ private void defineVarsForType(
   @Override
   Optional<String> nullableAnnotationForMethod(ExecutableElement propertyMethod) {
     if (nullableAnnotationFor(propertyMethod, propertyMethod.getReturnType()).isPresent()) {
-      errorReporter().reportError(propertyMethod, "@AutoOneOf properties cannot be @Nullable");
+      errorReporter()
+          .reportError(
+              propertyMethod, "[AutoOneOfNullable] @AutoOneOf properties cannot be @Nullable");
     }
     return Optional.empty();
   }

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

@@ -71,7 +71,6 @@
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.TypeParameterElement;
 import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.ArrayType;
 import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
@@ -301,7 +300,8 @@ public final boolean process(Set<? extends TypeElement> annotations, RoundEnviro
       for (TypeElement type : deferredTypes) {
         errorReporter.reportError(
             type,
-            "Did not generate @%s class for %s because it references undefined types",
+            "[AutoValueUndefined] Did not generate @%s class for %s because it references"
+                + " undefined types",
             simpleAnnotationName,
             type.getQualifiedName());
       }
@@ -331,7 +331,10 @@ public final boolean process(Set<? extends TypeElement> annotations, RoundEnviro
       } catch (RuntimeException e) {
         String trace = Throwables.getStackTraceAsString(e);
         errorReporter.reportError(
-            type, "@%s processor threw an exception: %s", simpleAnnotationName, trace);
+            type,
+            "[AutoValueException] @%s processor threw an exception: %s",
+            simpleAnnotationName,
+            trace);
         throw e;
       }
     }
@@ -378,8 +381,9 @@ final ImmutableSet<Property> propertySet(
     ImmutableSet.Builder<Property> props = ImmutableSet.builder();
     propertyMethodsAndTypes.forEach(
         (propertyMethod, returnType) -> {
-          String propertyType = TypeEncoder.encodeWithAnnotations(
-              returnType, getExcludedAnnotationTypes(propertyMethod));
+          String propertyType =
+              TypeEncoder.encodeWithAnnotations(
+                  returnType, getExcludedAnnotationTypes(propertyMethod));
           String propertyName = methodToPropertyName.get(propertyMethod);
           String identifier = methodToIdentifier.get(propertyMethod);
           ImmutableList<String> fieldAnnotations =
@@ -399,7 +403,9 @@ final ImmutableSet<Property> propertySet(
                   nullableAnnotation);
           props.add(p);
           if (p.isNullable() && returnType.getKind().isPrimitive()) {
-            errorReporter().reportError(propertyMethod, "Primitive types cannot be @Nullable");
+            errorReporter()
+                .reportError(
+                    propertyMethod, "[AutoValueNullPrimitive] Primitive types cannot be @Nullable");
           }
         });
     return props.build();
@@ -517,7 +523,10 @@ final ImmutableBiMap<String, ExecutableElement> propertyNameToMethodMap(
         // reportedDups prevents us from reporting more than one error for the same method.
         for (ExecutableElement context : contexts) {
           errorReporter.reportError(
-              context, "More than one @%s property called %s", simpleAnnotationName, name);
+              context,
+              "[AutoValueDupProperty] More than one @%s property called %s",
+              simpleAnnotationName,
+              name);
         }
       }
     }
@@ -622,16 +631,18 @@ final void checkModifiersIfNested(TypeElement type) {
     if (enclosingKind.isClass() || enclosingKind.isInterface()) {
       if (type.getModifiers().contains(Modifier.PRIVATE)) {
         errorReporter.abortWithError(
-            type, "@%s class must not be private", simpleAnnotationName);
+            type, "[AutoValuePrivate] @%s class must not be private", simpleAnnotationName);
       } else if (Visibility.effectiveVisibilityOfElement(type).equals(Visibility.PRIVATE)) {
         // The previous case, where the class itself is private, is much commoner so it deserves
         // its own error message, even though it would be caught by the test here too.
         errorReporter.abortWithError(
-            type, "@%s class must not be nested in a private class", simpleAnnotationName);
+            type,
+            "[AutoValueInPrivate] @%s class must not be nested in a private class",
+            simpleAnnotationName);
       }
       if (!type.getModifiers().contains(Modifier.STATIC)) {
         errorReporter.abortWithError(
-            type, "Nested @%s class must be static", simpleAnnotationName);
+            type, "[AutoValueInner] Nested @%s class must be static", simpleAnnotationName);
       }
     }
     // In principle type.getEnclosingElement() could be an ExecutableElement (for a class
@@ -766,13 +777,14 @@ boolean propertiesCanBeVoid() {
   final void checkReturnType(TypeElement autoValueClass, ExecutableElement getter) {
     TypeMirror type = getter.getReturnType();
     if (type.getKind() == TypeKind.ARRAY) {
-      TypeMirror componentType = ((ArrayType) type).getComponentType();
-      if (componentType.getKind().isPrimitive()) {
+      TypeMirror componentType = MoreTypes.asArray(type).getComponentType();
+     if (componentType.getKind().isPrimitive()) {
         warnAboutPrimitiveArrays(autoValueClass, getter);
       } else {
         errorReporter.reportError(
             getter,
-            "An @%s class cannot define an array-valued property unless it is a primitive array",
+            "[AutoValueArray] An @%s class cannot define an array-valued property unless it is a"
+                + " primitive array",
             simpleAnnotationName);
       }
     }
@@ -799,10 +811,11 @@ private void warnAboutPrimitiveArrays(TypeElement autoValueClass, ExecutableElem
       String context = sameClass ? "" : (" Method: " + getter.getEnclosingElement() + "." + getter);
       errorReporter.reportWarning(
           element,
-          "An @%s property that is a primitive array returns the original array, which can"
-              + " therefore be modified by the caller. If this is OK, you can suppress this warning"
-              + " with @SuppressWarnings(\"mutable\"). Otherwise, you should replace the property"
-              + " with an immutable type, perhaps a simple wrapper around the original array.%s",
+          "[AutoValueMutable] An @%s property that is a primitive array returns the original"
+              + " array, which can therefore be modified by the caller. If this is OK, you can"
+              + " suppress this warning with @SuppressWarnings(\"mutable\"). Otherwise, you should"
+              + " replace the property with an immutable type, perhaps a simple wrapper around the"
+              + " original array.%s",
           simpleAnnotationName,
           context);
     }
@@ -815,8 +828,8 @@ private void warnAboutPrimitiveArrays(TypeElement autoValueClass, ExecutableElem
   private static class ContainsMutableVisitor extends SimpleAnnotationValueVisitor8<Boolean, Void> {
     @Override
     public Boolean visitArray(List<? extends AnnotationValue> list, Void p) {
-      return list.stream().map(av -> av.getValue()).anyMatch("mutable"::equals);
-    }
+      return list.stream().map(AnnotationValue::getValue).anyMatch("mutable"::equals);
+   }
   }
 
   /**
@@ -1102,7 +1115,10 @@ final void writeSourceFile(String className, String text, TypeElement originatin
       // error later because user code will have a reference to the code we were supposed to
       // generate (new AutoValue_Foo() or whatever) and that reference will be undefined.
       errorReporter.reportWarning(
-          originatingType, "Could not write generated class %s: %s", className, e);
+          originatingType,
+          "[AutoValueCouldNotWrite] Could not write generated class %s: %s",
+          className,
+          e);
     }
   }
 }

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

@@ -121,8 +121,8 @@ public synchronized void init(ProcessingEnvironment processingEnv) {
         errorReporter()
             .reportWarning(
                 null,
-                "An exception occurred while looking for AutoValue extensions."
-                    + " No extensions will function.%s\n%s",
+                "[AutoValueExtensionsException] An exception occurred while looking for AutoValue"
+                    + " extensions. No extensions will function.%s\n%s",
                 explain,
                 Throwables.getStackTraceAsString(e));
         extensions = ImmutableList.of();
@@ -170,19 +170,22 @@ void processType(TypeElement type) {
       errorReporter()
           .abortWithError(
               type,
-              "annotation processor for @AutoValue was invoked with a type"
+              "[AutoValueCompilerBug] annotation processor for @AutoValue was invoked with a type"
                   + " that does not have that annotation; this is probably a compiler bug");
     }
     if (type.getKind() != ElementKind.CLASS) {
-      errorReporter().abortWithError(type, "@AutoValue only applies to classes");
+      errorReporter()
+          .abortWithError(type, "[AutoValueNotClass] @AutoValue only applies to classes");
     }
     if (ancestorIsAutoValue(type)) {
-      errorReporter().abortWithError(type, "One @AutoValue class may not extend another");
+      errorReporter()
+          .abortWithError(type, "[AutoValueExtend] One @AutoValue class may not extend another");
     }
     if (implementsAnnotation(type)) {
       errorReporter()
           .abortWithError(
-              type, "@AutoValue may not be used to implement an annotation"
+              type,
+              "[AutoValueImplAnnotation] @AutoValue may not be used to implement an annotation"
                   + " interface; try using @AutoAnnotation instead");
     }
     checkModifiersIfNested(type);
@@ -333,7 +336,8 @@ private ImmutableList<AutoValueExtension> applicableExtensions(
         errorReporter()
             .reportError(
                 type,
-                "More than one extension wants to generate the final class: %s",
+                "[AutoValueMultiFinal] More than one extension wants to generate the final class:"
+                    + " %s",
                 finalExtensions.stream().map(this::extensionName).collect(joining(", ")));
         break;
     }
@@ -355,7 +359,8 @@ private ImmutableSet<ExecutableElement> methodsConsumedByExtensions(
           errorReporter()
               .reportError(
                   type,
-                  "Extension %s wants to consume a property that does not exist: %s",
+                  "[AutoValueConsumeNonexist] Extension %s wants to consume a property that does"
+                      + " not exist: %s",
                   extensionName(extension),
                   consumedProperty);
         } else {
@@ -367,8 +372,8 @@ private ImmutableSet<ExecutableElement> methodsConsumedByExtensions(
           errorReporter()
               .reportError(
                   type,
-                  "Extension %s wants to consume a method that is not one of the abstract methods"
-                      + " in this class: %s",
+                  "[AutoValueConsumeNotAbstract] Extension %s wants to consume a method that is"
+                      + " not one of the abstract methods in this class: %s",
                   extensionName(extension),
                   consumedMethod);
         } else {
@@ -379,8 +384,8 @@ private ImmutableSet<ExecutableElement> methodsConsumedByExtensions(
         errorReporter()
             .reportError(
                 repeat,
-                "Extension %s wants to consume a method that was already consumed by another"
-                    + " extension",
+                "[AutoValueMultiConsume] Extension %s wants to consume a method that was already"
+                    + " consumed by another extension",
                 extensionName(extension));
       }
       consumed.addAll(consumedHere);
@@ -404,10 +409,12 @@ && objectMethodToOverride(method) == ObjectMethod.NONE) {
         // another, and therefore leaves us with both an abstract method and the subclass method
         // that overrides it. This shows up in AutoValueTest.LukesBase for example.
         String extensionMessage = extensionsPresent ? ", and no extension consumed it" : "";
-        errorReporter().reportWarning(
-            method,
-            "Abstract method is neither a property getter nor a Builder converter%s",
-            extensionMessage);
+        errorReporter()
+            .reportWarning(
+                method,
+                "[AutoValueBuilderWhat] Abstract method is neither a property getter nor a Builder"
+                    + " converter%s",
+                extensionMessage);
       }
     }
     errorReporter().abortIfAnyError();