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

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

@@ -1089,6 +1089,26 @@ public String[] findEnumValues(Class<?> enumType, Enum<?>[] enumValues, String[]
         return names;
     }
 
+    /**
+     * Finds the explicitly defined name of the given set of {@code Enum} values, if any.
+     * The method overwrites entries in the incoming {@code names} array with the explicit
+     * names found, if any, leaving other entries unmodified.
+     *
+     * @param config the mapper configuration to use
+     * @param enumValues the set of {@code Enum} values to find the explicit names for
+     * @param names the matching declared names of enumeration values (with indexes matching
+     *              {@code enumValues} entries)
+     * @param annotatedClass the annotated class for which to find the explicit names
+     *
+     * @return an array of names to use (possibly {@code names} passed as argument)
+     *
+     * @since 2.16
+     */
+    public String[] findEnumValues(MapperConfig<?> config, 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
@@ -1107,6 +1127,25 @@ public void findEnumAliases(Class<?> enumType, Enum<?>[] enumValues, String[][]
         ;
     }
 
+
+    /**
+     * Method that is called to check if there are alternative names (aliases) that can be accepted for entries
+     * in addition to primary names that were introspected earlier, related to {@link #findEnumValues}.
+     * These aliases should be returned in {@code String[][] aliases} passed in as argument. 
+     * The {@code aliases.length} is expected to match the number of {@code Enum} values.
+     *
+     * @param config The configuration of the mapper
+     * @param enumValues The values of the enumeration
+     * @param aliases (in/out) Pre-allocated array where aliases found, if any, may be added (in indexes
+     *     matching those of {@code enumValues})
+     * @param annotatedClass The annotated class of the enumeration type
+     *
+     * @since 2.16
+     */
+    public void findEnumAliases(MapperConfig<?> config, Enum<?>[] enumValues, String[][] aliases,
+                                AnnotatedClass annotatedClass) {
+        return;
+    }
     /**
      * Finds the Enum value that should be considered the default value, if possible.
      *

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

@@ -2425,9 +2425,7 @@ protected EnumResolver constructEnumResolver(Class<?> enumClass,
             }
             return EnumResolver.constructUsingMethod(config, enumClass, jvAcc);
         }
-        // 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, beanDesc.getClassInfo());
     }
 
     /**

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

@@ -124,6 +124,10 @@ private void _addFieldMixIns(Class<?> mixInCls, Class<?> targetClass,
 
     private boolean _isIncludableField(Field f)
     {
+        // [databind#2787]: Allow `Enum` mixins
+        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

@@ -612,13 +612,28 @@ public  String[] findEnumValues(Class<?> enumType, Enum<?>[] enumValues, String[
         return names;
     }
 
+    @Override
+    public String[] findEnumValues(MapperConfig<?> config, Enum<?>[] enumValues, String[] names,
+                                    AnnotatedClass annotatedClass) {
+        names = _secondary.findEnumValues(config, enumValues, names, annotatedClass);
+        names = _primary.findEnumValues(config, 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, Enum<?>[] enumConstants, String[][] aliases,
+                                    AnnotatedClass annotatedClass) {
+        _secondary.findEnumAliases(config, enumConstants, aliases, annotatedClass);
+        _primary.findEnumAliases(config, enumConstants, aliases, 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,45 @@ public String[] findEnumValues(Class<?> enumType, Enum<?>[] enumValues, String[]
         return names;
     }
 
+    @Override
+    public String[] findEnumValues(MapperConfig<?> config, Enum<?>[] enumValues, String[] names,
+                                   AnnotatedClass annotatedClass) {
+        // First collect all JsonProperty.value()
+        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());
+            }
+        }
+        final Class<?> enumType = annotatedClass.getRawType();
+        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 +303,23 @@ public void findEnumAliases(Class<?> enumType, Enum<?>[] enumValues, String[][]
         }
     }
 
+    @Override
+    public void findEnumAliases(MapperConfig<?> config, 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/BasicSerializerFactory.java

@@ -1209,6 +1209,10 @@ protected JsonSerializer<?> buildEnumSerializer(SerializationConfig config,
         if (format.getShape() == JsonFormat.Shape.OBJECT) {
             // one special case: suppress serialization of "getDeclaringClass()"...
             ((BasicBeanDescription) beanDesc).removeProperty("declaringClass");
+            // [databind#2787]: remove self-referencing enum fields introduced by annotation flattening of mixins
+            if (type.isEnumType()){
+                _removeEnumSelfReferences(((BasicBeanDescription) beanDesc));
+            }
             // returning null will mean that eventually BeanSerializer gets constructed
             return null;
         }
@@ -1224,6 +1228,30 @@ protected JsonSerializer<?> buildEnumSerializer(SerializationConfig config,
         return ser;
     }
 
+    /**
+     * Helper method used in the serialization of an {@link Enum} to remove any self-referencing properties from 
+     * the bean description before it is transformed into a JSON Object as configured by {@link JsonFormat.Shape#OBJECT}.
+     * <p>
+     * Basically, this method iterates through the properties of the bean description and removes any that are
+     * an enum type and a subtype of the enum class to be serialized.
+     *
+     * @param beanDesc the bean description to remove Enum properties from.
+     *
+     * @since 2.16 : [databind#2787]: remove self-referencing enum fields introduced by annotation flattening of mixins 
+     */
+    private void _removeEnumSelfReferences(BasicBeanDescription beanDesc) {
+        Class<?> aClass = ClassUtil.findEnumType(beanDesc.getBeanClass());
+        Iterator<BeanPropertyDefinition> it = beanDesc.findProperties().iterator();
+        while (it.hasNext()) {
+            BeanPropertyDefinition property = it.next();
+            // Remove enums, because they are self-referenced
+            JavaType propType = property.getPrimaryType();
+            if (propType.isEnumType() && propType.isTypeOrSubTypeOf(aClass)) {
+                it.remove();
+            }
+        }
+    }
+
     /*
     /**********************************************************
     /* Other helper methods

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

@@ -8,6 +8,7 @@
 import com.fasterxml.jackson.databind.EnumNamingStrategy;
 import com.fasterxml.jackson.databind.cfg.MapperConfig;
 import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
+import com.fasterxml.jackson.databind.introspect.AnnotatedClass;
 
 /**
  * Helper class used to resolve String values (either JSON Object field
@@ -76,6 +77,7 @@ protected EnumResolver(Class<Enum<?>> enumClass, Enum<?>[] enums,
      * Enum value.
      *
      * @since 2.12
+     * @deprecated Since 2.16 use {@link #constructFor(DeserializationConfig, Class)} instead
      */
     public static EnumResolver constructFor(DeserializationConfig config,
             Class<?> enumCls) {
@@ -115,6 +117,60 @@ protected static EnumResolver _constructFor(DeserializationConfig config, Class<
                 false);
     }
 
+    /**
+     * Factory method for constructing an {@link EnumResolver} based on the given {@link DeserializationConfig} and
+     * {@link AnnotatedClass} of the enum to be resolved.
+     *
+     * @param config the deserialization configuration to use
+     * @param annotatedClass the annotated class of the enum to be resolved
+     * @return the constructed {@link EnumResolver}
+     *
+     * @since 2.16
+     */
+    public static EnumResolver constructFor(DeserializationConfig config, AnnotatedClass annotatedClass) {
+        return _constructFor(config, annotatedClass);
+    }
+
+    /**
+     * Internal method for {@link #_constructFor(DeserializationConfig, AnnotatedClass)}.
+     *
+     * @since 2.16
+     */
+    public static EnumResolver _constructFor(DeserializationConfig config, AnnotatedClass annotatedClass)
+    {
+        // prepare data
+        final AnnotationIntrospector ai = config.getAnnotationIntrospector();
+        final boolean isIgnoreCase = config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS);
+        final Class<?> enumCls0 = annotatedClass.getRawType();
+        final Class<Enum<?>> enumCls = _enumClass(enumCls0);
+        final Enum<?>[] enumConstants = _enumConstants(enumCls0);
+
+        // introspect
+        String[] names = ai.findEnumValues(config, enumConstants, new String[enumConstants.length], annotatedClass);
+        final String[][] allAliases = new String[names.length][];
+        ai.findEnumAliases(config, enumConstants, allAliases, annotatedClass);
+
+        // finally, build
+        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);
+    }
+
     /**
      * Factory method for constructing resolver that maps from Enum.toString() into
      * Enum value