Keep the receiver's class binding, and reject two unsupported shapes clearly

A method with its own type parameters was binding the owning class's variables
positionally from the method call's type arguments, overwriting the mapping taken
from the receiver. Calling describe<string> on a Box<int> therefore dispatched the
class's bound through string, which is wrong wherever that instance exists and
silently so. The owning class is now bound only when the function has no type
parameters of its own, which is the constructor case that needed it, and the
receiver's mapping is never overwritten.

Two shapes that cannot work yet reported misleading errors rather than saying so:

A bound on a module type parameter failed with an unknown name. Using a module
copies its body into the class and substitutes type parameters in type positions,
but a requirement is called on the parameter as an expression, so it survives the
copy and no longer resolves. Supporting it needs the copy to rewrite those
receivers, or type parameters on the instantiation, which it has none of.

A requirement carrying its own type parameters was compared using the interface's
and the implementation's distinct definitions, so an identical signature was
rejected with a mismatch between a name and itself. Matching those would mean
pairing them first, which this version does not do.

Author: Frotty

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/intermediatelang/interpreter/ILInterpreter.java

@@ -73,16 +73,21 @@ private static void bindTypeArguments(ProgramState globalState, LocalState local
         if (typeArgs != null) {
             List<ImTypeVar> typeVars = f.getTypeVariables();
             for (int i = 0; i < Math.min(typeVars.size(), typeArgs.size()); i++) {
-                binding.put(typeVars.get(i), inheritIfStillAbstract(globalState, typeArgs.get(i)));
+                binding.putIfAbsent(typeVars.get(i), inheritIfStillAbstract(globalState, typeArgs.get(i)));
             }
             // A generic class holds its type variables on the class, not on its functions, so a
-            // constructor or method is called with arguments it has no variable of its own to bind.
-            // Bind the owning class's variables too, mirroring how type substitutions are built.
-            ImClass owner = owningClass(f);
-            if (owner != null) {
-                ImTypeVars classVars = owner.getTypeVariables();
-                for (int i = 0; i < Math.min(classVars.size(), typeArgs.size()); i++) {
-                    binding.put(classVars.get(i), inheritIfStillAbstract(globalState, typeArgs.get(i)));
+            // constructor is called with arguments it has no variable of its own to bind. Only do
+            // this when the function has no type parameters, because then the arguments are the
+            // class's; a method with its own parameters is called with those instead, and the
+            // class's mapping already came from the receiver, which must not be overwritten.
+            if (typeVars.isEmpty()) {
+                ImClass owner = owningClass(f);
+                if (owner != null) {
+                    ImTypeVars classVars = owner.getTypeVariables();
+                    for (int i = 0; i < Math.min(classVars.size(), typeArgs.size()); i++) {
+                        binding.putIfAbsent(classVars.get(i),
+                            inheritIfStillAbstract(globalState, typeArgs.get(i)));
+                    }
                 }
             }
         }

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/types/TypeClassConstraints.java

@@ -93,6 +93,24 @@ public static boolean hasBounds(TypeParamDef tp) {
             return i.getName() + " extends another interface, which is not supported for bounds:"
                     + " the requirements of a bound are the interface's own functions.";
         }
+        FuncDef generic = firstGenericMethod(i);
+        if (generic != null) {
+            // Matching such a requirement means pairing the interface's method type parameters with
+            // the implementation's, which this version does not do. Say so, rather than comparing
+            // parameters that only look identical and reporting a mismatch between a name and itself.
+            return i.getName() + "." + generic.getName() + " has its own type parameters, which is not"
+                    + " supported for a bound: a requirement may only use the interface's type parameter.";
+        }
+        return null;
+    }
+
+    /** The first requirement declaring type parameters of its own, or null when none does. */
+    public static @Nullable FuncDef firstGenericMethod(InterfaceDef iface) {
+        for (FuncDef method : iface.getMethods()) {
+            if (!method.getTypeParameters().isEmpty()) {
+                return method;
+            }
+        }
         return null;
     }
 

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/validation/WurstValidator.java

@@ -2643,6 +2643,15 @@ private void checkBoundsSatisfied(Element location, TypeParamDef tp, WurstType t
 
     /** Every bound written on a type parameter must be usable as a type class. */
     private void checkTypeParamBounds(TypeParamDef tp) {
+        if (TypeClassConstraints.hasBounds(tp) && tp.attrNearestStructureDef() instanceof ModuleDef) {
+            // Using a module copies its body into the class, replacing the module's type parameters
+            // in type positions. A requirement is called on the parameter itself, which is an
+            // expression, so it survives the copy and no longer resolves. Reject that here rather
+            // than let it fail later as an unknown name.
+            tp.addError("Type class bounds are not supported on a module type parameter."
+                    + "\nMove the bounded generic into a class, or use the module without a bound.");
+            return;
+        }
         for (TypeExpr boundExpr : TypeClassConstraints.boundExprs(tp)) {
             String reason = TypeClassConstraints.invalidBoundReason(boundExpr);
             if (reason != null) {
@@ -2679,6 +2688,13 @@ private void checkInstanceDecl(InstanceDecl decl) {
                     + " for type classes: the requirements of a bound are the interface's own functions.");
             return;
         }
+        FuncDef genericRequirement = TypeClassConstraints.firstGenericMethod(iface);
+        if (genericRequirement != null) {
+            decl.addError(iface.getName() + "." + genericRequirement.getName() + " has its own type parameters,"
+                    + " which is not supported for a type class: a requirement may only use the interface's"
+                    + " type parameter.");
+            return;
+        }
 
         checkInstanceIsNotOrphan(decl, iface, instanceType);
         checkInstanceIsUnique(decl, iface, instanceType);

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

@@ -742,6 +742,64 @@ public void boundForwardedThroughTwoLevels() {
         );
     }
 
+    /** A bound on a module type parameter is rejected: using a module copies its body out of scope. */
+    @Test
+    public void boundOnGenericModule() {
+        testAssertErrorsLines(false, "not supported on a module type parameter",
+            "package test",
+            "native testSuccess()",
+            "interface Show<T:>",
+            "    function show(T x) returns string",
+            "implements Show<int>",
+            "    function show(int x) returns string",
+            "        return \"i\"",
+            "module M<T: Show>",
+            "    function render(T x) returns string",
+            "        return T.show(x)",
+            "class C",
+            "    use M<int>",
+            "init",
+            "    if new C().render(1) == \"i\"",
+            "        testSuccess()"
+        );
+    }
+
+    /** A method with its own type parameters must not disturb the class binding taken from the receiver. */
+    @Test
+    public void classBoundWithIndependentMethodTypeParam() {
+        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 \"int\"",
+            "implements Show<string>",
+            "    function show(string x) returns string",
+            "        return \"string\"",
+            "class Box<T: Show>",
+            "    function describe<U:>(T x, U other) returns string",
+            "        return T.show(x)",
+            "init",
+            "    if new Box<int>().describe<string>(1, \"a\") == \"int\"",
+            "        testSuccess()"
+        );
+    }
+
+    /** A requirement may only use the interface's type parameter, and says so plainly. */
+    @Test
+    public void genericRequirement() {
+        testAssertErrorsLines(false, "has its own type parameters",
+            "package test",
+            "interface Pairing<T:>",
+            "    function pair<U:>(T x, U y) returns U",
+            "implements Pairing<int>",
+            "    function pair<U:>(int x, U y) returns U",
+            "        return y"
+        );
+    }
+
     /** A type parameter is not a value, so it may only appear as the receiver of a requirement. */
     @Test
     public void typeParameterIsNotAValue() {