Handle enum reordering in ClassInitPlugin

Author: skybber

hotswap-agent-core/src/main/java/org/hotswap/agent/plugin/jvm/ClassInitPlugin.java

@@ -21,6 +21,8 @@
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
 
 import org.hotswap.agent.annotation.LoadEvent;
 import org.hotswap.agent.annotation.OnClassLoadEvent;
@@ -70,6 +72,11 @@ public static void patch(final CtClass ctClass, final ClassLoader classLoader, f
             // swallow
         }
 
+        final boolean enumReordered = isEnumReordered(ctClass, originalClass);
+        if (enumReordered) {
+            LOGGER.debug("Enum order changed for {} -> will reinitialize enum constant fields.", className);
+        }
+
         CtConstructor clinit = ctClass.getClassInitializer();
 
         if (clinit != null) {
@@ -102,11 +109,17 @@ public void edit(FieldAccess f) throws CannotCompileException {
                                         if (reinitializeStatics[0]) {
                                             LOGGER.debug("New field will be initialized {}", f.getFieldName());
                                         } else {
-                                            reinitializeStatics[0] = checkOldEnumValues(ctClass, originalClass);
+                                            if (enumReordered) {
+                                                reinitializeStatics[0] = true;
+                                            } else {
+                                                reinitializeStatics[0] = checkOldEnumValues(ctClass, originalClass);
+                                            }
                                         }
                                     } else {
-                                        LOGGER.debug("Skipping old field {}", f.getFieldName());
-                                        f.replace("{}");
+                                        if (!originalField.isEnumConstant() || !enumReordered) {
+                                            LOGGER.debug("Skipping old field {}", f.getFieldName());
+                                            f.replace("{}");
+                                        }
                                     }
                                 }
                             }
@@ -165,11 +178,47 @@ private static boolean checkOldEnumValues(CtClass ctClass, Class<?> originalClas
         return false;
     }
 
+    private static boolean isEnumReordered(CtClass ctClass, Class<?> originalClass) {
+        if (!ctClass.isEnum() || originalClass == null || !originalClass.isEnum()) {
+            return false;
+        }
+
+        // Old order from runtime (original class)
+        Enum<?>[] oldConsts = (Enum<?>[]) originalClass.getEnumConstants();
+        List<String> oldOrder = new ArrayList<>();
+        for (Enum<?> e : oldConsts) {
+            oldOrder.add(e.name());
+        }
+
+        List<String> newOrder = new ArrayList<>();
+        try {
+            for (CtField f : ctClass.getDeclaredFields()) {
+                int mod = f.getModifiers();
+                boolean looksLikeConst = Modifier.isStatic(mod) && Modifier.isFinal(mod) && f.getType().getName().equals(ctClass.getName());
+                if (looksLikeConst) {
+                    newOrder.add(f.getName());
+                }
+            }
+        } catch (NotFoundException ex) {
+            return true;
+        }
+
+        for (int i = 0; i < newOrder.size() && i < oldOrder.size(); i++) {
+            if (!newOrder.get(i).equals(oldOrder.get(i))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
     private static boolean isSyntheticClass(Class<?> classBeingRedefined) {
         return classBeingRedefined.getSimpleName().contains("$$_javassist")
                 || classBeingRedefined.getSimpleName().contains("$$_jvst")
                 || classBeingRedefined.getName().startsWith("com.sun.proxy.$Proxy")
                 || classBeingRedefined.getSimpleName().contains("$$");
     }
 
+
 }

hotswap-agent-core/src/test/java/org/hotswap/agent/plugin/jvm/classinit/ClassInitTest.java

@@ -26,7 +26,6 @@
 import org.hotswap.agent.plugin.jvm.ClassInitPlugin;
 import org.hotswap.agent.util.ReflectionHelper;
 import org.hotswap.agent.util.test.WaitHelper;
-import org.junit.Test;
 
 public class ClassInitTest {
 
@@ -50,11 +49,25 @@ public void testStatic1() throws Exception {
     public void testEnumAddRemove() throws Exception {
         Enum1 enum1 = Enum1.ITEM_1;
         ClassInitPlugin.reloadFlag = true;
-        int lenEnum1 = Enum1.values().length;
+
+        int ordinal = 0;
+        for (Enum1 e : Enum1.values()) {
+            System.out.printf("%s: 0x%08x%n", e.name(), System.identityHashCode(e));
+            assertEquals(ordinal, e.ordinal());
+            ordinal++;
+        }
 
         swapClasses(Enum1.class, Enum2.class.getName());
 
         assertEquals(enum1.values().length, Enum2.values().length);
+        assertEquals(Enum1.class.getEnumConstants().length, Enum2.class.getEnumConstants().length);
+
+        ordinal = 0;
+        for (Enum1 e : Enum1.values()) {
+            System.out.printf("%s: 0x%08x%n", e.name(), System.identityHashCode(e));
+            assertEquals(ordinal, e.ordinal());
+            ordinal++;
+        }
 
         assertEquals(ReflectionHelper.get(enum1, "ITEM_1"), enum1); // new ITEM_1 is same instance like enum1
 
@@ -79,18 +92,26 @@ public void testEnumAddRemove() throws Exception {
 
 //    @Test
     public void testEnumRemove() throws Exception {
-        Enum3 enum1 = Enum3.ITEM_1;
-        Enum3 enum3 = Enum3.ITEM_3;
+        ClassInitPlugin.reloadFlag = true;
 
-        int lenEnum4 = Enum4.values().length;
+        int ordinal = 0;
+        for (Enum3 e : Enum3.values()) {
+            System.out.printf("%s: 0x%08x%n", e.name(), System.identityHashCode(e));
+            assertEquals(ordinal, e.ordinal());
+            ordinal++;
+        }
 
-        ClassInitPlugin.reloadFlag = true;
         swapClasses(Enum3.class, Enum4.class.getName());
 
-        assertEquals(Enum3.values().length, lenEnum4);
+        assertEquals(Enum3.values().length, Enum4.values().length);
+        assertEquals(Enum3.class.getEnumConstants().length, Enum4.class.getEnumConstants().length);
 
-        assertEquals(Enum3.values()[0], enum1); // must be kept from  original
-        assertEquals(Enum3.values()[1], enum3); // must be kept and shifted
+        ordinal = 0;
+        for (Enum3 e : Enum3.values()) {
+            System.out.printf("%s: 0x%08x%n", e.name(), System.identityHashCode(e));
+            assertEquals(ordinal, e.ordinal());
+            ordinal++;
+        }
     }
 
     private void swapClasses(Class<?> cls1, String class2Name) throws Exception {