Preserve tuple specialization class identity

Author: Frotty

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

@@ -281,9 +281,43 @@ public void visit(ImMemberAccess memberAccess) {
                 super.visit(memberAccess);
                 collectGenericNewUse(memberAccess);
             }
+
+            @Override
+            public void visit(ImDealloc dealloc) {
+                super.visit(dealloc);
+                collectGenericNewUse(dealloc);
+            }
+
+            @Override
+            public void visit(ImInstanceof instanceOf) {
+                super.visit(instanceOf);
+                collectGenericNewUse(instanceOf);
+            }
+
+            @Override
+            public void visit(ImTypeIdOfObj typeId) {
+                super.visit(typeId);
+                collectGenericNewUse(typeId);
+            }
+
+            @Override
+            public void visit(ImTypeIdOfClass typeId) {
+                super.visit(typeId);
+                collectGenericNewUse(typeId);
+            }
         });
     }
 
+    private void collectGenericNewUse(ImClassRelatedExprWithClass expression) {
+        ImClassType clazz = expression.getClazz();
+        if (clazz.getTypeArguments().isEmpty()
+            || typeArgumentsContainTypeVariable(clazz.getTypeArguments())
+            || !shouldSpecializeTupleArguments(clazz.getTypeArguments())) {
+            return;
+        }
+        genericsUses.add(new GenericClazzUse(expression));
+    }
+
     private void collectGenericNewUses(Element element) {
         element.accept(new Element.DefaultVisitor() {
             @Override
@@ -1796,7 +1830,8 @@ private ImClass specializeClass(ImClass c, GenericTypes generics) {
         // NEW: Create specialized global variables for this class instantiation
         createSpecializedGlobals(c, generics, typeVars);
 
-        if (genericNewOnly && isConstructionOnlyInstantiation(c)) {
+        if (genericNewOnly && (isConstructionOnlyInstantiation(c)
+            || (specializeTupleValueTypes && genericTypesContainTuple(generics)))) {
             attachSpecializedClassMethods(c, newC, generics);
         }
 

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/lua/translation/LuaTranslator.java

@@ -892,10 +892,16 @@ private void initClassTables(ImClass c) {
         ));
 
         // set typeid metadata:
+        ImClass typeIdClass = c;
+        ImTranslator.Specialisation specialization = imTr.specialisationOf(c);
+        if (specialization != null && specialization.original() instanceof ImClass original) {
+            // Targeted Lua specialization preserves the nominal identity of the erased class.
+            typeIdClass = original;
+        }
         deferMainInit(LuaAst.LuaAssignment(LuaAst.LuaExprFieldAccess(
             LuaAst.LuaExprVarAccess(classVar),
             ExprTranslation.TYPE_ID),
-            LuaAst.LuaExprIntVal("" + prog.attrTypeId().get(c))
+            LuaAst.LuaExprIntVal("" + prog.attrTypeId().get(typeIdClass))
         ));
 
 
@@ -1310,6 +1316,12 @@ private void collectSuperClasses(LuaTableFields superClasses, ImClass c, Set<ImC
         }
         superClasses.add(LuaAst.LuaTableExprField(LuaAst.LuaExprVarAccess(luaClassVar.getFor(c)), LuaAst.LuaExprBoolVal(true)));
         visited.add(c);
+        ImTranslator.Specialisation specialization = imTr.specialisationOf(c);
+        if (specialization != null && specialization.original() instanceof ImClass original) {
+            // A targeted Lua specialization is a representation detail, not a new nominal type.
+            // Keep erased-class runtime checks true without inheriting its fields a second time.
+            collectSuperClasses(superClasses, original, visited);
+        }
         for (ImClassType sc : c.getSuperClasses()) {
             collectSuperClasses(superClasses, sc.getClassDef(), visited);
         }

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

@@ -264,6 +264,54 @@ public void tupleReturnSlotsAreSharedAcrossMultipleInterfaceRoots() throws IOExc
         assertFalse(compiled.contains("tupleEquals"));
     }
 
+    @Test
+    public void tupleSpecializedClassBindsNongenericInterfaceDispatch() throws IOException {
+        test().testLua(true).executeProg().lines(
+            "package Test",
+            "native testSuccess()",
+            "tuple pair(int x, int y)",
+            "interface Producer",
+            "    function produce() returns pair",
+            "class GenericProducer<T:> implements Producer",
+            "    pair stored",
+            "    construct(pair value)",
+            "        stored = value",
+            "    function produce() returns pair",
+            "        return stored",
+            "init",
+            "    Producer producer = new GenericProducer<pair>(pair(4, 5))",
+            "    if producer.produce() == pair(4, 5)",
+            "        testSuccess()"
+        );
+
+        String compiled = compiledLua("tupleSpecializedClassBindsNongenericInterfaceDispatch");
+        assertTrue(compiled.contains("GenericProducer_specialized"));
+        assertFalse(compiled.contains("tupleCopy"));
+    }
+
+    @Test
+    public void tupleSpecializedClassPreservesRuntimeTypeOperations() throws IOException {
+        test().testLua(true).executeProg().lines(
+            "package Test",
+            "native testSuccess()",
+            "tuple pair(int x, int y)",
+            "interface Marker",
+            "class Box<T:> implements Marker",
+            "    T value",
+            "    construct(T initial)",
+            "        value = initial",
+            "init",
+            "    Marker box = new Box<pair>(pair(6, 7))",
+            "    Marker plain = new Box<int>(1)",
+            "    if box instanceof Box and box.typeId == plain.typeId",
+            "        testSuccess()"
+        );
+
+        String compiled = compiledLua("tupleSpecializedClassPreservesRuntimeTypeOperations");
+        assertTrue(compiled.contains("Box_specialized"));
+        assertFalse(compiled.contains("tupleCopy"));
+    }
+
     @Test
     public void tupleReturningCallsAreCapturedBeforeComparison() throws IOException {
         test().testLua(true).executeProg().lines(