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

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

@@ -1704,11 +1704,18 @@ public JsonDeserializer<?> createEnumDeserializer(DeserializationContext ctxt,
 
             // Need to consider @JsonValue if one found
             if (deser == null) {
-                deser = new EnumDeserializer(constructEnumResolver(enumClass,
-                        config, beanDesc.findJsonValueAccessor()),
+                Class<?> mixInClass = config.findMixInClassFor(enumClass);
+                if (mixInClass == null) {
+                    deser = new EnumDeserializer(
+                        constructEnumResolver(enumClass, config, beanDesc.findJsonValueAccessor()),
                         config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS),
-                        constructEnumNamingStrategyResolver(config, enumClass, beanDesc.getClassInfo())
-                );
+                        constructEnumNamingStrategyResolver(config, enumClass, beanDesc.getClassInfo()));
+                } else {
+                    deser = new EnumDeserializer(
+                        EnumResolver.constructForMixin(config, enumClass, mixInClass),
+                        config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS),
+                        null);
+                }
             }
         }
 

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

@@ -2,6 +2,7 @@
 
 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;
@@ -255,6 +256,112 @@ protected static EnumResolver _constructUsingMethod(Class<?> enumCls0,
         );
     }
 
+
+    /**
+     * Factory method to allow mix-ins for Enum classes. Its implementation regarding overrides
+     * of property names and alias SHOULD work just like POJOs.
+     *
+     * @since 2.15
+     */
+    public static EnumResolver constructForMixin(DeserializationConfig config,
+                                                 Class<?> enumCls, Class<?> mixInCls) {
+        return _constructForMixIn(enumCls, mixInCls, config.getAnnotationIntrospector(),
+            config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS));
+    }
+
+    /**
+     * @since 2.15
+     */
+    protected static EnumResolver _constructForMixIn(Class<?> enumCls0, Class<?> mixInCls0, 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]);
+        final String[][] allAliases = new String[names.length][];
+        ai.findEnumAliases(enumCls, enumConstants, allAliases);
+
+        HashMap<String, String> mixinPropertyMap = _findEnumNameToMixinPropertyMap(ai, mixInCls0);
+        HashMap<String, String> mixinAliasMap = _findEnumNameToMixinAliasMap(ai, mixInCls0);
+
+        HashMap<String, Enum<?>> map = new HashMap<String, Enum<?>>();
+        for (int i = 0, len = enumConstants.length; i < len; ++i) {
+            final Enum<?> enumValue = enumConstants[i];
+
+            // Property
+            String name = names[i];
+            if (name == null) {
+                name = enumValue.name();
+            }
+            if (mixinPropertyMap.get(enumValue.name()) != null) {
+                name = mixinPropertyMap.get(enumValue.name());
+            }
+            map.put(name, enumValue);
+
+            // Alias
+            if (mixinAliasMap.get(enumValue.name()) != null) {
+                map.put(mixinAliasMap.get(enumValue.name()), enumValue);
+            } else {
+                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);
+    }
+
+    /**
+     * @return Map with key as {@link Enum#name()} of mixin Enum class and value as alias.
+     *
+     * @since 2.15
+     */
+    protected static HashMap<String, String> _findEnumNameToMixinAliasMap(AnnotationIntrospector ai, Class<?> mixInCls) {
+        final Class<Enum<?>> enumCls = _enumClass(mixInCls);
+        final Enum<?>[] enumConstants = _enumConstants(mixInCls);
+        String[] names = ai.findEnumValues(enumCls, enumConstants, new String[enumConstants.length]);
+
+        final String[][] allAliases = new String[names.length][];
+        ai.findEnumAliases(enumCls, enumConstants, allAliases);
+
+        HashMap<String, String> map = new HashMap<String, String>();
+        for (int i = 0, len = enumConstants.length; i < len; ++i) {
+            final Enum<?> enumValue = enumConstants[i];
+            String[] aliases = allAliases[i];
+            if (aliases != null) {
+                for (String alias : aliases) {
+                    map.putIfAbsent(enumValue.name(), alias);
+                }
+            }
+        }
+        return map;
+    }
+
+    /**
+     * @return Map with key as {@link Enum#name()} of mixin Enum class and value as property name.
+     *
+     * @since 2.15
+     */
+    protected static HashMap<String, String> _findEnumNameToMixinPropertyMap(AnnotationIntrospector ai, Class<?> mixInCls) {
+        final Class<Enum<?>> enumCls = _enumClass(mixInCls);
+        final Enum<?>[] enumConstants = _enumConstants(mixInCls);
+        String[] names = ai.findEnumValues(enumCls, enumConstants, new String[enumConstants.length]);
+
+        HashMap<String, String> map = new HashMap<String, String>();
+        for (int i = 0, len = enumConstants.length; i < len; ++i) {
+            final Enum<?> enumValue = enumConstants[i];
+            String name = names[i];
+            if (name != null) {
+                map.put(enumValue.name(), name);
+            }
+        }
+        return map;
+    }
+
     public CompactStringObjectMap constructLookup() {
         return CompactStringObjectMap.construct(_enumsById);
     }

src/test/java/com/fasterxml/jackson/databind/deser/enums/EnumDeserMixin2787Test.java

