fix callees in specialized functions

Author: Frotty

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

@@ -223,6 +223,49 @@ private void eliminateGenericUses() {
         }
     }
 
+    private void fixCalleesInSpecializedFunction(ImFunction newF, GenericTypes generics) {
+        newF.accept(new Element.DefaultVisitor() {
+
+            @Override
+            public void visit(ImFunctionCall fc) {
+                super.visit(fc);
+
+                ImFunction callee = fc.getFunc();
+                if (callee == null) return;
+
+                // Only interesting if callee itself is generic
+                if (callee.getTypeVariables().isEmpty()) {
+                    return;
+                }
+
+                // Determine which generics to use for the callee
+                GenericTypes calleeGenerics;
+
+                if (!fc.getTypeArguments().isEmpty()) {
+                    // Call carries explicit type args → honor them
+                    calleeGenerics = new GenericTypes(specializeTypeArgs(fc.getTypeArguments()));
+                } else {
+                    // No explicit type args → use the same generics context as the enclosing function.
+                    // This matches the pattern: destroyArrayList<T>(this: ArrayList<T>) calls ArrayList_onDestroy<T>(this)
+                    calleeGenerics = generics;
+                }
+
+                if (calleeGenerics.containsTypeVariable()) {
+                    // Still not concrete → let the normal pipeline handle it later or fail explicitly if needed
+                    return;
+                }
+
+                ImFunction specializedCallee = specializedFunctions.get(callee, calleeGenerics);
+                if (specializedCallee == null) {
+                    specializedCallee = specializeFunction(callee, calleeGenerics);
+                }
+
+                fc.setFunc(specializedCallee);
+                fc.getTypeArguments().removeAll();
+            }
+        });
+    }
+
     /**
      * creates a specialized version of this function
      */
@@ -246,7 +289,13 @@ private ImFunction specializeFunction(ImFunction f, GenericTypes generics) {
 
         newF.setName(f.getName() + "⟪" + generics.makeName() + "⟫");
         rewriteGenerics(newF, generics, typeVars);
+
+        // fix calls inside this specialized function so they also point to specialized callees
+        fixCalleesInSpecializedFunction(newF, generics);
+
+        // Then collect further generic uses inside the now-specialized body
         collectGenericUsages(newF);
+
         return newF;
     }
 

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

@@ -1616,11 +1616,9 @@ public void inheritedField_lazyClosure_uses_enclosing_receiver() {
 
     @Test
     public void arrayListInClosure() {
-        testAssertOkLinesWithStdLib(true,
+        testAssertOkLines(true,
             "package Hello",
             "import NoWurst",
-            "import Integer",
-            "import Printing",
             "",
             "native testSuccess()",
             "",
@@ -1659,11 +1657,10 @@ public void arrayListInClosure() {
             "                freeSectionCount--",
             "                return",
             "",
-            "        if nextFreeIndex + cap > JASS_MAX_ARRAY_SIZE",
+            "        if nextFreeIndex + cap > 10000",
             "            compactFreeList()",
             "",
-            "            if nextFreeIndex + cap > JASS_MAX_ARRAY_SIZE",
-            "                print(\"ArrayList: WARNING - Memory store exhausted, wrapping around!\")",
+            "            if nextFreeIndex + cap > 10000",
             "                nextFreeIndex = 0",
             "",
             "        startIndex = nextFreeIndex",
@@ -1761,13 +1758,11 @@ public void arrayListInClosure() {
             "    /** Returns the element at the specified index (O(1)) */",
             "    function get(int index) returns T",
             "        if index < 0 or index >= size",
-            "            print(\"ArrayList: Index out of bounds: \" + index.toString())",
             "        return store[startIndex + index]",
             "",
             "    /** Removes the element at the given index and returns it (O(n) - shifts elements) */",
             "    function removeAt(int index) returns T",
             "        if index < 0 or index >= size",
-            "            print(\"ArrayList: Index out of bounds: \" + index.toString())",
             "",
             "        let elem = store[startIndex + index]",
             "",