Leave unreachable dispatches to garbage removal

Rejecting a dispatch whose function had no specialization also rejected a bounded
generic that is merely declared and never called. Nothing has to supply a concrete
type for such a function, and garbage removal deletes it later, so the rejection
made an unused generic API fail to compile on Lua while remaining fine on Jass.

Only the dispatches this pass can prove dead are neutralised now: those in a
function which does have a specialization, since every reachable call was rewritten
to it. Everything else is left for the passes that already decide reachability.

A dispatch which survives that far and reaches the Lua backend is reported there
instead of failing as an unimplemented case. By then it is known to be both
reachable and unresolvable, which is exactly when saying so is useful.

Author: Frotty

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

@@ -132,16 +132,17 @@ public void transformGenericNewOnly() {
     }
 
     /**
-     * Deals with the dispatches left after targeted specialization.
+     * Neutralises the dispatches left in functions that were specialized.
      * <p>
-     * A function that has a specialization is dead: every reachable call to it was rewritten to
-     * that specialization, so a dispatch still sitting in the original can never run. This backend
-     * keeps generics rather than removing them wholesale, so those originals are still translated,
-     * and a dispatch would reach a backend with no way to express it. Such a dispatch is replaced by
-     * the default value of its type.
+     * Such a function is dead: every reachable call to it was rewritten to its specialization, so a
+     * dispatch still sitting in the original can never run. This backend keeps generics rather than
+     * removing them wholesale, so those originals are still translated and the dispatch would reach
+     * a backend with no way to express it.
      * <p>
-     * A dispatch in a function that was never specialized is a different matter: it would run, and
-     * nothing has supplied the concrete type. That is reported rather than quietly defaulted.
+     * Anything else is left alone. A dispatch may legitimately remain in a bounded generic that is
+     * merely declared and never called, and garbage removal deletes those later; deciding here
+     * would mean duplicating reachability. One which survives that far and still reaches the
+     * backend is reported there, where it is known to be both reachable and unresolvable.
      */
     private void settleRemainingDispatches() {
         List<ImTypeVarDispatch> remaining = new ArrayList<>();
@@ -156,12 +157,7 @@ public void visit(ImTypeVarDispatch dispatch) {
             ImFunction owner = dispatch.getNearestFunc();
             if (owner != null && specializedFunctions.containsRow(owner)) {
                 dispatch.replaceBy(defaultValueFor(dispatch.getTypeClassFunc().getReturnType()));
-                continue;
             }
-            throw new CompileError(dispatch.attrTrace().attrSource(),
-                "Type class dispatch of " + dispatch.getTypeClassFunc().getName()
-                    + " could not be resolved for this target: the concrete type is not available"
-                    + " where it is used.");
         }
     }
 

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

@@ -1,6 +1,7 @@
 package de.peeeq.wurstscript.translation.lua.translation;
 
 import de.peeeq.wurstscript.WurstOperator;
+import de.peeeq.wurstscript.attributes.CompileError;
 import de.peeeq.wurstscript.jassIm.*;
 import de.peeeq.wurstscript.luaAst.*;
 import de.peeeq.wurstscript.translation.imtranslation.ImTranslator;
@@ -461,7 +462,12 @@ public static LuaExpr translate(ImCompiletimeExpr imCompiletimeExpr, LuaTranslat
     }
 
     public static LuaExpr translate(ImTypeVarDispatch imTypeVarDispatch, LuaTranslator tr) {
-        throw new Error("not implemented");
+        // Reaching the backend means specialization never supplied a concrete type for this
+        // dispatch and the code is reachable, since unreachable functions have been removed by now.
+        throw new CompileError(imTypeVarDispatch.attrTrace().attrSource(),
+            "Type class dispatch of " + imTypeVarDispatch.getTypeClassFunc().getName()
+                + " could not be resolved for the Lua target: the concrete type is not available"
+                + " where it is used.");
     }
 
     public static LuaExpr translate(ImCast imCast, LuaTranslator tr) {

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

@@ -907,6 +907,64 @@ public void overloadFromLaterBoundStaysAvailable() {
         );
     }
 
+    /**
+     * A bounded generic which is only declared, never called, stays valid: it is unreachable, so
+     * nothing has to supply a concrete type for it.
+     */
+    @Test
+    public void unusedBoundedGenericFunctionLua() {
+        test().testLua(true).executeProg().lines(
+            "package test",
+            "native testSuccess()",
+            "interface Show<T:>",
+            "    function show(T x) returns string",
+            "implements Show<int>",
+            "    function show(int x) returns string",
+            "        return \"i\"",
+            "function unused<Q: Show>(Q x) returns string",
+            "    return Q.show(x)",
+            "init",
+            "    testSuccess()"
+        );
+    }
+
+    /** The same for a bounded generic class which is never constructed. */
+    @Test
+    public void unusedBoundedGenericClassLua() {
+        test().testLua(true).executeProg().lines(
+            "package test",
+            "native testSuccess()",
+            "interface Show<T:>",
+            "    function show(T x) returns string",
+            "implements Show<int>",
+            "    function show(int x) returns string",
+            "        return \"i\"",
+            "class Unused<Q: Show>",
+            "    function render(Q x) returns string",
+            "        return Q.show(x)",
+            "init",
+            "    testSuccess()"
+        );
+    }
+
+    /** Declared and unused on Jass too, which is where it already worked. */
+    @Test
+    public void unusedBoundedGenericFunction() {
+        testAssertOkLines(true,
+            "package test",
+            "native testSuccess()",
+            "interface Show<T:>",
+            "    function show(T x) returns string",
+            "implements Show<int>",
+            "    function show(int x) returns string",
+            "        return \"i\"",
+            "function unused<Q: Show>(Q x) returns string",
+            "    return Q.show(x)",
+            "init",
+            "    testSuccess()"
+        );
+    }
+
     /** A type parameter is not a value, so it may only appear as the receiver of a requirement. */
     @Test
     public void typeParameterIsNotAValue() {