@@ -0,0 +1,135 @@
+package com.fasterxml.jackson.databind.deser.enums;
+
+import com.fasterxml.jackson.annotation.JsonAlias;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.BaseMapTest;
+import com.fasterxml.jackson.databind.MapperFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.exc.InvalidFormatException;
+
+public class EnumDeserMixin2787Test extends BaseMapTest {
+
+    static enum Enum2787 {
+        ITEM_A,
+
+        @JsonAlias({"B_ORIGIN_ALIAS_1", "B_ORIGIN_ALIAS_2"})
+        @JsonProperty("B_ORIGIN_PROP")
+        ITEM_B,
+
+        @JsonAlias({"C_ORIGIN_ALIAS"})
+        @JsonProperty("C_ORIGIN_PROP")
+        ITEM_C,
+
+        ITEM_ORIGIN
+    }
+
+    static enum EnumMixin2787 {
+        ITEM_A,
+
+        @JsonProperty("B_MIXIN_PROP")
+        ITEM_B,
+
+        @JsonAlias({"C_MIXIN_ALIAS_1", "C_MIXIN_ALIAS_2"})
+        @JsonProperty("C_MIXIN_PROP")
+        ITEM_C,
+
+        ITEM_MIXIN;
+
+        @Override
+        public String toString() {
+            return "SHOULD NOT USE WITH TO STRING";
+        }
+    }
+
+    static class EnumWrapper {
+        public Enum2787 value;
+    }
+
+    /*
+    /**********************************************************************
+    /* Test methods
+    /**********************************************************************
+     */
+
+    protected final ObjectMapper MAPPER = jsonMapperBuilder().build();
+
+    public void testEnumDeserSuccess() throws Exception {
+        ObjectMapper mapper = MAPPER.addMixIn(Enum2787.class, EnumMixin2787.class);
+
+        Enum2787 result = mapper.readValue(q("B_MIXIN_PROP"), Enum2787.class);
+
+        assertEquals(Enum2787.ITEM_B, result);
+    }
+
+    public void testEnumDeserSuccessCaseInsensitive() throws Exception {
+        ObjectMapper mapper = MAPPER.addMixIn(Enum2787.class, EnumMixin2787.class)
+            .enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS);
+
+        Enum2787 result = mapper.readValue(q("B_mIxIn_pRoP"), Enum2787.class);
+        assertEquals(Enum2787.ITEM_B, result);
+    }
+
+    public void testEnumDeserSuccessMissingFromMixIn() throws Exception {
+        ObjectMapper mapper = MAPPER.addMixIn(Enum2787.class, EnumMixin2787.class);
+
+        Enum2787 result = mapper.readValue(q("ITEM_ORIGIN"), Enum2787.class);
+
+        assertEquals(Enum2787.ITEM_ORIGIN, result);
+    }
+
+    public void testEnumDeserMixinFail() throws Exception {
+        ObjectMapper mapper = MAPPER.addMixIn(Enum2787.class, EnumMixin2787.class);
+
+        // fail for Bean property name
+        try {
+            mapper.readValue(q("tax10"), Enum2787.class);
+            fail("should not reach");
+        } catch (InvalidFormatException e) {
+            verifyException(e, "tax10", "not one of the values accepted for Enum class");
+        }
+
+        // fail for Bean's JsonProperty because overridden
+        try {
+            mapper.readValue(q("B_ORIGIN_PROP"), Enum2787.class);
+            fail("should not reach");
+        } catch (InvalidFormatException e) {
+            verifyException(e, "B_ORIGIN_PROP", "not one of the values accepted for Enum class");
+        }
+    }
+
+    public void testMixInItselfNonJsonProperty() throws Exception {
+        ObjectMapper mapper = MAPPER.addMixIn(Enum2787.class, EnumMixin2787.class);
+
+        EnumMixin2787 result = mapper.readValue(q("ITEM_MIXIN"), EnumMixin2787.class);
+
+        assertEquals(EnumMixin2787.ITEM_MIXIN, result);
+    }
+
+    public void testMixInValueForTargetClass() throws Exception {
+        ObjectMapper mapper = MAPPER.addMixIn(Enum2787.class, EnumMixin2787.class);
+
+        try {
+            mapper.readValue(q("tax30"), Enum2787.class);
+        } catch (InvalidFormatException e) {
+            verifyException(e, " String \"tax30\": not one of the values accepted for Enum class:");
+        }
+    }
+
+    public void testMixinOnEnumValuesThrowWhenUnknown() throws Exception {
+        ObjectMapper mapper = MAPPER.addMixIn(Enum2787.class, EnumMixin2787.class);
+
+        try {
+            mapper.readValue(q("should-not-exist"), Enum2787.class);
+        } catch (InvalidFormatException e) {
+            verifyException(e, "should-not-exist", "not one of the values accepted for Enum class");
+        }
+    }
+
+    public void testMixinForWrapper() throws Exception{
+        ObjectMapper mapper = MAPPER.addMixIn(Enum2787.class, EnumMixin2787.class);
+
+        EnumWrapper result = mapper.readValue(a2q("{'value': 'C_MIXIN_ALIAS_1'}"), EnumWrapper.class);
+
+        assertEquals(Enum2787.ITEM_C, result.value);
+    }
+}