Specialize static-owning generic factories

Author: Frotty

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/imtranslation/EliminateGenerics.java

@@ -807,9 +807,10 @@ private boolean functionNeedsSpecialization(ImFunction function, Set<ImFunction>
     /**
      * Whether a function must be specialised even on Lua, which otherwise keeps generics erased.
      * <p>
-     * Two operations need the concrete type argument: constructing a value of it, and dispatching
-     * on a type class bound. Specialising these paths keeps a bounded generic as cheap on Lua as it
-     * is on Jass, at the cost of one copy per instantiation actually used.
+     * Concrete type arguments are needed when constructing a value of them, dispatching on a type
+     * class bound, or constructing a generic class whose static storage is per instantiation.
+     * Specialising these paths keeps a bounded generic as cheap on Lua as it is on Jass, at the cost
+     * of one copy per instantiation actually used.
      */
     private boolean functionNeedsSpecialization(ImFunction function, Set<ImFunction> visitedFunctions,
                                                Set<ImMethod> visitedMethods) {
@@ -849,7 +850,8 @@ public void visit(ImAlloc alloc) {
 
             @Override
             public void visit(ImFunctionCall call) {
-                if (translator.isGenericNewMarker(call.getFunc())
+                if (constructsClassOwningGenericGlobals(function, call)
+                    || translator.isGenericNewMarker(call.getFunc())
                     || functionNeedsSpecialization(call.getFunc(), visitedFunctions, visitedMethods)) {
                     found[0] = true;
                     return;
@@ -869,6 +871,27 @@ public void visit(ImMethodCall call) {
         return found[0];
     }
 
+    /**
+     * A generic caller containing {@code new Box<T>()} must be revisited after {@code T} becomes
+     * concrete so each constructed instantiation can register its own static storage. Detect the
+     * constructor call at the caller boundary; marking the constructor implementation itself would
+     * unnecessarily redirect ordinary objects away from Lua's erased representation.
+     */
+    private boolean constructsClassOwningGenericGlobals(ImFunction enclosingFunction,
+                                                         ImFunctionCall call) {
+        if (!(call.getFunc().getTrace() instanceof ConstructorDef)) {
+            return false;
+        }
+        // A lowered constructor wrapper calls the class initializer carrying the same source
+        // ConstructorDef. That call implements the current allocation; it is not another generic
+        // allocation hidden inside this function and direct callers register it themselves.
+        if (enclosingFunction.getTrace() == call.getFunc().getTrace()) {
+            return false;
+        }
+        ImClass owner = classOwning(call.getFunc());
+        return owner != null && classOwnsGenericGlobals(owner);
+    }
+
     private boolean methodNeedsSpecialization(ImMethod method, Set<ImFunction> visitedFunctions,
                                              Set<ImMethod> visitedMethods) {
         if (!visitedMethods.add(method)) {

de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/LuaBackendAuditTests.java

@@ -1053,6 +1053,46 @@ public void eachConstructedErasedInstantiationGetsItsOwnStaticInitializer() {
         );
     }
 
+    @Test
+    public void genericFactoryAllocationSpecializesStaticOwningClass() throws IOException {
+        test().testLua(true).executeProg().lines(
+            "package Test",
+            "native testSuccess()",
+            "int bumps",
+            "function bump() returns int",
+            "    bumps++",
+            "    return bumps",
+            "class Box<T:>",
+            "    static int value = bump()",
+            "    construct()",
+            "    static function get() returns int",
+            "        return value",
+            "function make<T:>() returns Box<T>",
+            "    return new Box<T>()",
+            "function forward<T:>() returns Box<T>",
+            "    return make<T>()",
+            "class Maker<T:>",
+            "    construct()",
+            "    function makeBox() returns Box<T>",
+            "        return new Box<T>()",
+            "init",
+            "    let first = forward<int>()",
+            "    let second = forward<string>()",
+            "    let third = new Maker<real>().makeBox()",
+            "    if first != null and second != null and third != null",
+            "        and Box<int>.get() == 1 and Box<string>.get() == 2",
+            "        and Box<real>.get() == 3 and bumps == 3",
+            "        testSuccess()"
+        );
+
+        String compiled = compiledLua("genericFactoryAllocationSpecializesStaticOwningClass");
+        assertEquals("the shared constructor must allocate ordinary objects on the erased Lua class",
+            1, countOccurrences(compiled, "= Box:create()"));
+        assertFalse("static specialization must not create specialized object classes",
+            java.util.regex.Pattern.compile("(?m)^Box_specialized\\S* = \\(\\{\\}\\)$")
+                .matcher(compiled).find());
+    }
+
     @Test
     public void randomizedNestedGenericTupleClassShapesMatchAllBackends() {
         record Shape(String type, String value, int constructions) {}