Track erased generic static ownership

Author: Frotty

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

@@ -465,6 +465,7 @@ private void collectGenericNewUse(ImFunctionCall call) {
             }
             return;
         }
+        recordErasedConstructorAllocation(call);
         if (!call.getTypeArguments().isEmpty()
             && (shouldSpecializeTupleArguments(call.getTypeArguments())
                 || needsRuntimeTypeSpecialization(call)
@@ -479,6 +480,23 @@ private void collectGenericNewUse(ImFunctionCall call) {
         }
     }
 
+    private void recordErasedConstructorAllocation(ImFunctionCall call) {
+        if (call.getTypeArguments().isEmpty()
+            || typeArgumentsContainTypeVariable(call.getTypeArguments())
+            || !(call.getFunc().getTrace() instanceof ConstructorDef)
+            || !(call.getFunc().getReturnType() instanceof ImClassType)
+            || shouldSpecializeTupleArguments(call.getTypeArguments())
+            || needsRuntimeTypeSpecialization(call)) {
+            return;
+        }
+        ImClass owner = classOwning(call.getFunc());
+        if (owner != null && classOwnsGenericGlobals(owner)
+            && !functionNeedsSpecialization(call.getFunc(),
+            Collections.newSetFromMap(new IdentityHashMap<>()))) {
+            translator.recordErasedGenericAllocation(owner, call.getTypeArguments());
+        }
+    }
+
     /**
      * Collects a call which names a function of a generic class outright, taking the instantiation
      * from the receiver it was handed.
@@ -571,10 +589,15 @@ private void collectCallThroughGenericReceiver(ImFunctionCall call) {
     private void collectGenericNewUse(ImAlloc alloc) {
         ImClassType clazz = alloc.getClazz();
         if (clazz.getTypeArguments().isEmpty()
-            || typeArgumentsContainTypeVariable(clazz.getTypeArguments())
-            || (!shouldSpecializeTupleArguments(clazz.getTypeArguments())
-                && !needsRuntimeTypeSpecialization(clazz)
-                && !isConstructionOnlyInstantiation(clazz.getClassDef()))) {
+            || typeArgumentsContainTypeVariable(clazz.getTypeArguments())) {
+            return;
+        }
+        if (!shouldSpecializeTupleArguments(clazz.getTypeArguments())
+            && !needsRuntimeTypeSpecialization(clazz)
+            && !isConstructionOnlyInstantiation(clazz.getClassDef())) {
+            if (classOwnsGenericGlobals(clazz.getClassDef())) {
+                translator.recordErasedGenericAllocation(clazz.getClassDef(), clazz.getTypeArguments());
+            }
             return;
         }
         genericsUses.add(new GenericClazzUse(alloc));

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

@@ -61,6 +61,7 @@ public record Specialisation(Element original, List<ImTypeArgument> typeArgument
     }
 
     private final Map<Element, Specialisation> specialisations = new IdentityHashMap<>();
+    private final Map<ImClass, Set<GenericTypes>> erasedGenericAllocations = new IdentityHashMap<>();
 
     /**
      * @param typeArguments the arguments the copy was made for, empty when a copy carries none of its
@@ -99,6 +100,31 @@ public void recordGenericStaticOwner(ImVar global, ImClass owner) {
         return specialisations.get(copy);
     }
 
+    public void recordErasedGenericAllocation(ImClass clazz, List<ImTypeArgument> typeArguments) {
+        erasedGenericAllocations.computeIfAbsent(canonical(clazz), ignored -> new HashSet<>())
+            .add(new GenericTypes(typeArguments));
+    }
+
+    public boolean hasErasedAllocationWithoutStaticSpecialization(ImClass clazz, ImVar originalStatic) {
+        Set<GenericTypes> allocations = erasedGenericAllocations.get(canonical(clazz));
+        if (allocations == null || allocations.isEmpty()) {
+            return false;
+        }
+        Set<GenericTypes> specializedStatics = new HashSet<>();
+        for (Map.Entry<Element, Specialisation> entry : specialisations.entrySet()) {
+            Specialisation specialization = entry.getValue();
+            if (specialization.original() == originalStatic) {
+                specializedStatics.add(new GenericTypes(specialization.typeArguments()));
+            }
+        }
+        for (GenericTypes allocation : allocations) {
+            if (!specializedStatics.contains(allocation)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /**
      * The node {@code copy} was ultimately copied from, or {@code copy} itself.
      * <p>

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/lua/translation/RemoveGarbage.java

@@ -190,7 +190,9 @@ public static void removePhantomGenericStaticInitializers(ImProg prog, ImTransla
             changed = false;
             for (ImVar original : candidates.keySet()) {
                 ImClass owner = translator.genericStaticOwnerOf(original);
-                if ((used.getVars().contains(original) || used.getInstantiatedClasses().contains(owner))
+                boolean erasedInstantiationNeedsOriginal = used.getInstantiatedClasses().contains(owner)
+                    && translator.hasErasedAllocationWithoutStaticSpecialization(owner, original);
+                if ((used.getVars().contains(original) || erasedInstantiationNeedsOriginal)
                     && liveOriginals.add(original)) {
                     changed = true;
                 }

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

@@ -1008,6 +1008,27 @@ public void genericStaticsAreIndependentWithoutTupleInstantiation() throws IOExc
             2, storages);
     }
 
+    @Test
+    public void constructedErasedInstantiationDoesNotDuplicateSpecializedStaticInitializer() {
+        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",
+            "init",
+            "    new Box<int>()",
+            "    if Box<int>.get() == 1 and bumps == 1",
+            "        testSuccess()"
+        );
+    }
+
     @Test
     public void randomizedNestedGenericTupleClassShapesMatchAllBackends() {
         record Shape(String type, String value, int constructions) {}