TeaVM 0.15.0-dev-3 with workarounds

Author: CommanderTvis

bridge/build.gradle.kts

@@ -371,59 +371,17 @@ val stubs = listOf(
 
 val stubsClassesDir = layout.buildDirectory.dir("generated/teavm-stubs/classes")
 
-// TeaVM's classlib jar ships `META-INF/teavm.properties` with the directive
-// `includePackageHierarchy|java=false` — meaning every classpath entry whose class names start
-// with `java.` is *excluded* by default (TeaVM expects to provide them itself, via the
-// `org.teavm.classlib.java.*` → `java.*` renaming). Our stubs jar carries an additional
-// `META-INF/teavm.properties` that *re-includes* the specific java.* / jakarta.* / javax.*
-// sub-packages we ship stubs for, so the renamer doesn't drop them on the floor.
-val teavmStubsIncludes = listOf(
-    // Mapping rules so my generated `org.teavm.classlib.<pkg>.T<Class>` stubs surface as the
-    // requested `<pkg>.<Class>` classes. teavm-classlib already ships these for `java.*`; the
-    // jakarta.* and javax.* lines below add equivalent prefixes for the packages it doesn't
-    // cover. Package-hierarchy rules cascade to sub-packages.
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.jakarta=T",
-    "mapPackageHierarchy|org.teavm.classlib.jakarta=jakarta",
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.javax=T",
-    "mapPackageHierarchy|org.teavm.classlib.javax=javax",
-    // org.w3c.* and org.xml.* — same shape, distinct package roots.
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.org.w3c=T",
-    "mapPackageHierarchy|org.teavm.classlib.org.w3c=org.w3c",
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.org.xml=T",
-    "mapPackageHierarchy|org.teavm.classlib.org.xml=org.xml",
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.org.glassfish=T",
-    "mapPackageHierarchy|org.teavm.classlib.org.glassfish=org.glassfish",
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.jakarta.xml=T",
-    "mapPackageHierarchy|org.teavm.classlib.jakarta.xml=jakarta.xml",
-    // com.beanit, com.google.gson, io.r2dbc — leaf libraries we excluded from the dep graph;
-    // these prefixes let the stubs surface where TeaVM expects to find the original classes.
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.com.beanit=T",
-    "mapPackageHierarchy|org.teavm.classlib.com.beanit=com.beanit",
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.com.google=T",
-    "mapPackageHierarchy|org.teavm.classlib.com.google=com.google",
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.io.r2dbc=T",
-    "mapPackageHierarchy|org.teavm.classlib.io.r2dbc=io.r2dbc",
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.org.jooq=T",
-    "mapPackageHierarchy|org.teavm.classlib.org.jooq=org.jooq",
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.org.reactivestreams=T",
-    "mapPackageHierarchy|org.teavm.classlib.org.reactivestreams=org.reactivestreams",
-    // SLF4J shim: org.teavm.classlib.org.slf4j.TLoggerFactory → org.slf4j.LoggerFactory.
-    // Replaces SLF4J's real LoggerFactory whose provider-discovery static init would
-    // otherwise abort the moment any rell-base `companion object: KLogging()` resolves.
-    "stripPrefixFromPackageHierarchyClasses|org.teavm.classlib.org.slf4j=T",
-    "mapPackageHierarchy|org.teavm.classlib.org.slf4j=org.slf4j",
-    // teavm-classlib excludes javax.xml from project-classpath lookups by default
-    // (`includePackageHierarchy|javax.xml=false`); the rename above re-enables it for the
-    // sub-tree we ship stubs for.
-    "includePackageHierarchy|javax.xml=true",
-)
+// The `org.teavm.classlib.<pkg>.T<Class>` stubs below are surfaced as the requested
+// `<pkg>.<Class>` classes by RellPlaygroundSubstitutionPolicy (a SubstitutionPolicy SPI). Up to
+// 0.14 this remapping was driven by `mapPackageHierarchy` / `stripPrefixFromPackageHierarchyClasses`
+// directives in a `META-INF/teavm.properties` we shipped in this jar; 0.15.0-dev-3 deleted the
+// classpath property-renamer from teavm-core, so the rules now live in that policy class instead.
 
 val generateTeavmStubs by tasks.registering {
     description = "Emits empty stub bytecode for JDK packages TeaVM's classlib omits."
     group = LifecycleBasePlugin.BUILD_GROUP
 
     inputs.property("stubs", stubs.joinToString { "${it.name}|${it.isInterface}" })
-    inputs.property("includes", teavmStubsIncludes.joinToString("\n"))
     outputs.dir(stubsClassesDir)
 
     doLast {
@@ -465,11 +423,6 @@ val generateTeavmStubs by tasks.registering {
             classFile.parentFile.mkdirs()
             classFile.writeBytes(cw.toByteArray())
         }
-
-        // teavm.properties: re-includes the java.* / jakarta.* / javax.* sub-packages we ship.
-        val propsFile = outDir.resolve("META-INF/teavm.properties")
-        propsFile.parentFile.mkdirs()
-        propsFile.writeText(teavmStubsIncludes.joinToString("\n", postfix = "\n"))
     }
 }
 
@@ -521,27 +474,26 @@ dependencies {
 
     implementation(libs.rell.api.base)
 
-    // teavm-jso brings the @JSExport annotation used to expose static Kotlin methods to JS.
-    // The annotation has no runtime semantics on JVM; TeaVM consumes it at compile time.
     compileOnly(libs.teavm.jso)
-
-    // teavm-core: needed to compile the TeaVMPlugin / ClassHolderTransformer at
-    // com.chromia.rellplayground.teavm.*. Marked `compileOnly` because the plugin classes are
-    // loaded by TeaVM's own daemon (which already has teavm-core on its classpath) — shipping
-    // teavm-core itself into the compiled output would bloat the JS bundle with classes TeaVM
-    // never reaches at runtime.
     compileOnly(libs.teavm.core)
+    compileOnly(libs.teavm.extension.spi)
 
-    // TeaVM classpath. teavm(...) adds the entry to the configuration TeaVM compiles from
-    // (in addition to runtimeClasspath). jsoApis provides DOM + JSON types — we use a small
-    // subset (e.g. nothing yet) but it's required for the JS frontend's helpers.
     teavm(libs.teavm.jso.apis)
 }
 
-// Tensor-probe parameters. Override on the CLI with -Prell.teavm.opt=BALANCED, -Prell.teavm.fast=true.
+// TeaVM codegen config. Overridable on the CLI (-Prell.teavm.opt=..., -Prell.teavm.fast=...,
+// -Prell.teavm.obf=...) but the defaults below are the only combination that produces a *working*
+// bridge on 0.15.0-dev-3:
+//   - fastGlobalAnalysis = true is mandatory: precise analysis (fast=false) over-prunes
+//     reflectively-reached init and emits JS that references eliminated symbols, so every
+//     fast=false build crashes at runtime (C_LibBridge.instance uninitialized / ReferenceError).
+//   - With fastGlobalAnalysis on, the optimizer's size/codegen passes are bypassed, so NONE /
+//     BALANCED / AGGRESSIVE yield a byte-identical artifact — the opt level only changes build
+//     time (AGGRESSIVE is just slower for the same output). BALANCED is the fastest viable build.
 val probeOpt: OptimizationLevel = (project.findProperty("rell.teavm.opt") as String?)
-    ?.let { OptimizationLevel.valueOf(it) } ?: OptimizationLevel.NONE
-val probeFast: Boolean = (project.findProperty("rell.teavm.fast") as String?)?.toBoolean() ?: false
+    ?.let { OptimizationLevel.valueOf(it) } ?: OptimizationLevel.BALANCED
+val probeFast: Boolean = (project.findProperty("rell.teavm.fast") as String?)?.toBoolean() ?: true
+val probeObfuscated: Boolean = (project.findProperty("rell.teavm.obf") as String?)?.toBoolean() ?: true
 
 teavm {
     all {
@@ -578,7 +530,7 @@ teavm {
         optimization = probeOpt
         outOfProcess = true
         processMemory = 8192
-        obfuscated = true
+        obfuscated = probeObfuscated
         sourceMap = false
         targetFileName = "rell-playground-bridge.wasm"
     }

bridge/src/main/java/com/chromia/rellplayground/teavm/AbstractMethodBodyStubber.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2026 ChromaWay AB. See LICENSE for license information.
+ */
+
+package com.chromia.rellplayground.teavm;
+
+import java.util.Set;
+import org.teavm.model.ClassHolder;
+import org.teavm.model.ClassHolderTransformer;
+import org.teavm.model.ClassHolderTransformerContext;
+import org.teavm.model.ElementModifier;
+import org.teavm.model.MethodHolder;
+import org.teavm.model.Program;
+import org.teavm.model.emit.ProgramEmitter;
+
+/**
+ * Works around a TeaVM 0.15 WasmGC codegen crash. {@code WasmGCMethodGenerator.createInstanceFunction}
+ * / {@code generateMethodBody} guard against {@code STATIC} and {@code NATIVE} methods but not
+ * {@code ABSTRACT} ones, so when an abstract method becomes a virtual-dispatch target the generator
+ * calls {@code generateRegularMethodBody}, which does {@code Objects.requireNonNull(getProgram())}
+ * and NPEs. TeaVM catches the NPE and emits an {@code unreachable} body (so the {@code .wasm} is
+ * fine), but it also calls {@code diagnostics.error}, which fails the build.
+ *
+ * <p>Giving the offending abstract methods a real (throwing) body removes the null program, so no
+ * exception fires. The bodies are dead: every concrete implementor of these interfaces overrides
+ * them, so virtual dispatch never lands on the synthetic body. {@code throw} (rather than a silent
+ * return) preserves TeaVM's trap semantics and surfaces a clear error if one is ever reached.
+ *
+ * <p>Scoped to the specific interfaces TeaVM trips on (extend {@link #DEABSTRACT_CLASSES} as new
+ * ones surface) — de-abstracting the whole hierarchy would be wrong. The underlying bug should be
+ * fixed upstream (konsoletyper/teavm — skip abstract methods in the WasmGC method generator).
+ */
+final class AbstractMethodBodyStubber implements ClassHolderTransformer {
+    private static final Set<String> DEABSTRACT_CLASSES = Set.of(
+        // Reached via Rell's INSERT path: TableImpl.field -> Tools.tableField -> Fields.field.
+        "org.jooq.Fields");
+
+    @Override
+    public void transformClass(ClassHolder cls, ClassHolderTransformerContext context) {
+        if (!DEABSTRACT_CLASSES.contains(cls.getName())) {
+            return;
+        }
+        for (MethodHolder method : cls.getMethods()) {
+            if (method.hasModifier(ElementModifier.ABSTRACT)
+                    && !method.hasModifier(ElementModifier.NATIVE)
+                    && method.getProgram() == null) {
+                method.getModifiers().remove(ElementModifier.ABSTRACT);
+                method.setProgram(buildThrowStub(method, context));
+            }
+        }
+    }
+
+    private static Program buildThrowStub(MethodHolder method, ClassHolderTransformerContext context) {
+        var emitter = ProgramEmitter.create(method, context.getHierarchy());
+        emitter.construct(UnsupportedOperationException.class,
+                emitter.constant("not in TeaVM: " + method.getOwnerName() + "." + method.getName()))
+                .raise();
+        return emitter.getProgram();
+    }
+}

bridge/src/main/java/com/chromia/rellplayground/teavm/GenericParametersNormalizer.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2026 ChromaWay AB. See LICENSE for license information.
+ */
+
+package com.chromia.rellplayground.teavm;
+
+import org.teavm.model.ClassHolder;
+import org.teavm.model.ClassHolderTransformer;
+import org.teavm.model.ClassHolderTransformerContext;
+import org.teavm.model.GenericTypeParameter;
+
+/**
+ * Works around a second null-handling bug in TeaVM 0.15's WasmGC reflection metadata generator.
+ * {@code ClassReader.getGenericParameters()} returns {@code null} for any class without a generic
+ * signature, but {@code ReflectionMetadataGenerator.generateClassMetadata} forwards that null
+ * straight into {@code generateTypeParameters}, which does {@code for (var p : params)} and NPEs —
+ * for any class that has annotations / reflectable members / inner classes (so it isn't skipped)
+ * yet no type variables.
+ *
+ * <p>Normalising the model so every class reports an empty array instead of null sidesteps it.
+ * Like the rest of this package this is a TeaVM workaround that should be fixed upstream
+ * (konsoletyper/teavm — the generator should treat null as "no type parameters").
+ */
+final class GenericParametersNormalizer implements ClassHolderTransformer {
+    private static final GenericTypeParameter[] EMPTY = new GenericTypeParameter[0];
+
+    @Override
+    public void transformClass(ClassHolder cls, ClassHolderTransformerContext context) {
+        if (cls.getGenericParameters() == null) {
+            cls.setGenericParameters(EMPTY);
+        }
+    }
+}

bridge/src/main/java/com/chromia/rellplayground/teavm/ReflectionTargetPreserver.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2026 ChromaWay AB. See LICENSE for license information.
+ */
+
+package com.chromia.rellplayground.teavm;
+
+import java.util.HashSet;
+import java.util.Set;
+import org.teavm.dependency.AbstractDependencyListener;
+import org.teavm.dependency.DependencyAgent;
+import org.teavm.dependency.DependencyNode;
+import org.teavm.dependency.MethodDependency;
+import org.teavm.model.MethodReference;
+import org.teavm.model.ValueType;
+
+/**
+ * Works around a TeaVM 0.15 reflection-emit crash. When {@code Class.newInstance},
+ * {@code Class.getDeclaredAnnotations} or {@code Class.getDeclaredClasses} is reachable, the
+ * dependency analyser records every class that flows into them as a reflection target — including
+ * the inner classes ({@code $DefaultImpls}, {@code $WhenMappings}, …) of every reachable class.
+ * Many of those targets are never otherwise reached, so {@code TeaVM.link()} (which copies only
+ * {@code getReachableClasses()} into the emit source) drops them. The JS {@code ClassInfoGenerator}
+ * and the WasmGC {@code ReflectionMetadataGenerator} then iterate the same target set and
+ * dereference each one's now-null {@code ClassReader}, NPEing the whole emit phase with no hint of
+ * which class is to blame.
+ *
+ * <p>The fix pulls every reflection target that has bytecode back into the reachable set, so it
+ * survives into {@code cutClasses} and the emit phase finds a non-null {@code ClassReader}. Linking
+ * is only legal while the analyser is propagating (not in {@code completing}), so we attach a
+ * consumer to each sink's class-value node in {@link #methodReached} and link targets as they
+ * arrive. The set converges because the targets are overwhelmingly leaf inner classes.
+ *
+ * <p>Installed by {@link RellPlaygroundPlugin}. The TeaVM bug should also be reported upstream
+ * (konsoletyper/teavm) — the generators ought to null-check or skip pruned targets.
+ */
+public final class ReflectionTargetPreserver extends AbstractDependencyListener {
+    private static final Set<MethodReference> REFLECTIVE_SINKS = Set.of(
+        new MethodReference(Class.class, "newInstance", Object.class),
+        new MethodReference(Class.class, "getDeclaredAnnotations", java.lang.annotation.Annotation[].class),
+        new MethodReference(Class.class, "getDeclaredClasses", Class[].class));
+
+    private final Set<String> linked = new HashSet<>();
+
+    @Override
+    public void methodReached(DependencyAgent agent, MethodDependency method) {
+        if (!REFLECTIVE_SINKS.contains(method.getReference())) {
+            return;
+        }
+        DependencyNode classValues = method.getVariable(0).getClassValueNode();
+        classValues.addConsumer(type -> {
+            ValueType valueType = type.getValueType();
+            if (!(valueType instanceof ValueType.Object)) {
+                return;
+            }
+            var className = ((ValueType.Object) valueType).getClassName();
+            // Only pull in targets that actually have bytecode; `linked` keeps this idempotent so
+            // repeated propagation doesn't re-link and the analysis still converges.
+            if (linked.add(className) && agent.getClassSource().get(className) != null) {
+                agent.linkClass(className).initClass(null);
+            }
+        });
+    }
+}

bridge/src/main/java/com/chromia/rellplayground/teavm/RellPlaygroundPlugin.java

@@ -26,5 +26,8 @@ public final class RellPlaygroundPlugin implements TeaVMPlugin {
     @Override
     public void install(TeaVMHost host) {
         host.add(new MissingMethodInjector());
+        host.add(new GenericParametersNormalizer());
+        host.add(new AbstractMethodBodyStubber());
+        host.add(new ReflectionTargetPreserver());
     }
 }

bridge/src/main/java/com/chromia/rellplayground/teavm/RellPlaygroundSubstitutionPolicy.java

@@ -0,0 +1,52 @@
+package com.chromia.rellplayground.teavm;
+
+import java.util.function.Predicate;
+import org.teavm.extension.spi.substitution.SimpleSubstitutionPolicy;
+import org.teavm.extension.spi.substitution.SubstitutionSink;
+
+/**
+ * Redirects the handful of non-{@code java.*} packages we ship empty stubs for to our
+ * {@code org.teavm.classlib.<pkg>.T<Class>} overlay classes — the exact transformation
+ * teavm-classlib applies to {@code java.*} (see {@code ClasslibSubstitutionPolicy}).
+ *
+ * <p>This replaces the {@code mapPackageHierarchy} / {@code stripPrefixFromPackageHierarchyClasses}
+ * directives our stubs jar used to carry in {@code META-INF/teavm.properties}. TeaVM 0.15.0-dev-3
+ * deleted the classpath property-renamer from teavm-core (konsoletyper/teavm#1191) and moved the
+ * whole mechanism to this {@link org.teavm.extension.spi.substitution.SubstitutionPolicy} SPI, so
+ * without this class every stubbed class surfaces as "was not found" at link time.
+ *
+ * <p>Registered via {@code META-INF/services/org.teavm.extension.spi.substitution.SubstitutionPolicy};
+ * TeaVM loads it with a {@code ServiceLoader} over the program classpath, alongside
+ * {@link RellPlaygroundPlugin}.
+ */
+public class RellPlaygroundSubstitutionPolicy extends SimpleSubstitutionPolicy {
+    // Package roots whose `<root>.….<Class>` references resolve to our
+    // `org.teavm.classlib.<root>.….T<Class>` stubs. `java.*` is owned by teavm-classlib.
+    private static final String[] ROOTS = {
+        "jakarta",
+        "javax",
+        "org.w3c",
+        "org.xml",
+        "org.glassfish",
+        "com.beanit",
+        "com.google",
+        "io.r2dbc",
+        "org.jooq",
+        "org.reactivestreams",
+        // SLF4J shim: only `org.teavm.classlib.org.slf4j.TLoggerFactory` exists, so LoggerFactory
+        // resolves to our no-op (sidestepping SLF4J's provider-discovery static init); every other
+        // org.slf4j.* class has no T-stub and falls back to the real slf4j-api type.
+        "org.slf4j",
+    };
+
+    @Override
+    public void contribute(SubstitutionSink sink) {
+        Predicate<String> inAnyRoot = inPackage(ROOTS[0], true);
+        for (int i = 1; i < ROOTS.length; i++) {
+            inAnyRoot = inAnyRoot.or(inPackage(ROOTS[i], true));
+        }
+        sink.selectClasses(inAnyRoot)
+                .packagePrefix("org.teavm.classlib.")
+                .simpleNamePrefix("T");
+    }
+}

bridge/src/main/resources/META-INF/services/org.teavm.extension.spi.substitution.SubstitutionPolicy

@@ -0,0 +1 @@
+com.chromia.rellplayground.teavm.RellPlaygroundSubstitutionPolicy

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
 kotlin = "2.3.0"
 rell = "0.16.0"
-teavm = "0.15.0-dev-2"
+teavm = "0.15.0-dev-3"
 node-gradle = "7.1.0"
 
 [libraries]
@@ -14,6 +14,7 @@ rell-gtx = { module = "net.postchain.rell:rell-gtx", version.ref = "rell" }
 teavm-jso = { module = "org.teavm:teavm-jso", version.ref = "teavm" }
 teavm-jso-apis = { module = "org.teavm:teavm-jso-apis", version.ref = "teavm" }
 teavm-core = { module = "org.teavm:teavm-core", version.ref = "teavm" }
+teavm-extension-spi = { module = "org.teavm:teavm-extension-spi", version.ref = "teavm" }
 
 [plugins]
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }