Ignore setting values with CONSTANTS.

Author: wasabii

src/main/java/org/ikvm/javarefplugin/MethodBodyStripper.java

@@ -57,11 +57,19 @@ private List<JCTree.JCStatement> generateDefaultFieldAssignments(JCTree.JCClassD
             return statements.toList();
         }
 
-        // Collect all static fields
+        // Collect all static fields that can be safely reassigned
+        // (skip final fields that have an initializer - they have compile-time constant values)
         for (JCTree def : classTree.defs) {
             if (def instanceof JCTree.JCVariableDecl) {
                 JCTree.JCVariableDecl varDecl = (JCTree.JCVariableDecl) def;
                 if ((varDecl.mods.flags & Flags.STATIC) != 0) {
+                    // Skip if final AND has an initializer (compile-time constant)
+                    boolean isFinal = (varDecl.mods.flags & Flags.FINAL) != 0;
+                    boolean hasInitializer = varDecl.init != null;
+                    if (isFinal && hasInitializer) {
+                        continue;  // Skip final fields with initializers
+                    }
+
                     // Generate assignment: field = defaultValue;
                     JCTree.JCExpression defaultValue = generateDefaultValue(varDecl.vartype);
                     JCTree.JCAssign assignment = maker.Assign(

src/test/java/org/ikvm/javarefplugin/JavaRefPluginTest.java

@@ -438,5 +438,47 @@ private CompilationInvocation(CompilationResult result, String output) {
             this.output = output;
         }
     }
-}
 
+    @Test
+    void staticInitializerOptimizationHandlesAllFieldTypes() throws Exception {
+        Map<String, String> sources = new LinkedHashMap<>();
+        sources.put(
+            "example/StaticFieldTypes.java",
+            joinLines(
+                "package example;",
+                "",
+                "public class StaticFieldTypes {",
+                "    static final long CONSTANT = 42L;",
+                "    static final String uninit;",
+                "    static int mutable;",
+                "    static {",
+                "        uninit = \"initialized\";",
+                "        mutable = 100;",
+                "    }",
+                "    public static long getConstant() { return CONSTANT; }",
+                "    public static String getUninit() { return uninit; }",
+                "    public static int getMutable() { return mutable; }",
+                "}"
+            )
+        );
+
+        // Just verify the plugin can compile this without errors
+        // (the key test is that final fields with initializers don't get reassigned)
+        CompilationResult result = compile(sources);
+        Class<?> type = result.loadClass("example.StaticFieldTypes");
+
+        // All methods should be stripped and throw NullPointerException
+        InvocationTargetException constantFailure =
+            assertThrows(InvocationTargetException.class, () -> type.getMethod("getConstant").invoke(null));
+        assertTrue(constantFailure.getCause() instanceof NullPointerException);
+
+        InvocationTargetException uninitFailure =
+            assertThrows(InvocationTargetException.class, () -> type.getMethod("getUninit").invoke(null));
+        assertTrue(uninitFailure.getCause() instanceof NullPointerException);
+
+        InvocationTargetException mutableFailure =
+            assertThrows(InvocationTargetException.class, () -> type.getMethod("getMutable").invoke(null));
+        assertTrue(mutableFailure.getCause() instanceof NullPointerException);
+    }
+
+}