Do not read a type argument by position when the arities differ

Resolving a type class dispatch looked up the type variable's position and then
indexed the type arguments without checking the two lists correspond. A method
which declares its own type parameters alongside its class's is called with only
its own, so position no longer means anything: the class's variable read the
method's argument, and a later variable would have run off the end.

That is the same positional confusion already fixed for the interpreter, still
present in the specializer. Both lookups now bail when the arities disagree, so a
dispatch is left for a pass that has matching arguments rather than resolved
against whichever type happened to sit at that index.

The shape which exposed this, a bounded generic class method with an independent
type parameter, is unsupported on Lua by design and still reports an error there;
it never produced a wrong result, which was verified by making a wrong dispatch
resolvable and confirming it still failed.

Author: Frotty

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

@@ -1153,7 +1153,7 @@ private static void inheritTypeClassBinding(ImTypeArgument ta, ImType original,
             return;
         }
         int index = indexOfTypeVar(typeVars, ref.getTypeVariable());
-        if (index < 0) {
+        if (index < 0 || index >= generics.getTypeArguments().size()) {
             return;
         }
         Map<ImTypeClassFunc, Either<ImMethod, ImFunction>> outer =
@@ -1187,6 +1187,12 @@ private static int indexOfTypeVar(List<ImTypeVar> typeVars, ImTypeVar target) {
 
     private void resolveTypeClassDispatch(ImTypeVarDispatch e, GenericTypes generics, List<ImTypeVar> typeVars) {
         int index = indexOfTypeVar(typeVars, e.getTypeVariable());
+        if (index >= 0 && index >= generics.getTypeArguments().size()) {
+            // Fewer arguments than variables: the variables and the arguments are not in
+            // correspondence here, so position says nothing. Reading one anyway would dispatch
+            // through whichever type happened to sit at that index.
+            return;
+        }
         if (index < 0) {
             // dispatching on a variable of some enclosing generic; it is resolved when that one is
             // specialised.