Handle Enum introspection of values and aliases via AnnotatedClass instead of Class<?>

src/main/java/com/fasterxml/jackson/databind/AnnotationIntrospector.java

@@ -39,6 +39,7 @@
 public abstract class AnnotationIntrospector
     implements Versioned, java.io.Serializable
 {
+
     /*
     /**********************************************************************
     /* Helper types
@@ -1149,6 +1150,13 @@ public String[] findEnumValues(Class<?> enumType, Enum<?>[] enumValues, String[]
         return names;
     }
 
+    /**
+     * @since 2.15
+     */
+    public String[] findEnumValues(Class<?> enumType, Enum<?>[] enumValues, String[] names, AnnotatedClass annotatedClass){
+        return names;
+    }
+
     /**
      * Method that is related to {@link #findEnumValues} but is called to check if
      * there are alternative names (aliased) that can be accepted for entries, in
@@ -1167,6 +1175,13 @@ public void findEnumAliases(Class<?> enumType, Enum<?>[] enumValues, String[][]
         ;
     }
 
+
+    /**
+     * @since 2.15
+     */
+    public void findEnumAliases(Class<Enum<?>> enumCls, Enum<?>[] enumConstants, String[][] allAliases, AnnotatedClass annotatedClass) {
+        ;
+    }
     /**
      * Finds the Enum value that should be considered the default value, if possible.
      *

src/main/java/com/fasterxml/jackson/databind/deser/BasicDeserializerFactory.java

@@ -1704,11 +1704,9 @@ public JsonDeserializer<?> createEnumDeserializer(DeserializationContext ctxt,
 
             // Need to consider @JsonValue if one found
             if (deser == null) {
-                deser = new EnumDeserializer(constructEnumResolver(enumClass,
-                        config, beanDesc.findJsonValueAccessor()),
+                deser = new EnumDeserializer(constructEnumResolver(enumClass, config, beanDesc),
                         config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS),
-                        constructEnumNamingStrategyResolver(config, enumClass, beanDesc.getClassInfo())
-                );
+                        constructEnumNamingStrategyResolver(config, enumClass, beanDesc.getClassInfo()));
             }
         }
 
@@ -1914,7 +1912,7 @@ private KeyDeserializer _createEnumKeyDeserializer(DeserializationContext ctxt,
                 return StdKeyDeserializers.constructDelegatingKeyDeserializer(config, type, valueDesForKey);
             }
         }
-        EnumResolver enumRes = constructEnumResolver(enumClass, config, beanDesc.findJsonValueAccessor());
+        EnumResolver enumRes = constructEnumResolver(enumClass, config, beanDesc);
         EnumResolver byEnumNamingResolver = constructEnumNamingStrategyResolver(config, enumClass, beanDesc.getClassInfo());
 
         // May have @JsonCreator for static factory method
@@ -2412,18 +2410,17 @@ protected JavaType resolveMemberAndTypeAnnotations(DeserializationContext ctxt,
     }
 
     protected EnumResolver constructEnumResolver(Class<?> enumClass,
-            DeserializationConfig config, AnnotatedMember jsonValueAccessor)
+            DeserializationConfig config, BeanDescription beanDesc)
     {
+        AnnotatedMember jsonValueAccessor = beanDesc.findJsonValueAccessor();
         if (jsonValueAccessor != null) {
             if (config.canOverrideAccessModifiers()) {
                 ClassUtil.checkAndFixAccess(jsonValueAccessor.getMember(),
                         config.isEnabled(MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS));
             }
             return EnumResolver.constructUsingMethod(config, enumClass, jsonValueAccessor);
         }
-        // 14-Mar-2016, tatu: We used to check `DeserializationFeature.READ_ENUMS_USING_TO_STRING`
-        //   here, but that won't do: it must be dynamically changeable...
-        return EnumResolver.constructFor(config, enumClass);
+        return EnumResolver.constructFor(config, enumClass, beanDesc.getClassInfo());
     }
 
     /**

src/main/java/com/fasterxml/jackson/databind/introspect/AnnotatedFieldCollector.java

@@ -4,6 +4,7 @@
 import java.lang.reflect.Modifier;
 import java.util.*;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.databind.AnnotationIntrospector;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver;
@@ -70,9 +71,12 @@ private Map<String,FieldBuilder> _findFields(TypeResolutionContext tc,
         // Let's add super-class' fields first, then ours.
         fields = _findFields(new TypeResolutionContext.Basic(_typeFactory, parent.getBindings()),
                 parent, fields);
+
+        JsonFormat format = cls.getAnnotation(JsonFormat.class);
+        boolean isHandledAsObject = format != null && format.shape() == JsonFormat.Shape.OBJECT;
         for (Field f : cls.getDeclaredFields()) {
             // static fields not included (transients are at this point, filtered out later)
-            if (!_isIncludableField(f)) {
+            if (!_isIncludableField(f, isHandledAsObject)) {
                 continue;
             }
             // Ok now: we can (and need) not filter out ignorable fields at this point; partly
@@ -91,7 +95,7 @@ private Map<String,FieldBuilder> _findFields(TypeResolutionContext tc,
         if ((fields != null) && (_mixInResolver != null)) {
             Class<?> mixin = _mixInResolver.findMixInClassFor(cls);
             if (mixin != null) {
-                _addFieldMixIns(mixin, cls, fields);
+                _addFieldMixIns(mixin, cls, fields, isHandledAsObject);
             }
         }
         return fields;
@@ -103,13 +107,13 @@ private Map<String,FieldBuilder> _findFields(TypeResolutionContext tc,
      * super-classes)
      */
     private void _addFieldMixIns(Class<?> mixInCls, Class<?> targetClass,
-            Map<String,FieldBuilder> fields)
+             Map<String,FieldBuilder> fields, boolean isHandledAsObject)
     {
         List<Class<?>> parents = ClassUtil.findSuperClasses(mixInCls, targetClass, true);
         for (Class<?> mixin : parents) {
             for (Field mixinField : mixin.getDeclaredFields()) {
                 // there are some dummy things (static, synthetic); better ignore
-                if (!_isIncludableField(mixinField)) {
+                if (!_isIncludableField(mixinField, isHandledAsObject)) {
                     continue;
                 }
                 String name = mixinField.getName();
@@ -122,8 +126,11 @@ private void _addFieldMixIns(Class<?> mixInCls, Class<?> targetClass,
         }
     }
 
-    private boolean _isIncludableField(Field f)
+    private boolean _isIncludableField(Field f, boolean isHandledAsObject)
     {
+        if (f.isEnumConstant() && !isHandledAsObject) {
+            return true;
+        }
         // Most likely synthetic fields, if any, are to be skipped similar to methods
         if (f.isSynthetic()) {
             return false;

src/main/java/com/fasterxml/jackson/databind/introspect/JacksonAnnotationIntrospector.java

@@ -240,6 +240,44 @@ public String[] findEnumValues(Class<?> enumType, Enum<?>[] enumValues, String[]
         return names;
     }
 
+    @Override // since 2.15
+    public String[] findEnumValues(Class<?> enumType, Enum<?>[] enumValues, String[] names, AnnotatedClass annotatedClass) {
+        HashMap<String, String> enumToPropertyMap = new HashMap<>();
+        for (AnnotatedField field : annotatedClass._fields) {
+            JsonProperty property = field.getAnnotation(JsonProperty.class);
+            if (property != null) {
+                enumToPropertyMap.put(field.getName(), property.value());
+            }
+        }
+
+        HashMap<String,String> expl = null;
+        for (Field f : enumType.getDeclaredFields()) {
+            if (!f.isEnumConstant()) {
+                continue;
+            }
+
+            String n = enumToPropertyMap.get(f.getName());
+            if (n == null || n.isEmpty()) {
+                continue;
+            }
+            if (expl == null) {
+                expl = new HashMap<String,String>();
+            }
+            expl.put(f.getName(), n);
+        }
+        // and then stitch them together if and as necessary
+        if (expl != null) {
+            for (int i = 0, end = enumValues.length; i < end; ++i) {
+                String defName = enumValues[i].name();
+                String explValue = expl.get(defName);
+                if (explValue != null) {
+                    names[i] = explValue;
+                }
+            }
+        }
+        return names;
+    }
+
     @Override // since 2.11
     public void findEnumAliases(Class<?> enumType, Enum<?>[] enumValues, String[][] aliasList)
     {
@@ -264,6 +302,23 @@ public void findEnumAliases(Class<?> enumType, Enum<?>[] enumValues, String[][]
         }
     }
 
+    @Override // 2.15
+    public void findEnumAliases(Class<Enum<?>> enumType, Enum<?>[] enumValues, String[][] aliasList, AnnotatedClass annotatedClass)
+    {
+        HashMap<String, String[]> enumToAliasMap = new HashMap<>();
+        for (AnnotatedField field : annotatedClass._fields) {
+            JsonAlias alias = field.getAnnotation(JsonAlias.class);
+            if (alias != null) {
+                enumToAliasMap.putIfAbsent(field.getName(), alias.value());
+            }
+        }
+
+        for (int i = 0, end = enumValues.length; i < end; ++i) {
+            Enum<?> enumValue = enumValues[i];
+            aliasList[i] = enumToAliasMap.getOrDefault(enumValue.name(), new String[]{});
+        }
+    }
+
     /**
      * Finds the Enum value that should be considered the default value, if possible.
      * <p>

src/main/java/com/fasterxml/jackson/databind/util/EnumResolver.java

@@ -2,11 +2,12 @@
 
 import java.util.*;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.AnnotationIntrospector;
 import com.fasterxml.jackson.databind.DeserializationConfig;
 import com.fasterxml.jackson.databind.MapperFeature;
 import com.fasterxml.jackson.databind.EnumNamingStrategy;
-import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
+import com.fasterxml.jackson.databind.introspect.*;
 
 /**
  * Helper class used to resolve String values (either JSON Object field
@@ -80,6 +81,49 @@ public static EnumResolver constructFor(DeserializationConfig config,
                 config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS));
     }
 
+    /**
+     * @since 2.15
+     */
+    public static EnumResolver constructFor(DeserializationConfig config, Class<?> enumCls0, AnnotatedClass annotatedClass) {
+        return _constructFor(config, enumCls0, annotatedClass, config.getAnnotationIntrospector(),
+            config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS));
+    }
+    /**
+     * @since 2.15
+     */
+    public static EnumResolver _constructFor(DeserializationConfig config, Class<?> enumCls0,
+                                             AnnotatedClass annotatedClass, AnnotationIntrospector ai, boolean isIgnoreCase)
+    {
+        final Class<Enum<?>> enumCls = _enumClass(enumCls0);
+        final Enum<?>[] enumConstants = _enumConstants(enumCls0);
+        String[] names = ai.findEnumValues(enumCls, enumConstants, new String[enumConstants.length], annotatedClass);
+
+        final String[][] allAliases = new String[names.length][];
+        ai.findEnumAliases(enumCls, enumConstants, allAliases, annotatedClass);
+
+        HashMap<String, Enum<?>> map = new HashMap<String, Enum<?>>();
+        for (int i = 0, len = enumConstants.length; i < len; ++i) {
+            final Enum<?> enumValue = enumConstants[i];
+
+            String name = names[i];
+            if (name == null) {
+                name = enumValue.name();
+            }
+            map.put(name, enumValue);
+
+            String[] aliases = allAliases[i];
+            if (aliases != null) {
+                for (String alias : aliases) {
+                    // Avoid overriding any primary names
+                    map.putIfAbsent(alias, enumValue);
+                }
+            }
+        }
+        return new EnumResolver(enumCls, enumConstants, map,
+            _enumDefault(ai, enumCls), isIgnoreCase,
+            false);
+    }
+
     /**
      * @since 2.12
      */