js-port translator: elide clinit guards for classes with no initializer (TeaVM parity)

GETSTATIC/PUTSTATIC/NEW/static-call sites emitted `_I(owner)`
(ensureClassInitialized) unconditionally, even when the owner's entire
hierarchy has no `<clinit>` and no deferred static-field initialization -- in
which case the runtime helper just walks the supertypes, finds nothing to run,
and returns. A TeaVM build of hellocodenameone emits ~90 class-init guards;
ParparVM emitted ~8900.

Add classNeedsInitialization(className): walks the class + superclasses +
(transitive) superinterfaces and returns true iff any has an explicit clinit or
deferred static init. Over-approximates (returns true) on unknown classes /
hierarchy cycles so a needed guard is never dropped; static fields are
default-initialised at defineClass time, so a clinit-less class is safe to read
unguarded. Consulted at all four `_I(...)` emission sites (straight-line,
interpreter, static-method entry, static wrapper). Result cached per
translation run (cleared in setClassIndex).

hellocodenameone: clinit guards 8906 -> 6075 (-32%); translated_app.js
5127 -> 5101 KB raw, 1075 -> 1070 gzip; fewer runtime ensureClassInitialized
calls (startup perf). Verified: clean boot, UI renders, no errors. The
remaining guards are on genuinely init-bearing hierarchies; closing the rest of
the gap to TeaVM needs whole-program "already-initialised" propagation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: shai-almog

vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptMethodGenerator.java

@@ -113,7 +113,12 @@ final class JavascriptMethodGenerator {
     private JavascriptMethodGenerator() {
     }
 
+    // Memoises classNeedsInitialization(); keyed on the sanitized class name.
+    // Cleared whenever classIndex changes so a stale run can't leak.
+    private static final Map<String, Boolean> classNeedsInitCache = new java.util.concurrent.ConcurrentHashMap<String, Boolean>();
+
     static void setClassIndex(List<ByteCodeClass> allClasses) {
+        classNeedsInitCache.clear();
         if (allClasses == null) {
             classIndex = null;
             referencedStaticFields = null;
@@ -664,6 +669,62 @@ private static String resolveStaticFieldOwner(String owner, String fieldName) {
         return start;
     }
 
+    /**
+     * True when {@code _I(className)} (ensureClassInitialized) can have any
+     * observable effect: the class or one of its supertypes (superclass or a
+     * transitive superinterface) has an explicit {@code <clinit>} or deferred
+     * static-field initialization. When false the guard is pure overhead — the
+     * runtime helper walks the hierarchy, finds no clinit, and returns — so the
+     * emitter can omit it entirely. This mirrors TeaVM, which only guards
+     * init-bearing classes (a hellocodenameone build emits ~90 guards; ParparVM
+     * emitted ~8900 because it guarded unconditionally). Over-approximates
+     * (returns {@code true}) for unknown classes / hierarchy cycles so a needed
+     * guard is never dropped; static fields themselves are default-initialised
+     * at {@code defineClass} time, so a clinit-less class is safe to read
+     * without a guard.
+     */
+    private static boolean classNeedsInitialization(String className) {
+        Map<String, ByteCodeClass> idx = classIndex;
+        if (className == null || idx == null) {
+            return true;
+        }
+        String start = JavascriptNameUtil.sanitizeClassName(className);
+        Boolean cached = classNeedsInitCache.get(start);
+        if (cached != null) {
+            return cached;
+        }
+        boolean needs = false;
+        java.util.Set<String> seen = new java.util.HashSet<String>();
+        java.util.Deque<String> stack = new java.util.ArrayDeque<String>();
+        stack.push(start);
+        while (!stack.isEmpty()) {
+            String cur = stack.pop();
+            if (cur == null || !seen.add(cur)) {
+                continue;
+            }
+            ByteCodeClass cls = idx.get(cur);
+            if (cls == null) {
+                needs = true;            // unknown class -> keep the guard
+                break;
+            }
+            if (hasExplicitClinit(cls) || hasDeferredStaticInitialization(cls)) {
+                needs = true;
+                break;
+            }
+            String base = cls.getBaseClass();
+            if (base != null) {
+                stack.push(JavascriptNameUtil.sanitizeClassName(base));
+            }
+            if (cls.getBaseInterfaces() != null) {
+                for (String iface : cls.getBaseInterfaces()) {
+                    stack.push(JavascriptNameUtil.sanitizeClassName(iface));
+                }
+            }
+        }
+        classNeedsInitCache.put(start, needs);
+        return needs;
+    }
+
     static String generateClassJavascript(ByteCodeClass cls, List<ByteCodeClass> allClasses) {
         // Populate the resolution index lazily on first call and keep it
         // alive for the rest of the generation pass. The size check is
@@ -2477,7 +2538,8 @@ private static void appendMethodImpl(StringBuilder out, StringBuilder regs, Byte
             out.append("__cn1Arg").append(i + 1);
         }
         out.append("){\n");
-        if (!wrappedStaticMethod && method.isStatic() && !"__CLINIT__".equals(method.getMethodName())) {
+        if (!wrappedStaticMethod && method.isStatic() && !"__CLINIT__".equals(method.getMethodName())
+                && classNeedsInitialization(cls.getClsName())) {
             out.append("  _I(\"").append(cls.getClsName()).append("\");\n");
         }
         if ("__CLINIT__".equals(method.getMethodName())) {
@@ -2819,7 +2881,9 @@ private static void appendWrappedStaticMethod(StringBuilder out, ByteCodeClass c
         out.append(suspending ? "function* " : "function ").append(wrapperName).append("(");
         appendMethodParameters(out, method);
         out.append("){\n");
-        out.append("  _I(\"").append(cls.getClsName()).append("\");\n");
+        if (classNeedsInitialization(cls.getClsName())) {
+            out.append("  _I(\"").append(cls.getClsName()).append("\");\n");
+        }
         out.append("  return ").append(suspending ? "yield* " : "").append(bodyName).append("(");
         appendMethodParameterArguments(out, method);
         out.append(");\n");
@@ -4790,6 +4854,9 @@ private static boolean appendStraightLineFieldInstruction(StringBuilder out, Fie
     }
 
     private static void appendStraightLineEnsureClassInitialized(StringBuilder out, StraightLineContext ctx, String owner) {
+        if (!classNeedsInitialization(owner)) {
+            return;
+        }
         if (ctx.initializedClasses.add(owner)) {
             out.append("  _I(\"").append(owner).append("\");\n");
         }
@@ -6635,6 +6702,9 @@ private static void appendInterpreterEnsureClassInitialized(StringBuilder out, S
         // any of its methods can run, so both are already live by the
         // time this method body executes. ~30% of the 7.7k ``jvm.eI``
         // sites resolve to the containing class or its ancestors.
+        if (!classNeedsInitialization(owner)) {
+            return;
+        }
         if (isClassAlreadyInitializedForCurrentEmission(owner)) {
             return;
         }