Collect fixed generic method operations

Author: Frotty

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

@@ -42,6 +42,8 @@ public class EliminateGenerics {
     private final Set<Element> specializedCallSites = Collections.newSetFromMap(new IdentityHashMap<>());
     private final Set<Element> recordedErasedStaticAllocations =
         Collections.newSetFromMap(new IdentityHashMap<>());
+    private final Set<ImFunction> scannedFixedStaticCallees =
+        Collections.newSetFromMap(new IdentityHashMap<>());
     private final Table<ImFunction, GenericTypes, ImFunction> specializedFunctions = HashBasedTable.create();
     /** The class each function was moved out of, for calls which name their target without a receiver. */
     private final Map<ImFunction, ImClass> functionOwners = new IdentityHashMap<>();
@@ -486,26 +488,25 @@ private void collectGenericNewUse(ImFunctionCall call) {
             // The generic callee remains erased, so its body is skipped by collectGenericNewRoots.
             // Fixed concrete allocations inside it still name real per-instantiation statics and
             // must be registered without cloning the caller for unrelated type arguments.
-            recordFixedErasedStaticAllocations(call.getFunc(),
-                Collections.newSetFromMap(new IdentityHashMap<>()));
+            recordFixedErasedStaticAllocations(call.getFunc());
         }
     }
 
-    private void recordFixedErasedStaticAllocations(ImFunction function,
-                                                     Set<ImFunction> visited) {
-        if (!visited.add(function)) {
+    private void recordFixedErasedStaticAllocations(ImFunction function) {
+        if (!scannedFixedStaticCallees.add(function)) {
             return;
         }
         function.accept(new Element.DefaultVisitor() {
             @Override
             public void visit(ImFunctionCall nestedCall) {
                 super.visit(nestedCall);
-                recordErasedConstructorAllocation(nestedCall);
-                if (!nestedCall.getTypeArguments().isEmpty()
-                    && !typeArgumentsContainTypeVariable(nestedCall.getTypeArguments())
-                    && !(nestedCall.getFunc().getTrace() instanceof ConstructorDef)) {
-                    recordFixedErasedStaticAllocations(nestedCall.getFunc(), visited);
-                }
+                collectGenericNewUse(nestedCall);
+            }
+
+            @Override
+            public void visit(ImMethodCall nestedCall) {
+                super.visit(nestedCall);
+                collectGenericNewUse(nestedCall);
             }
         });
     }
@@ -744,21 +745,25 @@ private void collectGenericNewUse(ImMethodCall call) {
             specializedCallSites.add(call);
             return;
         }
-        if (!shouldSpecializeTupleArguments(call.getTypeArguments())
-            && !methodNeedsSpecialization(method,
-            Collections.newSetFromMap(new IdentityHashMap<>()),
-            Collections.newSetFromMap(new IdentityHashMap<>()))) {
-            return;
-        }
         if (isMissingClassTypeArguments(call, method)) {
             addMemberTypeArguments(call, method.attrClass());
         }
         if (typeArgumentsContainTypeVariable(call.getTypeArguments())) {
-            // The receiver's declared type is still generic, which happens when the method is
-            // called straight on a freshly constructed value. The construction states the
-            // instantiation, so take the arguments from it.
+            // A call directly on a fresh generic construction gets its concrete class arguments
+            // from that construction before deciding between specialization and fixed-body scan.
             useConstructionTypeArguments(call);
         }
+        boolean needsSpecialization = methodNeedsSpecialization(method,
+            Collections.newSetFromMap(new IdentityHashMap<>()),
+            Collections.newSetFromMap(new IdentityHashMap<>()));
+        if (!shouldSpecializeTupleArguments(call.getTypeArguments()) && !needsSpecialization) {
+            if (!call.getTypeArguments().isEmpty()
+                && !typeArgumentsContainTypeVariable(call.getTypeArguments())
+                && method.getImplementation() != null) {
+                recordFixedErasedStaticAllocations(method.getImplementation());
+            }
+            return;
+        }
         if (!call.getTypeArguments().isEmpty()
             && !typeArgumentsContainTypeVariable(call.getTypeArguments())) {
             genericsUses.add(new GenericMethodCall(call));
@@ -876,9 +881,10 @@ public void visit(ImAlloc alloc) {
 
             @Override
             public void visit(ImFunctionCall call) {
+                boolean dependsOnTypeVariable = typeArgumentsContainTypeVariable(call.getTypeArguments());
                 if (constructsClassOwningGenericGlobals(function, call)
-                    || translator.isGenericNewMarker(call.getFunc())
-                    || functionNeedsSpecialization(call.getFunc(), visitedFunctions, visitedMethods)) {
+                    || (dependsOnTypeVariable && (translator.isGenericNewMarker(call.getFunc())
+                    || functionNeedsSpecialization(call.getFunc(), visitedFunctions, visitedMethods)))) {
                     found[0] = true;
                     return;
                 }
@@ -887,7 +893,8 @@ public void visit(ImFunctionCall call) {
 
             @Override
             public void visit(ImMethodCall call) {
-                if (methodNeedsSpecialization(call.getMethod(), visitedFunctions, visitedMethods)) {
+                if (typeArgumentsContainTypeVariable(call.getTypeArguments())
+                    && methodNeedsSpecialization(call.getMethod(), visitedFunctions, visitedMethods)) {
                     found[0] = true;
                     return;
                 }

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

@@ -1196,6 +1196,63 @@ public void inheritedGenericStaticInitializerUsesDeclaringOwnerMapping() {
         );
     }
 
+    @Test
+    public void fixedAllocationInsideErasedGenericMethodIsRegistered() 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",
+            "class Factory<T:>",
+            "    construct()",
+            "    function make() returns Box<int>",
+            "        return new Box<int>()",
+            "init",
+            "    let factory = new Factory<real>()",
+            "    let made = factory.make()",
+            "    let fresh = new Factory<string>().make()",
+            "    if made != null and fresh != null and Box<string>.get() == 2 and bumps == 2",
+            "        testSuccess()"
+        );
+
+        String compiled = compiledLua("fixedAllocationInsideErasedGenericMethodIsRegistered");
+        assertFalse("fixed generic method body must not be cloned for its class argument",
+            compiled.contains("Factory_make_specialized"));
+    }
+
+    @Test
+    public void fixedStaticCalleeDoesNotSpecializeUnrelatedGenericCaller() 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()",
+            "    static function get() returns int",
+            "        return value",
+            "function helper<T:>() returns int",
+            "    return Box<int>.get()",
+            "init",
+            "    if helper<string>() == 1 and helper<real>() == 1",
+            "        and Box<string>.get() == 2 and bumps == 2",
+            "        testSuccess()"
+        );
+
+        String compiled = compiledLua("fixedStaticCalleeDoesNotSpecializeUnrelatedGenericCaller");
+        assertFalse("fixed Box<int> static call must not clone helper<T>",
+            compiled.contains("helper_specialized"));
+    }
+
     @Test
     public void randomizedNestedGenericTupleClassShapesMatchAllBackends() {
         record Shape(String type, String value, int constructions) {}