fixes & regression test

Author: Frotty

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/attributes/names/FuncLink.java

@@ -69,8 +69,11 @@ public static FuncLink create(FunctionDefinition func, WScope definedIn) {
         WurstType returnType = func.attrReturnTyp();
         WurstType receiverType = calcReceiverType(definedIn, func);
 
-        // Seed mapping with ALL visible type vars (not just the function's)
-        VariableBinding mapping = VariableBinding.emptyMapping().withTypeVariables(typeParams);
+        // Only the function's OWN type params need inference via argument matching.
+        // Enclosing structure type params (class/module) are resolved through
+        // receiver type matching in matchDefLinkReceiver, not through inference.
+        List<TypeParamDef> ownTypeParams = typeParams(func).collect(Collectors.toList());
+        VariableBinding mapping = VariableBinding.emptyMapping().withTypeVariables(ownTypeParams);
 
         return new FuncLink(visibility, definedIn, typeParams, receiverType, func, paramNames, paramTypes, returnType, mapping);
     }
@@ -182,6 +185,16 @@ public FuncLink withTypeArgBinding(Element context, VariableBinding binding) {
         }
         WurstType newReceiverType = adjustType(context, getReceiverType(), binding);
         changed = changed || newReceiverType != getReceiverType();
+        // Also check if any type params are being bound (even if types don't
+        // change structurally — e.g., T bound to itself within a generic module)
+        if (!changed) {
+            for (TypeParamDef tp : getTypeParams()) {
+                if (binding.contains(tp)) {
+                    changed = true;
+                    break;
+                }
+            }
+        }
         if (changed) {
             // remove type parameters that are now bound:
             List<TypeParamDef> newTypeParams = new ArrayList<>();

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

@@ -118,8 +118,14 @@ public static List<String> getParamNames(WParameters parameters) {
 
     public static FunctionSignature fromNameLink(FuncLink f) {
         VariableBinding mapping = f.getVariableBinding();
-        mapping = mapping.withTypeVariables(f.getTypeParams());
-        return new FunctionSignature(f.getDef(), mapping, f.getReceiverType(), f.getName(), f.getParameterTypes(), getParamNames(f.getDef().getParameters()), f.getReturnType());
+        // Only add the function definition's own type parameters as type variables
+        // for inference. Enclosing structure type params (from class/module) are
+        // resolved through receiver type matching, not argument inference.
+        FunctionDefinition def = f.getDef();
+        if (def instanceof AstElementWithTypeParameters) {
+            mapping = mapping.withTypeVariables(((AstElementWithTypeParameters) def).getTypeParameters());
+        }
+        return new FunctionSignature(def, mapping, f.getReceiverType(), f.getName(), f.getParameterTypes(), getParamNames(def.getParameters()), f.getReturnType());
     }
 
 

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

@@ -47,6 +47,76 @@ public void biggerModule() {
         );
     }
 
+    // Regression: FuncLink.create() was seeding the mapping with ALL visible type params
+    // (including enclosing module/class type params), causing them to appear as unbound
+    // inference variables on generic function calls. Only the function's own type params
+    // should be seeded; module type params are resolved via receiver type matching.
+    @Test
+    public void genericModuleFunctionWithOwnTypeParam() {
+        testAssertOkLines(false,
+                "package test",
+                "    native testSuccess()",
+                "    module M<T>",
+                "        T value",
+                "        function map<S>(S s) returns S",
+                "            return s",
+                "    class C",
+                "        use M<int>",
+                "    init",
+                "        C c = new C",
+                "        string r = c.map(\"hello\")",
+                "        if r == \"hello\"",
+                "            testSuccess()",
+                "endpackage"
+        );
+    }
+
+    // Regression: FuncLink.withTypeArgBinding() only detected structural type changes,
+    // missing the case where a type param is bound to itself (e.g. T→T in a generic class
+    // using a generic module). The FuncLink was not updated, leaving stale type params.
+    @Test
+    public void genericModuleInGenericClassGet() {
+        testAssertOkLines(false,
+                "package test",
+                "    native testSuccess()",
+                "    module M<T>",
+                "        T value",
+                "        function get() returns T",
+                "            return value",
+                "    class C<S>",
+                "        use M<S>",
+                "    init",
+                "        C<int> c = new C<int>",
+                "        c.value = 42",
+                "        int v = c.get()",
+                "        if v == 42",
+                "            testSuccess()",
+                "endpackage"
+        );
+    }
+
+    // Regression: static generic function in a generic module caused NPE due to
+    // duplicate matchAgainstSupertype call passing potentially-null mapping to the
+    // second call. FunctionSignature.fromNameLink also incorrectly added enclosing
+    // module type params as inference variables.
+    @Test
+    public void staticGenericFunctionInGenericModule() {
+        testAssertOkLines(false,
+                "package test",
+                "    native testSuccess()",
+                "    module M<T>",
+                "        static function wrap<S>(S s) returns S",
+                "            return s",
+                "    class C",
+                "        use M<int>",
+                "    init",
+                "        int x = C.wrap(99)",
+                "        if x == 99",
+                "            testSuccess()",
+                "endpackage"
+        );
+    }
+
     @Test
     public void genericInception() {
         testAssertOkLines(false,