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,14 @@ public String[] findEnumValues(Class<?> enumType, Enum<?>[] enumValues, String[]
         return names;
     }
 
+    /**
+     * @since 2.15
+     */
+    public String[] findEnumValues(MapperConfig<?> config, 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 +1176,14 @@ public void findEnumAliases(Class<?> enumType, Enum<?>[] enumValues, String[][]
         ;
     }
 
+
+    /**
+     * @since 2.15
+     */
+    public void findEnumAliases(MapperConfig<?> config, 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,8 +1704,7 @@ 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())
                 );
@@ -1914,7 +1913,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 +2411,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

@@ -124,6 +124,9 @@ private void _addFieldMixIns(Class<?> mixInCls, Class<?> targetClass,
 
     private boolean _isIncludableField(Field f)
     {
+        if (f.isEnumConstant()) {
+            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/AnnotationIntrospectorPair.java

@@ -657,13 +657,28 @@ public  String[] findEnumValues(Class<?> enumType, Enum<?>[] enumValues, String[
         return names;
     }
 
+    @Override
+    public String[] findEnumValues(MapperConfig<?> config, Class<?> enumType, Enum<?>[] enumValues,
+                                   String[] names, AnnotatedClass annotatedClass) {
+        names = _secondary.findEnumValues(config, enumType, enumValues, names, annotatedClass);
+        names = _primary.findEnumValues(config, enumType, enumValues, names, annotatedClass);
+        return names;
+    }
+
     @Override
     public void findEnumAliases(Class<?> enumType, Enum<?>[] enumValues, String[][] aliases) {
         // reverse order to give _primary higher precedence
         _secondary.findEnumAliases(enumType, enumValues, aliases);
         _primary.findEnumAliases(enumType, enumValues, aliases);
     }
 
+    @Override
+    public void findEnumAliases(MapperConfig<?> config, Class<Enum<?>> enumCls, Enum<?>[] enumConstants,
+                                String[][] allAliases, AnnotatedClass annotatedClass) {
+        _secondary.findEnumAliases(config, enumCls, enumConstants, allAliases, annotatedClass);
+        _primary.findEnumAliases(config, enumCls, enumConstants, allAliases, annotatedClass);
+    }
+
     @Override
     public Enum<?> findDefaultEnumValue(Class<Enum<?>> enumCls) {
         Enum<?> en = _primary.findDefaultEnumValue(enumCls);

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(MapperConfig<?> config, 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(MapperConfig<?> config, 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/ser/BeanSerializerFactory.java

@@ -2,10 +2,7 @@
 
 import java.util.*;
 
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.annotation.JsonIncludeProperties;
-import com.fasterxml.jackson.annotation.ObjectIdGenerator;
-import com.fasterxml.jackson.annotation.ObjectIdGenerators;
+import com.fasterxml.jackson.annotation.*;
 import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.JsonParser;
 import com.fasterxml.jackson.core.TokenStreamFactory;
@@ -601,6 +598,7 @@ protected List<BeanPropertyWriter> findBeanProperties(SerializerProvider prov,
 
         // ignore specified types
         removeIgnorableTypes(config, beanDesc, properties);
+        removeEnumsWithObjectShape(config, beanDesc, properties);
 
         // and possibly remove ones without matching mutator...
         if (config.isEnabled(MapperFeature.REQUIRE_SETTERS_FOR_GETTERS)) {
@@ -616,6 +614,7 @@ protected List<BeanPropertyWriter> findBeanProperties(SerializerProvider prov,
         PropertyBuilder pb = constructPropertyBuilder(config, beanDesc);
 
         ArrayList<BeanPropertyWriter> result = new ArrayList<BeanPropertyWriter>(properties.size());
+        // We do not want to include enums as self vlues in the first place.
         for (BeanPropertyDefinition property : properties) {
             final AnnotatedMember accessor = property.getAccessor();
             // Type id? Requires special handling:
@@ -639,6 +638,27 @@ protected List<BeanPropertyWriter> findBeanProperties(SerializerProvider prov,
         return result;
     }
 
+    /**
+     * @since 2.15
+     */
+    protected void removeEnumsWithObjectShape(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyDefinition> properties) {
+        AnnotationIntrospector ai = config.getAnnotationIntrospector();
+        JavaType type = beanDesc.getType();
+        JsonFormat.Value format = ai.findFormat(beanDesc.getClassInfo());
+
+        // If type is enum, BUT serialized as an object...
+        if (type.isEnumType() && format != null && format.getShape() == JsonFormat.Shape.OBJECT) {
+            Iterator<BeanPropertyDefinition> it = properties.iterator();
+            while (it.hasNext()) {
+                BeanPropertyDefinition property = it.next();
+                // Remove self(enum)
+                if (type.isTypeOrSubTypeOf(property.getRawPrimaryType())) {
+                    it.remove();
+                }
+            }
+        }
+    }
+
     /*
     /**********************************************************
     /* Overridable non-public methods for manipulating bean properties

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,50 @@ 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(config, enumCls, enumConstants, new String[enumConstants.length], annotatedClass);
+
+        final String[][] allAliases = new String[names.length][];
+        ai.findEnumAliases(config, 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
      */