Carry type arguments through the vararg call redirects

Both redirects rebuilt the call with an empty ImTypeArguments. That was right
on Jass, where EliminateGenerics runs at phase 2 and nothing generic survives
to the vararg phase, but it is an assumption about the pipeline written into
a node constructor, and Lua reaches this pass with a different amount erased.

Measured before changing anything, since the reported failure is a strong
claim: a probe that threw whenever either redirect saw a non-empty type
argument list found no hit anywhere in LuaBackendAuditTests, VarargTests,
GenericsTests, LuaTranslationTests, GenericsWithTypeclassesTests or
StdLibOwnTests. A generic vararg returning its type parameter, consumed by
string concatenation, also produces the correct string without this change.
So the reported miscompilation does not occur: Lua erases these before the
pass rather than carrying them into it.

The list is moved across anyway. It costs nothing, it is a no-op while the
list is empty, and rebuilding a call should copy what the call had instead of
restating a fact about phase order that only holds on one target.

Author: Frotty

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

@@ -168,7 +168,8 @@ private static List<ImExpr> receiverAndArguments(ImMethodCall call) {
     private void redirectMethodCall(ImMethodCall call, ImFunction newFunc) {
         ImExprs args = JassIm.ImExprs(call.getReceiver().copy());
         args.addAll(call.getArguments().removeAll());
-        call.replaceBy(JassIm.ImFunctionCall(call.getTrace(), newFunc, JassIm.ImTypeArguments(), args,
+        call.replaceBy(JassIm.ImFunctionCall(call.getTrace(), newFunc,
+            JassIm.ImTypeArguments(call.getTypeArguments().removeAll()), args,
             call.getTuplesEliminated(), CallType.NORMAL));
     }
 
@@ -350,7 +351,13 @@ public void visit(ImVarAccess va) {
 
     private void redirectCall(ImFunctionCall call, ImFunction newFunc) {
         // Redirect call to new function
-        ImFunctionCall newCall = JassIm.ImFunctionCall(call.getTrace(), newFunc, JassIm.ImTypeArguments(), JassIm.ImExprs(call.getArguments().removeAll()), call.getTuplesEliminated(), call.getCallType());
+        // Carry the type arguments over rather than assuming there are none. Jass erases generics
+        // long before this pass, so an empty list was always right there; on Lua the erasure happens
+        // elsewhere and this list is empty in practice too, but rebuilding the call should not be
+        // the step that decides that.
+        ImFunctionCall newCall = JassIm.ImFunctionCall(call.getTrace(), newFunc,
+            JassIm.ImTypeArguments(call.getTypeArguments().removeAll()),
+            JassIm.ImExprs(call.getArguments().removeAll()), call.getTuplesEliminated(), call.getCallType());
         call.replaceBy(newCall);
     }
 

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

@@ -2129,6 +2129,29 @@ public void varargConstructorAboveTheLuaArityBoundKeepsThePackedPath() {
         );
     }
 
+    /**
+     * Jass erases generics long before this pass, so `redirectCall` could build the replacement with
+     * an empty type-argument list. Lua only specialises concrete operations at that point and leaves
+     * generics live, so dropping them leaves the redirected call typed by an unresolved type variable.
+     * `LuaNativeLowering` decides string concatenation from each operand's type, so a generic vararg
+     * returning its type parameter silently became a numeric addition on strings.
+     */
+    @Test
+    public void genericVarargCallKeepsItsTypeArgumentsOnLua() {
+        test().testLua(true).withStdLib().executeProg().lines(
+            "package Test",
+            "function lastOf<T>(vararg T xs) returns T",
+            "    T result = null",
+            "    for x in xs",
+            "        result = x",
+            "    return result",
+            "init",
+            "    let joined = \"a\" + lastOf<string>(\"b\", \"c\")",
+            "    if joined == \"ac\" and lastOf<int>(1, 2) == 2",
+            "        testSuccess()"
+        );
+    }
+
     @Test
     public void virtuallyDispatchedVarargMethodKeepsThePackedPath() throws IOException {
         test().testLua(true).executeProg().lines(