Booleans should be zero.

Author: wasabii

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

@@ -57,28 +57,23 @@ private List<JCTree.JCStatement> generateDefaultStaticFieldAssignments(JCTree.JC
             return statements.toList();
         }
 
-        // Assign default values to static fields WITHOUT initializers:
-        // 1. static non-final fields without initializers
-        // 2. static final fields without initializers (must assign in static {} block)
-        // Do NOT assign to any static fields that already have initializers
+        // Assign defaults to static fields without initializers.
+        // Skip fields that have initializers - they are already assigned and shouldn't be reassigned.
         for (JCTree def : classTree.defs) {
             if (def instanceof JCTree.JCVariableDecl) {
                 JCTree.JCVariableDecl varDecl = (JCTree.JCVariableDecl) def;
                 boolean isStatic = (varDecl.mods.flags & Flags.STATIC) != 0;
 
-                // Only process static fields
                 if (!isStatic) {
                     continue;
                 }
 
                 boolean hasInitializer = varDecl.init != null;
 
-                // Skip any field that already has an initializer
                 if (hasInitializer) {
                     continue;
                 }
 
-                // Assign default to static fields without initializers
                 JCTree.JCExpression defaultValue = generateDefaultValue(varDecl.vartype);
                 JCTree.JCAssign assignment = maker.Assign(
                     maker.Ident(varDecl.name),
@@ -98,7 +93,8 @@ private JCTree.JCExpression generateDefaultValue(JCTree.JCExpression typeExpr) {
             || "float".equals(typeStr) || "double".equals(typeStr)) {
             return maker.Literal(TypeTag.INT, 0);
         } else if ("boolean".equals(typeStr)) {
-            return maker.Literal(TypeTag.BOOLEAN, Boolean.FALSE);
+            // javac expects boolean literals as numeric payload (0/1) for TypeTag.BOOLEAN
+            return maker.Literal(TypeTag.BOOLEAN, 0);
         } else if ("char".equals(typeStr)) {
             return maker.Literal(TypeTag.CHAR, 0);
         }

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

@@ -1,6 +1,7 @@
 package org.ikvm.javarefplugin;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -481,4 +482,77 @@ void staticInitializerOptimizationHandlesAllFieldTypes() throws Exception {
         assertTrue(mutableFailure.getCause() instanceof NullPointerException);
     }
 
+    @Test
+    void staticFieldsAllCombinations() throws Exception {
+        Map<String, String> sources = new LinkedHashMap<>();
+        sources.put(
+            "example/AllStaticFields.java",
+            joinLines(
+                "package example;",
+                "",
+                "public class AllStaticFields {",
+                "    // static final WITH initializer - should NOT be reassigned",
+                "    static final long WITH_INIT_FINAL = 42L;",
+                "",
+                "    // static final WITHOUT initializer - MUST be assigned",
+                "    static final String WITHOUT_INIT_FINAL;",
+                "",
+                "    // static non-final WITH initializer - should NOT be reassigned?",
+                "    static int WITH_INIT_MUTABLE = 100;",
+                "",
+                "    // static non-final WITHOUT initializer - should be assigned to 0",
+                "    static int WITHOUT_INIT_MUTABLE;",
+                "",
+                "    static {",
+                "        WITHOUT_INIT_FINAL = \"initialized\";",
+                "        WITHOUT_INIT_MUTABLE = 200;",
+                "    }",
+                "",
+                "    public static void dummy() { }",
+                "}"
+            )
+        );
+
+        // Just verify the plugin can compile this without errors
+        CompilationResult result = compile(sources);
+        assertNotNull(result.loadClass("example.AllStaticFields"));
+    }
+
+    @Test
+    void staticBooleanFieldsCombinationsAreHandled() throws Exception {
+        Map<String, String> sources = new LinkedHashMap<>();
+        sources.put(
+            "example/StaticBooleanFields.java",
+            joinLines(
+                "package example;",
+                "",
+                "public class StaticBooleanFields {",
+                "    static final boolean WITH_INIT_FINAL = true;",
+                "    static final boolean WITHOUT_INIT_FINAL;",
+                "    static boolean WITH_INIT_MUTABLE = true;",
+                "    static boolean WITHOUT_INIT_MUTABLE;",
+                "",
+                "    static {",
+                "        WITHOUT_INIT_FINAL = true;",
+                "        WITHOUT_INIT_MUTABLE = true;",
+                "    }",
+                "}"
+            )
+        );
+
+        CompilationResult result = compile(sources);
+        Class<?> type = result.loadClass("example.StaticBooleanFields");
+
+        assertTrue(getStaticBoolean(type, "WITH_INIT_FINAL"));
+        assertFalse(getStaticBoolean(type, "WITHOUT_INIT_FINAL"));
+        assertTrue(getStaticBoolean(type, "WITH_INIT_MUTABLE"));
+        assertFalse(getStaticBoolean(type, "WITHOUT_INIT_MUTABLE"));
+    }
+
+    private static boolean getStaticBoolean(Class<?> type, String fieldName) throws Exception {
+        java.lang.reflect.Field field = type.getDeclaredField(fieldName);
+        field.setAccessible(true);
+        return field.getBoolean(null);
+    }
+
 }