Fix #356

src/main/java/de/dhbwstuttgart/bytecode/Codegen.java

@@ -2,24 +2,17 @@ package de.dhbwstuttgart.bytecode;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
-import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.Method;
-import de.dhbwstuttgart.syntaxtree.Pattern;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.target.generate.ASTToTargetAST;
-import de.dhbwstuttgart.target.generate.StatementToTargetExpression;
 import de.dhbwstuttgart.target.tree.*;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
-import org.antlr.v4.codegen.Target;
 import org.objectweb.asm.*;
 
 import java.lang.invoke.*;
 import java.lang.reflect.Modifier;
 import java.util.*;
-import java.util.stream.IntStream;
 
 import static org.objectweb.asm.Opcodes.*;
 import static de.dhbwstuttgart.target.tree.expression.TargetBinaryOp.*;
@@ -1469,10 +1462,27 @@ public class Codegen {
             // TODO Check if class is a Record
 
             for (var i = 0; i < cp.subPatterns().size(); i++) {
-                state.mv.visitInsn(DUP);
-
                 var subPattern = cp.subPatterns().get(i);
+
+                state.mv.visitInsn(DUP);
                 extractField(state, cp.type(), i, clazz);
+
+                if (subPattern.type() instanceof TargetRefType || subPattern.type() instanceof TargetExtendsWildcard) {
+                    state.mv.visitInsn(DUP);
+                    state.mv.visitTypeInsn(INSTANCEOF, subPattern.type().getInternalName());
+
+                    var cont = new Label();
+                    state.mv.visitJumpInsn(IFNE, cont);
+                    for (var j = 0; j < depth + 1; j++) {
+                        state.mv.visitInsn(POP);
+                    }
+
+                    state.mv.visitVarInsn(ALOAD, state.switchResultValue.peek());
+                    state.mv.visitLdcInsn(index + 1);
+                    state.mv.visitJumpInsn(GOTO, start);
+                    state.mv.visitLabel(cont);
+                }
+
                 bindPattern(state, subPattern.type(), subPattern, start, index, depth + 1);
             }
             state.mv.visitInsn(POP);
@@ -1558,7 +1568,8 @@ public class Codegen {
                 state.mv.visitInsn(DUP);
 
             extractField(state, cp.type(), i, clazz);
-            state.mv.visitTypeInsn(CHECKCAST, subPattern.type().getInternalName());
+            if (subPattern.type() instanceof TargetRefType)
+                state.mv.visitTypeInsn(CHECKCAST, subPattern.type().getInternalName());
             offset = state.createVariable(subPattern.name(), subPattern.type()).index;
             state.mv.visitVarInsn(ASTORE, offset);
             if (subPattern instanceof TargetComplexPattern cp2) {

src/main/java/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java

@@ -176,8 +176,9 @@ public class ASTFactory {
 		for (Type jreInterface : jreClass.getGenericInterfaces()) {
 			implementedInterfaces.add((RefType) createType(jreInterface));
 		}
-		List<RefType> permittedSubtypes = new ArrayList<>();
+		List<RefType> permittedSubtypes = null;
 		if (jreClass.isSealed()) {
+			permittedSubtypes = new ArrayList<>();
 			for (Class subclass : jreClass.getPermittedSubclasses()) {
 				permittedSubtypes.add((RefType) createType(subclass));
 			}

src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java

@@ -215,6 +215,10 @@ public class ASTToTargetAST {
             // Then check for methods with the same signature
             var resMethods = new HashSet<MethodWithTphs>();
 
+            for (var m1 : methodsWithTphs) {
+                System.out.println(m1.method.name() + " -> " + m1.method.signature().parameters().stream().map(m -> m.pattern().type()).toList());
+            }
+
             outer:
             for (var m1 : methodsWithTphs) {
                 for (var m2 : methodsWithTphs) {
@@ -238,6 +242,12 @@ public class ASTToTargetAST {
             }
         }
 
+        mapOfSignatures.values().forEach(e -> {
+            e.forEach(e2 -> {
+                System.out.println(e2.name() + " -> " + e2.signature().parameters().stream().map(m -> m.pattern().type()).toList());
+            });
+            System.out.println();
+        });
         return mapOfSignatures.values().stream().toList();
     }
 

src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java

@@ -103,34 +103,31 @@ public class TYPE {
 
         var subPatternList = recordPattern.getSubPattern();
         var resolver = new GenericsResolverSameName();
+        var refType = (RefType) recordPattern.getType();
+
+        var allClasses = blockInformation.getAvailableClasses();
+        var typename = refType.getName().getClassName();
+
+        ClassOrInterface allClass = allClasses.stream().filter(c -> c.getClassName().getClassName().equals(typename)).findFirst().orElseThrow();
 
         int counter = 0;
         for (Pattern el : subPatternList){
             if (el instanceof RecordPattern){
                 constraintSet.addAll(addRecursiveParameterConstraints((RecordPattern) el, blockInformation));
-            } else if (recordPattern.getType() instanceof RefType refType){
+            } else {
-                var allClasses = blockInformation.getAvailableClasses();
+                FormalParameter param = (FormalParameter) allClass.getConstructors().getFirst().getParameterList().getParameterAt(counter);
-                var typename = refType.getName().getClassName();
+                FieldAssumption assumption = new FieldAssumption(param.getName(), allClass, param.getType(), blockInformation.getCurrentTypeScope());
 
-                for (ClassOrInterface allClass : allClasses) {
+                var fieldCons = new Pair(el.getType(), assumption.getType(resolver), PairOperator.SMALLERDOT);
-                    var className = allClass.getClassName().getClassName();
+                var recvCons = new Pair(refType, assumption.getReceiverType(resolver), PairOperator.EQUALSDOT);
-                    if(className.equals(typename)){
+                constraintSet.addUndConstraint(fieldCons);
-                        FormalParameter param = (FormalParameter) allClass.getConstructors().getFirst().getParameterList().getParameterAt(counter);
+                constraintSet.addUndConstraint(recvCons);
-                        FieldAssumption assumption = new FieldAssumption(param.getName(), allClass, param.getType(), blockInformation.getCurrentTypeScope());
 
-                        var fieldCons = new Pair(el.getType(), assumption.getType(resolver), PairOperator.EQUALSDOT);
+                for (var i = 0; i < refType.getParaList().size(); i++) {
-                        var recvCons = new Pair(refType, assumption.getReceiverType(resolver), PairOperator.EQUALSDOT);
+                    constraintSet.addUndConstraint(new Pair(refType.getParaList().get(i),
-                        constraintSet.addUndConstraint(fieldCons);
+                            ((RefType)assumption.getReceiverType(resolver)).getParaList().get(i),
-                        constraintSet.addUndConstraint(recvCons);
+                            PairOperator.EQUALSDOT));
-
-                        for (var i = 0; i < refType.getParaList().size(); i++) {
-                            constraintSet.addUndConstraint(new Pair(refType.getParaList().get(i),
-                                    ((RefType)assumption.getReceiverType(resolver)).getParaList().get(i),
-                                    PairOperator.EQUALSDOT));
-                        }
-                    }
                 }
-
             }
             counter++;
         }

src/test/java/TestComplete.java

@@ -940,6 +940,9 @@ public class TestComplete {
 
         var list1 = ConsCtor.newInstance(1, ConsCtor.newInstance(2, ConsCtor.newInstance(3, EmptyCtor.newInstance())));
         var list2 = ConsCtor.newInstance(4, ConsCtor.newInstance(5, ConsCtor.newInstance(6, EmptyCtor.newInstance())));
+
+        var append = clazz.getDeclaredMethod("append", List, List);
+        System.out.println(append.invoke(instance, list1, list2));
     }
 
     @Test