Rewrite static ctors to set all fields to default value.

wasabii · wasabii · commit acbeb99ab5c3 · 2026-05-31T13:43:09.000-05:00
diff --git a/README.md b/README.md
@@ -14,6 +14,16 @@ org.ikvm:java-ref-plugin
 - Plugin class: `org.ikvm.javarefplugin.JavaRefPlugin`
 - Automatic module name: `org.ikvm.javarefplugin`
 
+## Plugin behavior
+
+The plugin rewrites method bodies to throw `NullPointerException` on invocation:
+
+- **Instance methods**: replaced with `throw null`.
+- **Constructors**: preserved `this()/super()` chaining, then `throw null`.
+- **Static initializers**: replaced with minimal field assignments (sets static fields to type-appropriate defaults: `0`, `false`, or `null`). This drastically reduces bytecode size while ensuring the class loads correctly.
+- **Abstract/native methods**: bodies left unchanged (they have no bodies).
+- **Synthetic bridge methods**: rewritten like regular methods (bridges still exist as method symbols).
+
 ### Plugin arguments
 
 - `ignorePackage=<packageName>`: skips rewriting for classes in the package and its subpackages. Repeat the argument to ignore multiple package roots. Ignored classes are logged as `javac` notices during compilation.
diff --git a/src/main/java/org/ikvm/javarefplugin/MethodBodyStripper.java b/src/main/java/org/ikvm/javarefplugin/MethodBodyStripper.java
@@ -30,11 +30,67 @@ void strip(Object compilationUnit) {
     public void visitClassDef(JCTree.JCClassDecl tree) {
         boolean previousInAnnotationType = inAnnotationType;
         inAnnotationType = (tree.mods.flags & Flags.ANNOTATION) != 0;
+
         super.visitClassDef(tree);
+
+        // Rewrite static initializers to set fields to default values
+        if (tree.defs != null && !inAnnotationType) {
+            for (JCTree def : tree.defs) {
+                if (def instanceof JCTree.JCBlock) {
+                    JCTree.JCBlock block = (JCTree.JCBlock) def;
+                    if ((block.flags & Flags.STATIC) != 0) {
+                        // Replace with minimal field assignments
+                        block.stats = generateDefaultFieldAssignments(tree);
+                    }
+                }
+            }
+        }
+
         inAnnotationType = previousInAnnotationType;
         result = tree;
     }
 
+    private List<JCTree.JCStatement> generateDefaultFieldAssignments(JCTree.JCClassDecl classTree) {
+        ListBuffer<JCTree.JCStatement> statements = new ListBuffer<>();
+
+        if (classTree.defs == null) {
+            return statements.toList();
+        }
+
+        // Collect all static fields
+        for (JCTree def : classTree.defs) {
+            if (def instanceof JCTree.JCVariableDecl) {
+                JCTree.JCVariableDecl varDecl = (JCTree.JCVariableDecl) def;
+                if ((varDecl.mods.flags & Flags.STATIC) != 0) {
+                    // Generate assignment: field = defaultValue;
+                    JCTree.JCExpression defaultValue = generateDefaultValue(varDecl.vartype);
+                    JCTree.JCAssign assignment = maker.Assign(
+                        maker.Ident(varDecl.name),
+                        defaultValue
+                    );
+                    statements.append(maker.Exec(assignment));
+                }
+            }
+        }
+
+        return statements.toList();
+    }
+
+    private JCTree.JCExpression generateDefaultValue(JCTree.JCExpression typeExpr) {
+        // For simplicity: 0 for numeric types, false for boolean, null for everything else
+        String typeStr = typeExpr.toString();
+        if ("int".equals(typeStr) || "byte".equals(typeStr) || "short".equals(typeStr) || "long".equals(typeStr)
+            || "float".equals(typeStr) || "double".equals(typeStr)) {
+            return maker.Literal(TypeTag.INT, 0);
+        } else if ("boolean".equals(typeStr)) {
+            return maker.Literal(TypeTag.BOOLEAN, Boolean.FALSE);
+        } else if ("char".equals(typeStr)) {
+            return maker.Literal(TypeTag.CHAR, 0);
+        }
+        // Reference type or unknown: null
+        return maker.Literal(TypeTag.BOT, null);
+    }
+
     @Override
     public void visitMethodDef(JCTree.JCMethodDecl tree) {
         super.visitMethodDef(tree);
@@ -57,6 +113,10 @@ private boolean isConstructor(JCTree.JCMethodDecl tree) {
         return tree.name == names.init;
     }
 
+    private boolean isClassInitializer(JCTree.JCMethodDecl tree) {
+        return tree.name == names.clinit;
+    }
+
 
     private List<JCTree.JCStatement> replacementStatements(JCTree.JCMethodDecl tree) {
         ListBuffer<JCTree.JCStatement> statements = new ListBuffer<>();
@@ -106,4 +166,3 @@ private JCTree.JCStatement findConstructorInvocation(List<JCTree.JCStatement> st
     }
 
 }
-
