More new generic improvements

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

@@ -613,12 +613,12 @@ public void setVal(ImVar v, ILconst val) {
             if (inits != null && !inits.isEmpty()) {
                 ILconst initVal = inits.get(inits.size() - 1).getRight().evaluate(this, EMPTY_LOCAL_STATE);
                 genericStaticScalarVals.put(key, initVal);
-                System.out.println("[GENSTATIC] get " + key + " -> (init) " + initVal);
+                WLogger.trace("[GENSTATIC] get " + key + " -> (init) " + initVal);
                 return initVal;
             }
 
             // fallback: default semantics (if your interpreter expects “unset = null/0”)
-            System.out.println("[GENSTATIC] get " + key + " -> (unset) null");
+            WLogger.trace("[GENSTATIC] get " + key + " -> (unset) null");
             return null;
         }
 

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

@@ -2,12 +2,14 @@
 
 import com.google.common.collect.*;
 import de.peeeq.wurstscript.WLogger;
+import de.peeeq.wurstscript.ast.ClassDef;
 import de.peeeq.wurstscript.ast.PackageOrGlobal;
 import de.peeeq.wurstscript.ast.WPackage;
 import de.peeeq.wurstscript.attributes.CompileError;
 import de.peeeq.wurstscript.jassIm.*;
 import de.peeeq.wurstscript.translation.imtojass.ImAttrType;
 import de.peeeq.wurstscript.translation.imtojass.TypeRewriteMatcher;
+import de.peeeq.wurstscript.translation.lua.translation.RemoveGarbage;
 import org.eclipse.jdt.annotation.Nullable;
 import org.jetbrains.annotations.NotNull;
 
