fix: resolve NPE, type inference, and variable hiding issues

1. FunctionSignature.matchAgainstArgs: Remove duplicate matchAgainstSupertype
   call that was added for debug logging but passed potentially-null mapping
   to the second call, causing NPE on generic static method calls.

2. FuncLink.create: Only add function's own type parameters as type variables
   in the mapping. Enclosing structure type params (class/module) are resolved
   through receiver type matching, not through argument inference.

3. FunctionSignature.fromNameLink: Only add function definition's own type
   parameters as type variables, not enclosing structure params. This prevents
   module type params from appearing as unbound inference variables.

4. FuncLink.withTypeArgBinding: Also check if any type params are being bound
   (even when types don't change structurally, e.g., T bound to itself within
   a generic module) to ensure the FuncLink is updated.

5. WurstValidator: Downgrade variable-hides-superclass-variable from error to
   warning, matching pre-wurstscript#1098 behavior.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Donach

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());
     }
 
 
@@ -234,14 +240,13 @@ public WurstType getVarargType() {
         for (int i = 0; i < argTypes.size(); i++) {
             WurstType pt = getParamType(i);
             WurstType at = argTypes.get(i);
-            mapping = at.matchAgainstSupertype(pt, location, mapping, VariablePosition.RIGHT);
             VariableBinding before = mapping;
-            VariableBinding after = at.matchAgainstSupertype(pt, location, mapping, VariablePosition.RIGHT);
+            mapping = at.matchAgainstSupertype(pt, location, mapping, VariablePosition.RIGHT);
+            VariableBinding after = mapping;
             WLogger.trace(() -> "[IMPLCONV]   vb " + System.identityHashCode(before)
                 + " -> " + (after == null ? "null" : System.identityHashCode(after))
                 + " sameObj=" + (before == after)
                 + " pt=" + pt + " at=" + at);
-            mapping = after;
             if (mapping == null) return null;
 
         }

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

@@ -1861,7 +1861,7 @@ private void checkFieldShadowing(ClassDef c) {
                     ClassDef superOwner = (ClassDef) owner;
                     if (isStrictSuperclassOf(superOwner, c)) {
                         // produce the requested error text
-                        def.addError("Variable " + name + " in class " + c.getName()
+                        def.addWarning("Variable " + name + " in class " + c.getName()
                             + " hides variable " + name + " from superclass " + superOwner.getName());
                         // one error per conflicting ancestor is enough
                         break;

de.peeeq.wurstscript/wurst_run.args

@@ -0,0 +1,3 @@
+-runcompiletimefunctions
+-injectobjects
+-stacktraces