Fix #356

modified:   src/test/java/AllgemeinTest.java

.gitea/workflows/build_and_test.yml

@@ -15,7 +15,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
-          java-version: '21'
+          java-version: '22'
           cache: 'maven'
       - name: Compile project
         run: |

resources/AllgemeinTest/Box.jav

@@ -1,9 +1,12 @@
-public class Box<A> {
+public class Box {
 
-	A a;
+	a;
 
 	public Box() { }
-	public Box(A a) {
+	public Box(a) {
 		//this.a = a;
 	}
+	set(x) {
+	  a = x;
+	}
 }

resources/bytecode/javFiles/OverloadNestedPattern.jav

@@ -0,0 +1,20 @@
+import java.lang.Object;
+import java.lang.Integer;
+import java.lang.Float;
+
+public record R(Object nested) {}
+
+public class OverloadNestedPattern {
+
+    public Integer m(R(R(Integer a)), R(Integer b)) {
+        return 1;
+    }
+
+    public Integer m(R(R(Float a)), R(Float b)) {
+        return 2;
+    }
+
+    public Integer m(R(Integer a), R(Integer b)) {
+        return 3;
+    }
+}

resources/bytecode/javFiles/OverloadPattern.jav

@@ -5,13 +5,29 @@ import java.lang.Float;
 public record Point(Number x, Number y) {}
 
 public class OverloadPattern {
-    public m(Point(x, y), Point(z, a)) {
-        return x + y + z + a;
+    public Number m(Point(Integer x, Integer y), Point(Float a, Float b)) {
+        return 1;
     }
 
-    /*public m(Point(Float x, Float y)) {
-        return x * y;
-    }*/
+    public Number m(Point(Integer x, Integer y), Point(Integer a, Integer b)) {
+        return 2;
+    }
+
+    public Number m(Point(Float x, Float y), Point(Integer a, Integer b)) {
+        return 3;
+    }
+
+    public Number m(Point(Float x, Float y), Point(Float a, Float b)) {
+        return 4;
+    }
+
+    public Number m(Point(Integer x, Integer y)) {
+        return 5;
+    }
+
+    public Number m(Point(Float x, Float y)) {
+        return 6;
+    }
 
     public m(Integer x) {
         return x;

resources/bytecode/javFiles/PaternMatchingHaskellStyle.jav

@@ -1,14 +0,0 @@
-sealed interface List<T> permits LinkedElem, Elem {}
-
-public record LinkedElem<T>(T a, List<T> l) implements List<T> {}
-public record Elem<T>(T a) implements List<T> {}
-
-public class PaternMatchingHaskellStyle {
-   public append(LinkedElem(a, Elem(e)), l2) {
-   	  return new LinkedElem<>(a, new LinkedElem<>(e, l2));
-   }
-
-   public append(LinkedElem(a, r), l2) {
-   	  return new LinkedElem<>(a, append(r, l2));
-   }
-}

resources/bytecode/javFiles/PatternMatchingHaskellStyle.jav

@@ -0,0 +1,21 @@
+import java.lang.Boolean;
+
+sealed interface List<T> permits LinkedElem, Elem {}
+
+public record LinkedElem<T>(T a, List<T> l) implements List<T> {}
+public record Elem<T>(T a) implements List<T> {}
+
+public class PatternMatchingHaskellStyle {
+
+    public append(LinkedElem(a, b), list2) {
+        return handleAppend(a, b, list2);
+    }
+
+    private handleAppend(a, Elem(e), list2) {
+        return new LinkedElem<>(a, new LinkedElem<>(e, list2));
+    }
+
+    private handleAppend(a, LinkedElem(e,r), list2) {
+        return new LinkedElem<>(a, append(new LinkedElem(e, r), list2));
+    }
+}

resources/bytecode/javFiles/PatternMatchingListAppend.jav

@@ -0,0 +1,26 @@
+import java.lang.Boolean;
+import java.lang.Object;
+
+sealed interface List<T> permits Cons, Empty {}
+
+public record Cons<T>(T a, List<T> l) implements List<T> {}
+public record Empty<T>() implements List<T> {}
+
+public class PatternMatchingListAppend {
+
+    public append(Cons(a, b), list2) {
+        return new Cons<>(a, append(b, list2));
+    }
+
+    public append(Empty(), list2) {
+        return list2;
+    }
+
+    /*public append(a, list2) {
+        switch(a) {
+            case Cons(x, y) -> ...
+            case Empty() ->
+        }
+    }*/
+
+}

resources/bytecode/javFiles/SwitchNestedValue.jav

@@ -0,0 +1,14 @@
+import java.lang.Object;
+import java.lang.Integer;
+
+public record R(Integer i) {}
+
+public class SwitchNestedValue {
+    public main(r) {
+        return switch(r) {
+            case R(10) -> 1;
+            case R(20) -> 2;
+            case R(i) -> 3;
+        };
+    }
+}

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.*;
@@ -109,6 +102,10 @@ public class Codegen {
             this.scope = this.scope.parent;
         }
 
+        LocalVar createVariable(TargetType type) {
+            return createVariable("__var" + this.localCounter, type);
+        }
+
         LocalVar createVariable(String name, TargetType type) {
             var local = new LocalVar(localCounter, name, type);
             scope.add(local);
@@ -1393,8 +1390,10 @@ public class Codegen {
 
         state.breakStack.pop();
         if (aSwitch.isExpression()) {
+            if (aSwitch.type() != null) {
                 mv.visitVarInsn(ALOAD, state.switchResultValue.peek());
                 unboxPrimitive(state, aSwitch.type());
+            }
             state.popSwitch();
         }
 
@@ -1431,7 +1430,24 @@ public class Codegen {
             state.mv.visitTypeInsn(CHECKCAST, pat.type().getInternalName());
         }
 
-        if (pat instanceof TargetTypePattern sp) {
+        if (pat instanceof TargetExpressionPattern ep) {
+            var cur = state.createVariable(pat.type());
+            state.mv.visitVarInsn(ASTORE, cur.index);
+
+            var expr = new Equal(pat.type(), new TargetLocalVar(cur.type, cur.name), ep.expression());
+            generate(state, expr);
+
+            var cont = new Label();
+            state.mv.visitJumpInsn(IFNE, cont);
+            for (var i = 0; i < depth - 1; i++) {
+                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);
+        } else if (pat instanceof TargetTypePattern sp) {
             var local = state.createVariable(sp.name(), sp.type());
             state.mv.visitVarInsn(ASTORE, local.index);
         } else if (pat instanceof TargetComplexPattern cp) {
@@ -1446,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);
@@ -1535,6 +1568,7 @@ public class Codegen {
                 state.mv.visitInsn(DUP);
 
             extractField(state, cp.type(), i, clazz);
+            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);

src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java

@@ -468,7 +468,7 @@ public class StatementGenerator {
         case RPatternContext rPattern:
             RecordPatternContext recordPattern = rPattern.recordPattern();
             return convert(recordPattern);
-            case Java17Parser.LPatternContext patternContext: return new LiteralPattern(TypePlaceholder.fresh(patternContext.start), patternContext.literal().get(0).getText(), patternContext.start);
+            case Java17Parser.LPatternContext patternContext: return new LiteralPattern(TypePlaceholder.fresh(patternContext.start), convert(patternContext.literal().get(0)), patternContext.start);
 
             default:
                 throw new NotImplementedException();
@@ -477,7 +477,8 @@ public class StatementGenerator {
     }
 
     private RecordPattern convert(RecordPatternContext recordPatternCtx) {
-        List<PatternContext> subPatternCtx = recordPatternCtx.recordStructurePattern().recordComponentPatternList().pattern();
+        var cpl = recordPatternCtx.recordStructurePattern().recordComponentPatternList();
+        List<PatternContext> subPatternCtx = cpl == null ? List.of() : cpl.pattern();
         List<Pattern> subPattern = subPatternCtx.stream().map(this::convert).collect(Collectors.toList());
         IdentifierContext identifierCtx = recordPatternCtx.identifier();
         var text = (identifierCtx != null) ? identifierCtx.getText() : null;

src/main/java/de/dhbwstuttgart/syntaxtree/ASTVisitor.java

@@ -10,6 +10,8 @@ public interface ASTVisitor extends StatementVisitor{
 
     void visit(FormalParameter formalParameter);
 
+    void visit(LiteralPattern literalPattern);
+
     void visit(GenericDeclarationList genericTypeVars);
 
     void visit(Field field);

src/main/java/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java

@@ -37,6 +37,11 @@ public abstract class AbstractASTWalker implements ASTVisitor {
         formalParameter.getType().accept((ASTVisitor) this);
     }
 
+    @Override
+    public void visit(LiteralPattern literalPattern) {
+
+    }
+
     @Override
     public void visit(GenericDeclarationList genericTypeVars) {
         Iterator<GenericTypeVar> genericIterator = genericTypeVars.iterator();

src/main/java/de/dhbwstuttgart/syntaxtree/LiteralPattern.java

@@ -12,15 +12,15 @@ import org.antlr.v4.runtime.Token;
 
 public class LiteralPattern extends FormalParameter
 {
-    public final Object value;
-    public LiteralPattern(RefTypeOrTPHOrWildcardOrGeneric type, Object value, Token offset) {
-        super((String) value, type, offset);
+    public final Expression value;
+    public LiteralPattern(RefTypeOrTPHOrWildcardOrGeneric type, Expression value, Token offset) {
+        super(null, type, offset);
 
         this.value = value;
     }
     @Override
     public FormalParameter withType(RefTypeOrTPHOrWildcardOrGeneric type) {
-        return null;
+        return new LiteralPattern(type, value, getOffset());
     }
     @Override
     public void accept(ASTVisitor visitor) {

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

@@ -34,7 +34,6 @@ public class ASTFactory {
 	private static final HashMap<java.lang.Class, ClassOrInterface> cache = new HashMap<>();
 
 	public static ClassOrInterface createClass(java.lang.Class jreClass) {
-		System.out.println(jreClass);
 		if (cache.containsKey(jreClass))
 			return cache.get(jreClass);
 
@@ -174,12 +173,12 @@ public class ASTFactory {
 			superClass = (RefType) createType(java.lang.Object.class);
 		}
 		List<RefType> implementedInterfaces = new ArrayList<>();
-		System.out.println(jreClass);
 		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/syntaxtree/visual/OutputGenerator.java

@@ -57,6 +57,11 @@ public class OutputGenerator implements ASTVisitor {
         out.append(formalParameter.getName());
     }
 
+    @Override
+    public void visit(LiteralPattern literalPattern) {
+        literalPattern.value.accept(this);
+    }
+
     @Override
     public void visit(GenericDeclarationList genericTypeVars) {
         Iterator<GenericTypeVar> genericIterator = genericTypeVars.iterator();
@@ -508,12 +513,11 @@ public class OutputGenerator implements ASTVisitor {
         aRecordPattern.getType().accept(this);
         out.append("(");
         List<Pattern> subPatterns = aRecordPattern.getSubPattern();
-        int i;
-        for (i = 0; i < subPatterns.size() - 1; i++) {
+        for (var i = 0; i < subPatterns.size(); i++) {
             subPatterns.get(i).accept(this);
+            if (i < subPatterns.size() - 1)
                 out.append(", ");
         }
-        subPatterns.get(i).accept(this);
         String name;
         if ((name = aRecordPattern.getName()) != null)
             out.append(name);

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

@@ -1,10 +1,10 @@
 package de.dhbwstuttgart.target.generate;
 
-import de.dhbwstuttgart.bytecode.CodeGenException;
 import de.dhbwstuttgart.bytecode.FunNGenerator;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.environment.ByteArrayClassLoader;
 import de.dhbwstuttgart.environment.IByteArrayClassLoader;
+import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.*;
@@ -17,7 +17,7 @@ import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
 import de.dhbwstuttgart.typeinference.result.*;
 
-import java.sql.Array;
+import java.lang.annotation.Target;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -145,23 +145,83 @@ public class ASTToTargetAST {
         return ret;
     }
 
+    // This is used to serve as a custom equality to signature that performs a weak check without going into record patterns.
+    // The two signatures are considered equal if all the argument types match.
+    // This also turns equal if both types implement a sealed super interface
+    class PatternSignature {
+        final TargetMethod.Signature signature;
+        final String name;
+        PatternSignature(String name, TargetMethod.Signature signature) {
+            this.signature = signature;
+            this.name = name;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (!(o instanceof PatternSignature other)) return false;
+            if (!this.name.equals(other.name)) return false;
+            if (other.signature.parameters().size() != signature.parameters().size()) return false;
+            for (var i = 0; i < signature.parameters().size(); i++) {
+                var p1 = signature.parameters().get(i).pattern().type();
+                var p2 = other.signature.parameters().get(i).pattern().type();
+                if (p1 instanceof TargetGenericType && p2 instanceof TargetGenericType) continue;
+                if (!p1.equals(p2) && commonSuperInterfaceTypes(p1, p2).isEmpty()) return false;
+            }
+            return true;
+        }
+
+        @Override
+        public int hashCode() {
+            return signature.parameters().size();
+        }
+    }
+
+    // This finds a common sealed interface type to group together methods that use different records
+    private List<ClassOrInterface> commonSuperInterfaceTypes(TargetType a, TargetType b) {
+        if (a instanceof TargetGenericType && b instanceof TargetGenericType) return List.of(ASTFactory.createClass(Object.class));
+        if (a instanceof TargetRefType ta && b instanceof TargetRefType tb) {
+            var res = new HashSet<ClassOrInterface>();
+
+            var cla = compiler.getClass(new JavaClassName(ta.name()));
+            var clb = compiler.getClass(new JavaClassName(tb.name()));
+
+            while (!cla.equals(ASTFactory.createClass(Object.class))) {
+                var clb2 = clb;
+                while (!clb2.equals(ASTFactory.createClass(Object.class))) {
+                    for (var intfa : cla.getSuperInterfaces()) {
+                        for (var intfb : clb.getSuperInterfaces()) {
+                            if (intfa.equals(intfb)) {
+                                var clintf = compiler.getClass(intfa.getName());
+                                if (clintf.isSealed()) {
+                                    res.add(clintf);
+                                }
+                            }
+                        }
+                    }
+                    clb2 = compiler.getClass(clb2.getSuperClass().getName());
+                }
+                cla = compiler.getClass(cla.getSuperClass().getName());
+            }
+            return res.stream().toList();
+        }
+        return List.of();
+    }
+
     public List<List<TargetMethod>> groupOverloads(ClassOrInterface input, List<Method> methods) {
-        var res = new ArrayList<List<TargetMethod>>();
+        var mapOfSignatures = new HashMap<PatternSignature, List<TargetMethod>>();
         for (var method : methods) {
             // Convert all methods
             var methodsWithTphs = convert(input, method);
             // Then check for methods with the same signature
-            var mapOfSignatures = new HashMap<TargetMethod.Signature, List<MethodWithTphs>>();
-            for (var m : methodsWithTphs) {
-                var methodsWithSameSignature = mapOfSignatures.getOrDefault(m.method.signature(), new ArrayList<>());
-                methodsWithSameSignature.add(m);
-                mapOfSignatures.put(m.method.signature(), methodsWithSameSignature);
+            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());
             }
 
-            var resMethods = new HashSet<TargetMethod>();
-            for (var methodsWithSignature : mapOfSignatures.values()) {
-                outer: for (var m1 : methodsWithSignature) {
-                    for (var m2 : methodsWithSignature) {
+            outer:
+            for (var m1 : methodsWithTphs) {
+                for (var m2 : methodsWithTphs) {
                     for (var i = 0; i < m1.args.size(); i++) {
                         var arg1 = m1.args.get(i);
                         var arg2 = m2.args.get(i);
@@ -171,12 +231,24 @@ public class ASTToTargetAST {
                         }
                     }
                 }
-                    resMethods.add(m1.method);
+                resMethods.add(m1);
+            }
+
+            for (var m : resMethods) {
+                var signature = new PatternSignature(m.method.name(), m.method.signature());
+                var methodsWithSameSignature = mapOfSignatures.getOrDefault(signature, new ArrayList<>());
+                methodsWithSameSignature.add(m.method);
+                mapOfSignatures.put(signature, methodsWithSameSignature);
             }
         }
-            res.add(resMethods.stream().toList());
-        }
-        return res;
+
+        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();
     }
 
     public TargetStructure convert(ClassOrInterface input) {
@@ -223,9 +295,14 @@ public class ASTToTargetAST {
     }
 
     public List<MethodParameter> convert(ParameterList input, GenerateGenerics generics) {
-        return input.getFormalparalist().stream().map(param ->
-            new MethodParameter((TargetPattern) convert(param))
-        ).toList();
+        var res = new ArrayList<MethodParameter>();
+        for (var i = 0; i < input.getFormalparalist().size(); i++) {
+            var param = input.getFormalparalist().get(i);
+            var pattern = (TargetPattern) convert(param);
+            if (pattern instanceof TargetComplexPattern) pattern = pattern.withName("__var" + i);
+            res.add(new MethodParameter(pattern));
+        }
+        return res;
     }
 
     private boolean hasGeneric(Set<TargetGeneric> generics, GenericRefType type) {
@@ -295,10 +372,86 @@ public class ASTToTargetAST {
         }
     }
 
+    private TargetType unwrap(TargetType type) {
+        if (type instanceof TargetRefType ref) {
+            if (!ref.params().isEmpty()) return new TargetRefType(ref.name());
+        }
+        return type;
+    }
+
+    private TargetExpression generatePatternOverloadsRec(int offset, TargetExpression switchExpr, List<TargetLocalVar> params, List<TargetPattern> patterns, List<TargetMethod> methods, TargetType classType) {
+        if (methods.isEmpty()) throw new DebugException("Couldn't find a candidate for switch overloading");
+        if (methods.size() == 1) {
+            var method = methods.getFirst();
+            var mParams = new ArrayList<TargetExpression>();
+            for (var i = 0; i < params.size(); i++) {
+                var tpe = method.signature().parameters().get(i).pattern().type();
+                mParams.add(new TargetLocalVar(tpe, params.get(i).name()));
+            }
+            TargetExpression caseBody = new TargetMethodCall(
+                method.signature().returnType(),
+                new TargetThis(classType),
+                mParams,
+                classType,
+                method.name(),
+                false, false, method.isPrivate()
+            );
+            if (method.signature().returnType() != null) {
+                caseBody = new TargetReturn(caseBody);
+            }
+            return caseBody;
+        }
+
+        var cases = new ArrayList<TargetSwitch.Case>();
+        var usedPatterns = new HashSet<TargetType>();
+
+        for (var method : methods) {
+            var patternsRec = new ArrayList<>(patterns);
+
+            TargetExpression expr = null;
+            var i = 0;
+            for (var param : method.signature().parameters()) {
+                if (i == offset) {
+                    patternsRec.add(param.pattern());
+                }
+                if (i > offset) {
+                    // Find next pattern
+                    expr = params.get(i);
+                    break;
+                }
+                i++;
+            }
+
+            var lastPattern = patternsRec.getLast();
+            var type = unwrap(lastPattern.type());
+            if (usedPatterns.contains(type)) continue;
+            usedPatterns.add(type);
+
+            var candidates = methods.stream().filter(m -> {
+                var j = 0;
+                for (var param : m.signature().parameters()) {
+                    if (j >= patternsRec.size()) return true;
+                    if (!patternsRec.get(j).type().equals(param.pattern().type())) return false;
+                    j++;
+                }
+                return true;
+            }).toList();
+
+            var caseBody = generatePatternOverloadsRec(offset + 1, expr, params, patternsRec, candidates, classType);
+            var body = new TargetBlock(List.of(caseBody));
+            var case_ = new TargetSwitch.Case(List.of(lastPattern), body);
+
+            cases.add(case_);
+        }
+
+        return new TargetSwitch(switchExpr, cases, null, true);
+    }
+
     private List<TargetMethod> generatePatternOverloads(ClassOrInterface clazz, List<TargetMethod> overloadedMethods) {
         if (overloadedMethods.size() <= 1) return overloadedMethods;
         // Check if we have a pattern as a parameter
         var firstMethod = overloadedMethods.getFirst();
+        var secondMethod = overloadedMethods.get(1);
         if (firstMethod.signature().parameters().stream().noneMatch(mp -> mp.pattern() instanceof TargetComplexPattern)) return overloadedMethods;
         // Rename existing methods
 
@@ -308,8 +461,44 @@ public class ASTToTargetAST {
             res.add(new TargetMethod(method.access(), name, method.block(), method.signature(), method.txSignature()));
         }
 
-        // Generate dispatch method
+        var signatureParams = new ArrayList<MethodParameter>();
+        for (var i = 0; i < firstMethod.signature().parameters().size(); i++) {
+            var p1 = firstMethod.signature().parameters().get(i).pattern();
+            var t1 = p1.type();
+            var t2 = secondMethod.signature().parameters().get(i).pattern().type();
+            var commonSubTypes = new HashSet<>(commonSuperInterfaceTypes(t1, t2));
+            for (var m : overloadedMethods.subList(2, overloadedMethods.size())) {
+                var t3 = m.signature().parameters().get(i).pattern().type();
+                commonSubTypes.retainAll(commonSuperInterfaceTypes(t1, t3));
+            }
+            if (commonSubTypes.size() != 1) throw new DebugException("Invalid overload");
+            // TODO accept multiple types
+            var superType = commonSubTypes.iterator().next();
+            String name;
+            if (p1 instanceof TargetComplexPattern) name = "__var" + i;
+            else name = p1.name();
+            signatureParams.add(new MethodParameter(new TargetRefType(superType.getClassName().toString()), name));
+        }
 
+        var commonSubTypes = new HashSet<>(commonSuperInterfaceTypes(firstMethod.signature().returnType(), secondMethod.signature().returnType()));
+        for (var m : overloadedMethods.subList(2, overloadedMethods.size())) {
+            commonSubTypes.retainAll(commonSuperInterfaceTypes(firstMethod.signature().returnType(), m.signature().returnType()));
+        }
+        var returnType = commonSubTypes.isEmpty() ? TargetType.Object : new TargetRefType(commonSubTypes.iterator().next().getClassName().toString());
+
+        var parameters = signatureParams.stream().map( p -> new TargetLocalVar(p.pattern().type(), p.pattern().name())).toList();
+        //var patterns = List.of((TargetComplexPattern) firstMethod.signature().parameters().stream()
+        //       .filter(p -> p.pattern() instanceof TargetComplexPattern).findFirst().orElseThrow().pattern());
+
+        // Generate dispatch method
+        var classType = new TargetRefType(clazz.getClassName().getClassName());
+        var stmt = generatePatternOverloadsRec(0, new TargetLocalVar(signatureParams.getFirst().pattern().type(), signatureParams.getFirst().pattern().name()), parameters, List.of(), res, classType);
+        var block = new TargetBlock(List.of(stmt));
+
+        var signature = new TargetMethod.Signature(Set.of(), signatureParams, returnType);
+        var bridgeMethod = new TargetMethod(firstMethod.access(), firstMethod.name(), block, signature, firstMethod.txSignature());
+
+        res.add(bridgeMethod);
         return res;
     }
 
@@ -391,7 +580,6 @@ public class ASTToTargetAST {
             var txSignature = new TargetMethod.Signature(txMethodGenerics, txParams, convert(method.getReturnType(), this.generics.txGenerics));
 
             signatures.add(new Signature(javaSignature, txSignature, generics));
-            System.out.println(javaSignature);
             var listOfGenerics = collectedGenerics.getOrDefault(javaSignature, new ArrayList<>());
             listOfGenerics.add(generics);
             collectedGenerics.put(javaSignature, listOfGenerics);
@@ -414,7 +602,9 @@ public class ASTToTargetAST {
         var list = new ArrayList<MethodParameter>();
         for (var i = 0; i < paraList.getFormalparalist().size(); i++) {
             var param = paraList.getParameterAt(i);
-            list.add(new MethodParameter((TargetPattern) convert(param)).withType(convert(superList.getParameterAt(i).getType(), generics)));
+            var pattern = (TargetPattern) convert(param);
+            if (pattern instanceof TargetComplexPattern) pattern = pattern.withName("__var" + i);
+            list.add(new MethodParameter(pattern).withType(convert(superList.getParameterAt(i).getType(), generics)));
         }
         return list;
     }

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

@@ -1,10 +1,7 @@
 package de.dhbwstuttgart.target.generate;
 
 import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.Constructor;
-import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.syntaxtree.type.Void;
@@ -170,6 +167,25 @@ public abstract class GenerateGenerics {
         else if (to instanceof RefType t) concreteTypes.put(new TPH(from), t);
     }*/
 
+    Set<TPH> findTypeVariables(ParameterList params) {
+        var res = new HashSet<TPH>();
+        for (var param : params.getFormalparalist()) {
+            res.addAll(findTypeVariables(param));
+        }
+        return res;
+    }
+
+    Set<TPH> findTypeVariables(Pattern pattern) {
+        var res = new HashSet<TPH>();
+        if (pattern instanceof RecordPattern rp) {
+            for (var subPattern : rp.getSubPattern()) {
+                res.addAll(findTypeVariables(subPattern));
+            }
+        }
+        res.addAll(findTypeVariables(pattern.getType()));
+        return res;
+    }
+
     Set<TPH> findTypeVariables(RefTypeOrTPHOrWildcardOrGeneric type) {
         var result = new HashSet<TPH>();
         if (type instanceof TypePlaceholder tph) {
@@ -506,9 +522,7 @@ public abstract class GenerateGenerics {
 
         if (!(method instanceof Constructor))
             typeVariables.addAll(findTypeVariables(method.getReturnType()));
-        for (var arg : method.getParameterList().getFormalparalist()) {
-            typeVariables.addAll(findTypeVariables(arg.getType()));
-        }
+        typeVariables.addAll(findTypeVariables(method.getParameterList()));
 
         if (method.block != null)
             method.block.accept(new TracingStatementVisitor() {
@@ -572,9 +586,7 @@ public abstract class GenerateGenerics {
 
         var usedTphs = new HashSet<TPH>();
         // For eliminating inner type variables we need to figure out which ones are actually used
-        for (var param : method.getParameterList().getFormalparalist()) {
-            usedTphs.addAll(findTypeVariables(param.getType()));
-        }
+        usedTphs.addAll(findTypeVariables(method.getParameterList()));
         usedTphs.addAll(findTypeVariables(method.getReturnType()));
         referenced.addAll(usedTphs);
         referenced.addAll(typeVariablesOfClass);
@@ -672,11 +684,21 @@ public abstract class GenerateGenerics {
             if (p1 instanceof PairLT ptph && ptph.left.resolve().equals(ptph.right.resolve()))
                 result.remove(p1); // TODO This is a bit strange
         }
-
         for (var tph : usedTphs) {
             if (classGenerics == null || classGenerics.stream().noneMatch((pair) -> pair.left.equals(tph)))
                 addToPairs(result, new PairEQ(tph, ASTToTargetAST.OBJECT));
         }
+        var all = new HashSet<>(result);
+        for (var p : all) {
+            if (p instanceof PairEQ peq && peq.right.equals(ASTToTargetAST.OBJECT)) {
+                for (var p2 : all) {
+                    if (p2 instanceof PairLT && p2.left.equals(p.left)) {
+                        result.remove(p);
+                        break;
+                    }
+                }
+            }
+        }
     }
 
     private record ToAdd(TypePlaceholder left, TypePlaceholder right) {}

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

@@ -568,6 +568,11 @@ public class StatementToTargetExpression implements ASTVisitor {
         result = new TargetTypePattern(converter.convert(aPattern.getType()), aPattern.getName());
     }
 
+    @Override
+    public void visit(LiteralPattern literalPattern) {
+        result = new TargetExpressionPattern(converter.convert(literalPattern.value));
+    }
+
     @Override
     public void visit(ExpressionPattern aPattern) {
         result = converter.convert(aPattern.getExpression());

src/main/java/de/dhbwstuttgart/target/tree/MethodParameter.java

@@ -11,4 +11,8 @@ public record MethodParameter(TargetPattern pattern) {
     public MethodParameter withType(TargetType type) {
         return new MethodParameter(pattern.withType(type));
     }
+
+    public MethodParameter withName(String name) {
+        return new MethodParameter(pattern.withName(name));
+    }
 }

src/main/java/de/dhbwstuttgart/target/tree/TargetMethod.java

@@ -79,6 +79,10 @@ public record TargetMethod(int access, String name, TargetBlock block, Signature
         return (access & Opcodes.ACC_STATIC) != 0;
     }
 
+    public boolean isPrivate() {
+        return (access & Opcodes.ACC_PRIVATE) != 0;
+    }
+
     @Override
     public boolean equals(Object other) {
         if (!(other instanceof TargetMethod otherMethod)) return false;

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetComplexPattern.java

@@ -9,4 +9,9 @@ public record TargetComplexPattern(TargetType type, String name, List<TargetPatt
     public TargetComplexPattern withType(TargetType type) {
         return new TargetComplexPattern(type, name, subPatterns);
     }
+
+    @Override
+    public TargetComplexPattern withName(String name) {
+        return new TargetComplexPattern(type, name, subPatterns);
+    }
 }

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetExpressionPattern.java

@@ -0,0 +1,20 @@
+package de.dhbwstuttgart.target.tree.expression;
+
+import de.dhbwstuttgart.target.tree.type.TargetType;
+
+public record TargetExpressionPattern(TargetExpression expression) implements TargetPattern {
+    @Override
+    public TargetPattern withType(TargetType type) {
+        return this;
+    }
+
+    @Override
+    public TargetType type() {
+        return expression.type();
+    }
+
+    @Override
+    public TargetPattern withName(String name) {
+        return this;
+    }
+}

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetGuard.java

@@ -12,4 +12,9 @@ public record TargetGuard(TargetPattern inner, TargetExpression expression) impl
     public TargetType type() {
         return inner.type();
     }
+
+    @Override
+    public TargetGuard withName(String name) {
+        return new TargetGuard(inner.withName(name), expression);
+    }
 }

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetPattern.java

@@ -2,7 +2,7 @@ package de.dhbwstuttgart.target.tree.expression;
 
 import de.dhbwstuttgart.target.tree.type.TargetType;
 
-public sealed interface TargetPattern extends TargetExpression permits TargetComplexPattern, TargetGuard, TargetTypePattern {
+public sealed interface TargetPattern extends TargetExpression permits TargetComplexPattern, TargetExpressionPattern, TargetGuard, TargetTypePattern {
     default String name() {
         return null;
     }
@@ -10,4 +10,6 @@ public sealed interface TargetPattern extends TargetExpression permits TargetCom
     TargetPattern withType(TargetType type);
 
     TargetType type();
+
+    TargetPattern withName(String name);
 }

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetTypePattern.java

@@ -7,4 +7,9 @@ public record TargetTypePattern(TargetType type, String name) implements TargetP
     public TargetTypePattern withType(TargetType type) {
         return new TargetTypePattern(type, name);
     }
+
+    @Override
+    public TargetTypePattern withName(String name) {
+        return new TargetTypePattern(type, name);
+    }
 }

src/main/java/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java

@@ -13,7 +13,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-public class TypeInsertPlacer extends AbstractASTWalker{
+public class TypeInsertPlacer extends AbstractASTWalker {
     Set<TypeInsert> inserts = new HashSet<>();
     private ResultSet withResults;
     String pkgName;

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

@@ -7,7 +7,9 @@ import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
@@ -100,25 +102,32 @@ public class TYPE {
         ConstraintSet constraintSet = new ConstraintSet();
 
         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){
+        for (Pattern el : subPatternList){
+            if (el instanceof RecordPattern){
                 constraintSet.addAll(addRecursiveParameterConstraints((RecordPattern) el, blockInformation));
-            }else{
-                var allClasses = blockInformation.getAvailableClasses();
-                RefTypeOrTPHOrWildcardOrGeneric type;
+            } else {
+                FormalParameter param = (FormalParameter) allClass.getConstructors().getFirst().getParameterList().getParameterAt(counter);
+                FieldAssumption assumption = new FieldAssumption(param.getName(), allClass, param.getType(), blockInformation.getCurrentTypeScope());
 
-                for (ClassOrInterface allClass : allClasses) {
-                    var typename = recordPattern.getType().toString();
-                    var className = allClass.getClassName().getClassName();
-                    if(className.equals(typename)){
-                        type = allClass.getConstructors().get(0).getParameterList().getParameterAt(counter).getType();
-                        constraintSet.addUndConstraint(new Pair(el.getType(), type, PairOperator.SMALLERDOT, new SourceLoc(blockInformation.getCurrentClass().getFileName(), el.getOffset().getLine())));
-                    }
-                }
+                var fieldCons = new Pair(el.getType(), assumption.getType(resolver), PairOperator.SMALLERDOT);
+                var recvCons = new Pair(refType, assumption.getReceiverType(resolver), PairOperator.EQUALSDOT);
+                constraintSet.addUndConstraint(fieldCons);
+                constraintSet.addUndConstraint(recvCons);
 
+                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/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java

@@ -841,7 +841,7 @@ public class TYPEStmt implements StatementVisitor {
             for (var child : switchStmt.getBlocks()) {
                 for (var label : child.getLabels()) {
                     if (label.getPattern() == null) {
-                        System.out.println("DefaultCase");
+                        //System.out.println("DefaultCase");
                     } else {
                         constraintsSet.addUndConstraint(
                                 new Pair(
@@ -910,10 +910,11 @@ public class TYPEStmt implements StatementVisitor {
 
         for (var subPattern : pattern.getSubPattern()) {
             for (Constructor con : constructors) {
-                System.out.println("----------------------\n" + subPattern.getType() + " | " + con.getParameterList().getParameterAt(counter).getType() + "\n----------------------\n");
+                //System.out.println("----------------------\n" + subPattern.getType() + " | " + con.getParameterList().getParameterAt(counter).getType() + "\n----------------------\n");
                 constraintsSet.addUndConstraint(new Pair(subPattern.getType(), con.getParameterList().getParameterAt(counter).getType(), PairOperator.SMALLERDOT, loc(con.getParameterList().getParameterAt(counter).getOffset())));
             }
             if (subPattern instanceof RecordPattern) recursivelyAddRecordConstraints((RecordPattern) subPattern);
+            else if (subPattern instanceof LiteralPattern lp) lp.value.accept(this);
             counter++;
         }
     }

src/test/java/AllgemeinTest.java

@@ -64,11 +64,11 @@ public class AllgemeinTest {
 		//String className = "Cycle";
 		//String className = "TripleTest";
 		//String className = "WildcardList";
-		//String className = "List";
+		String className = "List";
 		//String className = "Box";
 		//String className = "GenBox";
 		//String className = "InnerInf";
-		String className = "Foo";
+		//String className = "Foo";
 		//PL 2019-10-24: genutzt fuer unterschiedliche Tests
 		path = System.getProperty("user.dir")+"/resources/AllgemeinTest/" + className + ".jav";
 		//path = System.getProperty("user.dir")+"/src/test/resources/AllgemeinTest/Overloading_Generics.jav";

src/test/java/TestComplete.java

@@ -782,6 +782,24 @@ public class TestComplete {
         assertEquals(swtch.invoke(instance, listWithOneElement), 10);
     }
 
+    @Test
+    public void testSwitchNestedValue() throws Exception {
+        var classFiles = generateClassFiles(new ByteArrayClassLoader(), "SwitchNestedValue.jav");
+        var clazz = classFiles.get("SwitchNestedValue");
+        var rec = classFiles.get("R");
+        var instance = clazz.getDeclaredConstructor().newInstance();
+        var m = clazz.getDeclaredMethod("main", rec);
+
+        var ctor = rec.getDeclaredConstructor(Integer.class);
+        var r1 = ctor.newInstance(10);
+        var r2 = ctor.newInstance(20);
+        var r3 = ctor.newInstance(30);
+
+        assertEquals(m.invoke(instance, r1), 1);
+        assertEquals(m.invoke(instance, r2), 2);
+        assertEquals(m.invoke(instance, r3), 3);
+    }
+
     @Test
     public void testGenericRecordSwitchCase() throws Exception {
         var classFiles = generateClassFiles(new ByteArrayClassLoader(), "GenericRecordSwitchCase.jav");
@@ -838,7 +856,6 @@ public class TestComplete {
         var instance = clazz.getDeclaredConstructor().newInstance();
     }
 
-    @Ignore("Not implemented")
     @Test
     public void testOverloadPattern() throws Exception {
         var classFiles = generateClassFiles(new ByteArrayClassLoader(), "OverloadPattern.jav");
@@ -846,19 +863,50 @@ public class TestComplete {
         var rec = classFiles.get("Point");
 
         var instance = clazz.getDeclaredConstructor().newInstance();
-        var m1 = clazz.getDeclaredMethod("m", rec);
-        var m2 = clazz.getDeclaredMethod("m", Integer.class);
+        var m1 = clazz.getDeclaredMethod("m", rec, rec);
+        var m2 = clazz.getDeclaredMethod("m", rec);
+        var m3 = clazz.getDeclaredMethod("m", Integer.class);
 
-        var pt = rec.getDeclaredConstructor(Number.class, Number.class).newInstance(10, 20);
-        assertEquals(m1.invoke(instance, pt), 30);
-        assertEquals(m2.invoke(instance, 10), 10);
+        var ptInt = rec.getDeclaredConstructor(Number.class, Number.class).newInstance(1, 2);
+        var ptFlt = rec.getDeclaredConstructor(Number.class, Number.class).newInstance(1f, 2f);
+
+        assertEquals(m1.invoke(instance, ptInt, ptFlt), 1);
+        assertEquals(m1.invoke(instance, ptInt, ptInt), 2);
+        assertEquals(m1.invoke(instance, ptFlt, ptInt), 3);
+        assertEquals(m1.invoke(instance, ptFlt, ptFlt), 4);
+
+        assertEquals(m2.invoke(instance, ptInt), 5);
+        assertEquals(m2.invoke(instance, ptFlt), 6);
+
+        assertEquals(m3.invoke(instance, 10), 10);
     }
 
-    @Ignore("Not implemented")
     @Test
-    public void testOverloadPatternMatching() throws Exception {
-        var classFiles = generateClassFiles(new ByteArrayClassLoader(), "PaternMatchingHaskellStyle.jav");
-        var clazz = classFiles.get("PaternMatchingHaskellStyle");
+    public void testOverloadNestedPattern() throws Exception {
+        var classFiles = generateClassFiles(new ByteArrayClassLoader(), "OverloadNestedPattern.jav");
+        var clazz = classFiles.get("OverloadNestedPattern");
+        var rec = classFiles.get("R");
+
+        var instance = clazz.getDeclaredConstructor().newInstance();
+        var ctor = rec.getDeclaredConstructor(Object.class);
+        var r1 = ctor.newInstance(1);
+        var r2 = ctor.newInstance(r1);
+
+        var m = clazz.getDeclaredMethod("m", rec, rec);
+        assertEquals(m.invoke(instance, r2, r1), 1);
+
+        var r3 = ctor.newInstance(2f);
+        var r4 = ctor.newInstance(r3);
+        assertEquals(m.invoke(instance, r4, r3), 2);
+
+        assertEquals(m.invoke(instance, r1, r1), 3);
+    }
+
+    //@Ignore("Not implemented")
+    @Test
+    public void testPatternMatchingHaskellStyle() throws Exception {
+        var classFiles = generateClassFiles(new ByteArrayClassLoader(), "PatternMatchingHaskellStyle.jav");
+        var clazz = classFiles.get("PatternMatchingHaskellStyle");
         var R2 = classFiles.get("Elem");
         var R = classFiles.get("LinkedElem");
         var I = classFiles.get("List");
@@ -867,16 +915,36 @@ public class TestComplete {
         var r2ctor = R2.getDeclaredConstructor(Object.class);
 
         var instance = clazz.getDeclaredConstructor().newInstance();
-        var m = clazz.getDeclaredMethod("append", R, I);
+        var m = clazz.getDeclaredMethod("append$LLinkedElem$_$LTPH$_$LLinkedElem$_$LTPH$_$", R, Object.class);
 
-        //var x = rctor.newInstance(rctor.newInstance(0, rctor.newInstance(0, r2ctor.newInstance(0))), 0);
-        //var y = rctor.newInstance(r2ctor.newInstance(0), 0);
+        var x = rctor.newInstance(rctor.newInstance(0, rctor.newInstance(0, r2ctor.newInstance(0))), r2ctor.newInstance(0));
+        var y = rctor.newInstance(r2ctor.newInstance(0), r2ctor.newInstance(0));
 
-        //assertEquals(m.invoke(instance, x, y), 10);
-        //assertEquals(m.invoke(instance, y, y), 40.0);
+        assertEquals(m.invoke(instance, x, y), null);
+        assertEquals(m.invoke(instance, y, y), null);
 
     }
 
+    @Test
+    public void testPatternMatchingListAppend() throws Exception {
+        var classFiles = generateClassFiles(new ByteArrayClassLoader(), "PatternMatchingListAppend.jav");
+        var clazz = classFiles.get("PatternMatchingListAppend");
+        var instance = clazz.getDeclaredConstructor().newInstance();
+
+        var Cons = classFiles.get("Cons");
+        var Empty = classFiles.get("Empty");
+        var List = classFiles.get("List");
+
+        var ConsCtor = Cons.getDeclaredConstructor(Object.class, List);
+        var EmptyCtor = Empty.getDeclaredConstructor();
+
+        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
     public void testOverloadSwitch() throws Exception {
         var classFiles = generateClassFiles(new ByteArrayClassLoader(), "SwitchOverload.jav");
@@ -891,7 +959,7 @@ public class TestComplete {
         var x = rctor.newInstance(10);
         var d = rctor.newInstance(20.0);
 
-        assertEquals(m.invoke(instance, x, 0), 10);
+        assertEquals(m.invoke(instance, x, 0), 50);
         assertEquals(m.invoke(instance, d, 0), 40.0);
     }