@@ -81,6 +83,26 @@ public void transform() {
         dbg(summary("after removeGenericConstructs"));
 
         dbg(checkDanglingMethodRefs("end"));
+
+        // TODO fix or remove this check
+//        assertNoUnspecializedGenericGlobals();
+    }
+
+    private void assertNoUnspecializedGenericGlobals() {
+        prog.accept(new Element.DefaultVisitor() {
+            @Override public void visit(ImVarAccess va) {
+                super.visit(va);
+                if (globalToClass.containsKey(va.getVar())) {
+                    throw new CompileError(va, "Unspecialized generic global still used: " + va.getVar().getName());
+                }
+            }
+            @Override public void visit(ImVarArrayAccess vaa) {
+                super.visit(vaa);
+                if (globalToClass.containsKey(vaa.getVar())) {
+                    throw new CompileError(vaa, "Unspecialized generic global array still used: " + vaa.getVar().getName());
+                }
+            }
+        });
     }
 
     private void makeNullAssignmentsSafe() {
@@ -152,17 +174,50 @@ private String checkDanglingMethodRefs(String phase) {
         final int[] dangling = {0};
 
         prog.accept(new Element.DefaultVisitor() {
-            @Override public void visit(ImMethodCall mc) {
+            @Override
+            public void visit(ImMethodCall mc) {
+                super.visit(mc);
+
                 ImMethod m = mc.getMethod();
-                if (m != null && !inProg.containsKey(m)) {
-                    dangling[0]++;
-                    dbg("DANGLING methodCall: method=" + m.getName() + " " + id(m)
+                if (m == null) return;
+
+                boolean methodIsGeneric = m.getImplementation() != null && !m.getImplementation().getTypeVariables().isEmpty();
+
+                // If method is generic but call carries no type args, try to infer from receiver type and patch them in.
+                if (methodIsGeneric && mc.getTypeArguments().isEmpty()) {
+                    ImClass owning = m.attrClass();
+                    ImType rt = mc.getReceiver().attrTyp();
+                    if (owning != null && rt instanceof ImClassType) {
+                        ImClassType adapted = adaptToSuperclass((ImClassType) rt, owning);
+                        if (adapted != null && !adapted.getTypeArguments().isEmpty()) {
+                            List<ImTypeArgument> copied = new ArrayList<>(adapted.getTypeArguments().size());
+                            for (ImTypeArgument ta : adapted.getTypeArguments()) copied.add(ta.copy());
+                            mc.getTypeArguments().addAll(0, copied);
+
+                            dbg("Backfilled missing methodCall typeArgs: method=" + m.getName() + " " + id(m)
+                                + " owning=" + owning.getName()
+                                + " recvType=" + rt
+                                + " inferredTA=" + shortTypeArgs(mc.getTypeArguments()));
+                        } else {
+                            dbg("MISSING methodCall typeArgs (cannot infer): method=" + m.getName() + " " + id(m)
+                                + " owning=" + (owning == null ? "null" : owning.getName())
+                                + " recvType=" + rt);
+                        }
+                    } else {
+                        dbg("MISSING methodCall typeArgs (no owning/receiverClassType): method=" + m.getName() + " " + id(m)
+                            + " owning=" + (owning == null ? "null" : owning.getName())
+                            + " recvType=" + shortType(rt));
+                    }
+                }
+
+                if (!mc.getTypeArguments().isEmpty()) {
+                    dbg("COLLECT GenericMethodCall: method=" + m.getName() + " " + id(m)
                         + " impl=" + (m.getImplementation() == null ? "null" : (m.getImplementation().getName() + " " + id(m.getImplementation())))
                         + " owningClass=" + (m.attrClass() == null ? "null" : (m.attrClass().getName() + " " + id(m.attrClass())))
-                        + " receiverType=" + shortType(mc.getReceiver().attrTyp())
-                        + " callTypeArgs=" + shortTypeArgs(mc.getTypeArguments()));
+                        + " recvType=" + shortType(mc.getReceiver().attrTyp())
+                        + " callTA=" + shortTypeArgs(mc.getTypeArguments()));
+                    genericsUses.add(new GenericMethodCall(mc));
                 }
-                super.visit(mc);
             }
         });
 
@@ -226,7 +281,12 @@ private String summary(String phase) {
     private void removeNonSpecializedGlobals() {
         for (ImVar imVar : specializedGlobals.rowKeySet()) {
             prog.getGlobals().remove(imVar);
-            prog.getGlobalInits().remove(imVar);
+            List<ImSet> inits = prog.getGlobalInits().remove(imVar);
+            if (inits != null) {
+                for (ImSet init : inits) {
+                    init.replaceBy(ImHelper.nullExpr());
+                }
+            }
         }
     }
 
@@ -366,29 +426,79 @@ private void moveFunctionsOutOfClass(ImClass c) {
      * These are the "static" fields that need specialization
      */
     private void identifyGenericGlobals() {
-        // Build a map of class name to class for quick lookup
-        Map<String, ImClass> classMap = new HashMap<>();
+        // Only include "relevant" classes: new-generic or subclass of new-generic.
+        Map<String, ImClass> relevantClassMap = buildRelevantClassMap();
+
+        for (ImVar global : prog.getGlobals()) {
+            ImClass owner = resolveOwningClassFromTrace(global, relevantClassMap);
+            if (owner == null) {
+                continue; // not defined inside a class (package/global constant, etc.)
+            }
+
+            // This global belongs to a relevant (new-generic or inheriting) class:
+            globalToClass.put(global, owner);
+            WLogger.trace("Identified generic static-field global: " + global.getName()
+                + " of type " + global.getType()
+                + " belonging to class " + owner.getName());
+        }
+    }
+
+    /**
+     * Build a map of class-name -> ImClass, but only for "relevant" classes:
+     * - the class is new-generic (has typeVariables)
+     * - OR any of its superclasses is new-generic (transitively)
+     */
+    private Map<String, ImClass> buildRelevantClassMap() {
+        Map<String, ImClass> m = new HashMap<>();
+        IdentityHashMap<ImClass, Boolean> memo = new IdentityHashMap<>();
+
         for (ImClass c : prog.getClasses()) {
-            classMap.put(c.getName(), c);
+            if (isNewGenericOrExtendsNewGeneric(c, memo)) {
+                m.put(c.getName(), c);
+            }
         }
+        return m;
+    }
 
-        // Check each global variable to see if it belongs to a generic class
-        for (ImVar global : prog.getGlobals()) {
-            // Global variable names for static fields follow the pattern: ClassName_fieldName
-            String varName = global.getName();
-            int underscoreIdx = varName.indexOf('_');
-            if (underscoreIdx > 0) {
-                String potentialClassName = varName.substring(0, underscoreIdx);
-                ImClass owningClass = classMap.get(potentialClassName);
-
-                if (owningClass != null && !owningClass.getTypeVariables().isEmpty()) {
-                    // This global belongs to a generic class
-                    globalToClass.put(global, owningClass);
-                    WLogger.trace("Identified generic global: " + varName + " of type " + global.getType() +
-                        " belonging to class " + owningClass.getName());
+    private boolean isNewGenericOrExtendsNewGeneric(ImClass c, IdentityHashMap<ImClass, Boolean> memo) {
+        Boolean cached = memo.get(c);
+        if (cached != null) return cached;
+
+        boolean res = !c.getTypeVariables().isEmpty();
+        if (!res) {
+            for (ImClassType sc : c.getSuperClasses()) {
+                ImClass sup = sc.getClassDef();
+                if (sup != null && isNewGenericOrExtendsNewGeneric(sup, memo)) {
+                    res = true;
+                    break;
                 }
             }
         }
+
+        memo.put(c, res);
+        return res;
+    }
+
+    /**
+     * Resolve owning class for a global via trace:
+     * - if the global's trace source is inside a class, return the matching ImClass (if relevant)
+     * - otherwise return null
+     */
+    private @Nullable ImClass resolveOwningClassFromTrace(ImVar global, Map<String, ImClass> relevantClassMap) {
+        if (global.getTrace() == null) return null;
+
+        // This is the only assumption you may need to adapt if your ImTrace API differs:
+        de.peeeq.wurstscript.ast.Element srcObj = global.getTrace(); // expected to be a wurst AST Element
+        if (srcObj == null) return null;
+
+        @Nullable ClassDef classDef = srcObj.attrNearestClassDef();
+        if (classDef == null) return null;
+
+        // Get the class name from the AST (no global-name parsing).
+        String className = classDef.getNameId().getName();
+
+        // Only accept if it is one of the relevant classes (new-generic or inherits new-generic).
+        return relevantClassMap.get(className);
     }
 
     /**
@@ -1169,6 +1279,9 @@ public void eliminate() {
     }
 
     private ImVar ensureSpecializedGlobal(ImVar originalGlobal, ImClass owningClass, GenericTypes concreteGenerics) {
+        concreteGenerics = normalizeToClassArity(concreteGenerics, owningClass, "ensureSpecializedGlobal:" + originalGlobal.getName());
+        if (concreteGenerics == null) return null;
+
         String key = gKey(concreteGenerics);
         ImVar sg = specializedGlobals.get(originalGlobal, key);
         if (sg != null) return sg;
@@ -1229,6 +1342,29 @@ class GenericGlobalArrayAccess implements GenericUse {
         }
     }
 
+    private @Nullable GenericTypes normalizeToClassArity(GenericTypes g, ImClass owningClass, String why) {
+        int need = owningClass.getTypeVariables().size();
+        int have = g.getTypeArguments().size();
+
+        if (have == need) return g;
+
+        if (have < need) {
+            dbg("GEN-ARITY FAIL (" + why + "): class=" + owningClass.getName()
+                + " need=" + need + " have=" + have + " g=" + g);
+            return null;
+        }
+
+        // have > need: take the prefix; this is the common case when the function-context has extra type args.
+        List<ImTypeArgument> cut = new ArrayList<>(need);
+        for (int i = 0; i < need; i++) {
+            cut.add(g.getTypeArguments().get(i).copy());
+        }
+        GenericTypes r = new GenericTypes(cut);
+        dbg("GEN-ARITY TRUNC (" + why + "): class=" + owningClass.getName()
+            + " need=" + need + " have=" + have + " g=" + g + " -> " + r);
+        return r;
+    }
+
     /**
      * NEW: Infer generic types from the enclosing function context
      * For specialized functions, the name contains the type information
@@ -1241,18 +1377,15 @@ private GenericTypes inferGenericsFromFunction(Element element, ImClass owningCl
 
                 GenericTypes specialized = specializedFunctionGenerics.get(func);
                 if (specialized != null) {
-                    return specialized;
+                    return normalizeToClassArity(specialized, owningClass, "specializedFunctionGenerics:" + func.getName());
                 }
 
-                // If function is still generic, we can't decide yet.
                 if (!func.getTypeVariables().isEmpty()) {
                     return null;
                 }
 
                 if (!func.getParameters().isEmpty()) {
-                    ImVar receiver = func.getParameters().get(0);
-                    ImType rt = receiver.getType();
-
+                    ImType rt = func.getParameters().get(0).getType();
                     if (rt instanceof ImClassType) {
                         ImClassType ct = (ImClassType) rt;
                         ImClass raw = ct.getClassDef();
@@ -1263,27 +1396,26 @@ private GenericTypes inferGenericsFromFunction(Element element, ImClass owningCl
                                 raw.isSubclassOf(owningClass);
 
                         if (matches) {
-                            // PRIMARY: use actual type args if present
                             if (!ct.getTypeArguments().isEmpty()) {
                                 List<ImTypeArgument> copied = new ArrayList<>(ct.getTypeArguments().size());
                                 for (ImTypeArgument ta : ct.getTypeArguments()) {
                                     copied.add(JassIm.ImTypeArgument(ta.getType().copy(), ta.getTypeClassBinding()));
                                 }
-                                return new GenericTypes(copied);
+                                return normalizeToClassArity(new GenericTypes(copied), owningClass, "receiverTypeArgs:" + func.getName());
                             }
 
-                            // FALLBACK: parse from specialized class name: Box⟪...⟫
                             GenericTypes fromName = extractGenericsFromClassName(raw.getName());
                             if (fromName != null && !fromName.getTypeArguments().isEmpty()) {
-                                return fromName;
+                                return normalizeToClassArity(fromName, owningClass, "className:" + raw.getName());
                             }
                         }
                     }
                 }
 
                 Map<GenericTypes, ImClass> specs = specializedClasses.row(owningClass);
                 if (specs.size() == 1) {
-                    return specs.keySet().iterator().next();
+                    GenericTypes only = specs.keySet().iterator().next();
+                    return normalizeToClassArity(only, owningClass, "singleSpecializationFallback");
                 }
 
                 return null;
@@ -1294,6 +1426,7 @@ private GenericTypes inferGenericsFromFunction(Element element, ImClass owningCl
     }
 
 
+
     /**
      * NEW: Extract generic types from a specialized class name like "Box⟪integer⟫"
      */

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

@@ -1976,6 +1976,14 @@ private void checkVarRef(NameRef e, boolean dynamicContext) {
         if (e.attrTyp() instanceof WurstTypeNamedScope) {
             WurstTypeNamedScope wtns = (WurstTypeNamedScope) e.attrTyp();
             if (wtns.isStaticRef()) {
+                if (isUsedAsReceiverInExprMember(e) && isNewGenericTypeDef(def)) {
+                    Element parent = e.getParent();
+                    parent.addError(
+                        "Cannot access members via generic type '" + def.getName() + "' without specialization.\n"
+                            + "New generics (<T:>) require a concrete specialization; use an instance receiver instead."
+                    );
+                    return;
+                }
                 if (!isUsedAsReceiverInExprMember(e)) {
                     e.addError("Reference to " + e.getVarName() + " cannot be used as an expression.");
                 } else if (e.getParent() instanceof ExprMemberMethodDotDot) {
@@ -2867,4 +2875,22 @@ private void checkParameter(WParameter param) {
             param.addError("Cannot use arrays as parameters.");
         }
     }
+
+    private static boolean isNewGenericTypeDef(@Nullable NameDef def) {
+        if (!(def instanceof AstElementWithTypeParameters)) {
+            return false;
+        }
+        AstElementWithTypeParameters g = (AstElementWithTypeParameters) def;
+        TypeParamDefs tps = g.getTypeParameters();
+        if (tps == null || tps.size() == 0) {
+            return false;
+        }
+        // Treat "any new TP" as new-generic. Mixed is already diagnosed elsewhere.
+        for (TypeParamDef tp : tps) {
+            if (isTypeParamNewGeneric(tp)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }