pom.xml

@@ -28,15 +28,15 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<artifactId>commons-io</artifactId>
 			<version>2.6</version>
 		</dependency>
-		<dependency>
-			<groupId>io.github.classgraph</groupId>
-			<artifactId>classgraph</artifactId>
-			<version>4.8.172</version>
-		</dependency>
 		<dependency>
 			<groupId>com.google.guava</groupId>
 			<artifactId>guava</artifactId>
-			<version>33.2.0-jre</version>
+			<version>22.0</version>
+		</dependency>
+		<dependency>
+			<groupId>org.reflections</groupId>
+			<artifactId>reflections</artifactId>
+			<version>0.9.11</version>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm -->
 		<dependency>
@@ -66,7 +66,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 					<redirectTestOutputToFile>true</redirectTestOutputToFile>
 					<reportsDirectory>${project.build.directory}/test-reports</reportsDirectory>
 					<argLine>--enable-preview</argLine>
-					<trimStackTrace>false</trimStackTrace>
+					<trimStackTrace>true</trimStackTrace>
 					<excludes>
 						<exclude>**/JavaTXCompilerTest.java</exclude>
 						<exclude>**/AllgemeinTest.java</exclude>

resources/AllgemeinTest/Bar.java

@@ -1,10 +0,0 @@
-public class Bar{
-
-    void visit(Object o){
-        System.out.println("Object");
-    }
-
-    void visit(Bla f){
-        System.out.println("Foo");
-    }
-}

resources/AllgemeinTest/Box.jav

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

resources/AllgemeinTest/Foo.jav

@@ -1,6 +0,0 @@
-public class Foo{
-
-    public accept(Bar b){
-        b.visit(this);
-    }
-}

resources/AllgemeinTest/List.jav

@@ -1,46 +0,0 @@
-import java.lang.Boolean;
-import java.lang.Object;
-
-class List {
-    elem;
-    next;
-
-    List() {
-		super();
-    }
-
-    List(elem, next) {
-		this.elem = elem;
-		this.next = next;
-    }
-    
-    addElement(newElem) {
-    	return new List(newElem, this);
-    }
-    
-    append(l) {
-       if (next == null) {
-       	return l;
-       }
-       else {
-       	return new List(elem, next.append(l));
-       }
-    }
-/*
-    addAll(l) {
-		var nextLoc = next;
-		while (//nextLoc != null 
-		true) {
-	    	nextLoc = nextLoc.next;
-		}
-		nextLoc = l;
-    }
-
-    void m() {
-		List<? extends Object> l; // = new List<Integer>(1, null);
-		List<? extends Object> l2; // = new List<String>("SSS", null);
-		l.addAll(l2);
-    }
-*/
-}
-	    

resources/bytecode/javFiles/Box.jav

@@ -1,9 +1,7 @@
-public class Box<A> {
+class B { }
-
+class Box_Main extends B {
-	A a;
+    m(b) {
-
+       b.m(new Box_Main());
-	public Box() { }
+       b.m(new B());
-	public Box(A a) {
+    }
-		//this.a = a;
+}
-	}
-}

resources/bytecode/javFiles/Box.java

@@ -0,0 +1,3 @@
+class Box<A> {
+    void m(A a) { }
+}

resources/bytecode/javFiles/Bug298.jav

@@ -2,16 +2,18 @@ import java.util.List;
 import java.util.ArrayList;
 import java.lang.Integer;
 import java.lang.System;
-import java.lang.Boolean;
 import java.io.PrintStream;
 import java.util.stream.Stream;
 import java.util.function.Function;
 
 public class Bug298 {
+    public <R, T> Stream<R> takes(Stream<T> s, Function<? super T, ? super R> fun) {
+        return null;
+    }
+
     public void m() {
         List<Integer> list = new ArrayList<>();
-        list.stream().map(x -> 2 * x);
+        Stream<Integer> a = list.stream();
-
+        takes(a, x -> 2 * x);
-        Function<Integer, Boolean> filter = x -> true;
     }
 }

resources/bytecode/javFiles/Bug300.jav

@@ -1,17 +0,0 @@
-import java.lang.String;
-
-class Base {
-    toString() {
-        return "Base";
-    }
-}
-
-public class Bug300 extends Base {
-    public m() {
-        return super.toString();
-    }
-
-    toString() {
-        return "Derived";
-    }
-}

resources/bytecode/javFiles/Bug301.jav

@@ -1,4 +0,0 @@
-import java.util.HashSet;
-
-public class Bug301<A> extends HashSet<A> {
-}

resources/bytecode/javFiles/Bug302.jav

@@ -1,11 +0,0 @@
-import java.util.ArrayList;
-import java.util.List;
-import java.lang.Integer;
-
-public class Bug302 {
-    public Bug302(List<Integer> a){}
-
-    public static m() {
-        new Bug302(new ArrayList<Integer>());
-    }
-}

resources/bytecode/javFiles/Bug306.jav

@@ -1,13 +0,0 @@
-import java.lang.Integer;
-import java.util.List;
-
-class Base {
-    m(List<Integer> a) {}
-}
-
-public class Bug306 extends Base {
-    @Override
-    m(List<Integer> b) {
-        b.add(1);
-    }
-}

resources/bytecode/javFiles/Bug307.jav

@@ -1,46 +0,0 @@
-public class Bug307 {
-    public void main() {
-        IVisitor v = new Visitor();
-        Impl2 f = new Impl2();
-        Impl1 g = new Impl1();
-
-        f.accept(v);
-        g.accept(v);
-    }
-}
-
-interface IVisitor {
-    void visit(Impl1 f);
-    void visit(Impl2 fb);
-}
-
-interface IAcceptor {
-    void accept(IVisitor v);
-}
-
-class Visitor implements IVisitor {
-
-    @Override
-    public void visit(Impl1 f) {
-    }
-
-    @Override
-    public void visit(Impl2 fb) {
-    }
-}
-
-class Impl1 implements IAcceptor {
-
-    @Override
-    public void accept(IVisitor v) {
-        v.visit(this);
-    }
-}
-
-class Impl2 implements IAcceptor {
-
-    @Override
-    public void accept(IVisitor v) {
-        v.visit(this);
-    }
-}

resources/bytecode/javFiles/Bug309.jav

@@ -1,16 +0,0 @@
-import java.util.List;
-import java.util.ArrayList;
-import java.lang.Integer;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.Optional;
-
-public class Bug309 {
-    public main() {
-        List<Integer> list = new ArrayList<>(List.of(1,2,3,4,5,6,7,8,9));
-        var res = list.stream().filter(x -> x == 5).map(x -> x * 2).findFirst();
-        return res;
-    }
-}

resources/bytecode/javFiles/Bug310.jav

@@ -1,9 +0,0 @@
-import java.lang.Integer;
-import java.lang.String;
-
-public class Bug310 {
-    Integer i = 3;
-    public toString() {
-        return i.toString();
-    }
-}

resources/bytecode/javFiles/Bug311.jav

@@ -1,10 +0,0 @@
-import java.lang.String;
-
-public class Bug311 {
-    Bug311A i = new Bug311A();
-    public toString() {
-        return i.toString();
-    }
-}
-
-class Bug311A {}

resources/bytecode/javFiles/Bug312.jav

@@ -1,8 +0,0 @@
-public class Bug312 {
-    Bug312A i = new Bug312A();
-    public main() {
-        if (i == null) {}
-    }
-}
-
-class Bug312A {}

resources/bytecode/javFiles/Bug314.jav

@@ -1,13 +0,0 @@
-import java.lang.Integer;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.stream.Stream;
-import java.util.function.Predicate;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-public class Bug314 {
-    public List<Integer> convert(List<Integer> in) {
-        return in.stream().filter(x -> x > 5).collect(Collectors.toList());
-    }
-}

resources/bytecode/javFiles/Bug325.jav

@@ -1,13 +0,0 @@
-import java.lang.Integer;
-import java.util.function.Function;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.stream.Stream;
-
-public class Bug325 {
-    public main() {
-      List<Integer> list = new ArrayList<>(List.of(1,2,3,4,5));
-      var func = x -> x*2;
-      return list.stream().map(func).toList();
-   }
-}

resources/bytecode/javFiles/Bug326.jav

@@ -1,8 +0,0 @@
-import java.lang.Integer;
-
-public class Bug326 {
-   public Bug326() {
-      var func = x -> y -> x * y;
-      return func.apply(3).apply(4);
-   }
-}

resources/bytecode/javFiles/Bug328.jav

@@ -1,8 +0,0 @@
-import java.lang.Integer;
-import Bug328B;
-
-public class Bug328 extends Bug328B {
-    public Bug328() {
-        super(1);
-    }
-}

resources/bytecode/javFiles/Bug328B.java

@@ -1,3 +0,0 @@
-public class Bug328B {
-    public Bug328B(int a) {}
-}

resources/bytecode/javFiles/Bug332.jav

@@ -1,15 +0,0 @@
-import java.lang.Object;
-
-interface Visitor {
-    public void visit(Object obj);
-    public void visit(ClassA a);
-}
-
-class ClassA {
-    void accept(Visitor v) {
-        v.visit(this);
-    }
-}
-
-public class Bug332 {
-}

resources/bytecode/javFiles/Bug333.jav

@@ -1,11 +0,0 @@
-import java.lang.String;
-
-public class Bug333 {
-    public static String Bar = "Bar";
-}
-
-class Bar {
-    public bar() {
-        String s = Bug333.Bar;
-    }
-}

resources/bytecode/javFiles/Bug337.jav

@@ -1,10 +0,0 @@
-import java.lang.Integer;
-import java.lang.Number;
-import java.lang.Object;
-
-public class Bug337 {
-    public void main() {
-        Fun1$$<Object, Integer> fun1 = x -> x.hashCode() + 1;
-        Fun1$$<Number, Number> fun2 = fun1;
-    }
-}

resources/bytecode/javFiles/Bug338.jav

@@ -1,11 +0,0 @@
-import java.util.List;
-import java.lang.Integer;
-import java.lang.String;
-import java.lang.Object;
-import java.util.List;
-
-public class Bug338 {
-    public hashCode() {
-        return List.of(42);
-    }
-}

resources/bytecode/javFiles/Bug343.jav

@@ -1,2 +0,0 @@
-public record Bug343() {
-}

resources/bytecode/javFiles/BugXXX.jav

@@ -1,16 +0,0 @@
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import java.lang.String;
-import java.util.stream.Stream;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.lang.Integer;
-
-class BugXXX {
-    public main() {
-        List<Integer> i = new ArrayList<>(List.of(1,2,3,4,5,6,7,8,9,10));
-        Optional<Integer> tmp = i.stream().filter(x -> x == 5).map(x -> x*2).findFirst();
-        return tmp;
-    }
-}

resources/bytecode/javFiles/ImportWildcard.jav

@@ -1,5 +0,0 @@
-import java.lang.*;
-
-public class ImportWildcard {
-    m(a, b) { return a * b; }
-}

resources/bytecode/javFiles/LamRunnable.jav

@@ -0,0 +1,16 @@
+import java.lang.Runnable;
+import java.lang.System;
+import java.lang.String;
+import java.io.PrintStream;
+
+public class LamRunnable {
+
+	public LamRunnable() {
+		Runnable lam = () -> {
+		    System.out.println("lambda");
+		};
+
+		lam.run();
+	}
+}
+ 

resources/bytecode/javFiles/Literal.jav

@@ -3,6 +3,4 @@ import java.lang.Character;
 public class Literal {
     public m() { return null; }
     public m2() { return 'C'; }
-    public m3() { return 10L; }
-    public m4() { return 10.5F; }
 }

resources/bytecode/javFiles/Matrix.jav

@@ -1,5 +1,3 @@
-import java.util.List;
-import java.util.AbstractList;
 import java.util.Vector;
 import java.lang.Integer;
 //import java.lang.Float;
@@ -32,8 +30,8 @@ public class Matrix    extends Vector<Vector<Integer>> {
                 var erg = 0;
                 var k = 0;
                 while(k < v1.size()) {
-                    erg = erg + v1.get(k)
+                    erg = erg + v1.elementAt(k)
-                             * m.get(k).get(j);
+                             * m.elementAt(k).elementAt(j);
                     k++; }
 //                v2.addElement(new Integer(erg));
                 v2.addElement(erg);

resources/bytecode/javFiles/Op1.jav

@@ -1,34 +1,11 @@
-import java.lang.Boolean;
+public class Op1{
-import java.lang.Integer;
+	public Op1() {
-
+		
-public class Op1 {
+		Runnable lam = () -> {
-	public not() {
+				String test = "";
-		var b = false;
+					String b = "b";
-		var c = !b;
+					test = b;
-		return c;
+				System.out.println(test);};
+		//lam.run();
 	}
-
-	public or() {
-	    var a = 10;
-	    var b = 20;
-	    return a | b;
-	}
-
-	public and() {
-	    var a = 10;
-	    var b = 20;
-	    return a & b;
-	}
-
-    public xor() {
-        var a = 10;
-        var b = 20;
-        return a ^ b;
-    }
-
-    public mod() {
-        var a = 10;
-        var b = 2;
-        return a % b;
-    }
 }

resources/bytecode/javFiles/OverrideEquals.jav

@@ -1,12 +0,0 @@
-import java.lang.Object;
-import java.lang.Boolean;
-
-public class OverrideEquals extends OverrideRoot {
-    public boolean equals(Object o) {
-        return true;
-    }
-
-    public int method(int var1, float var2) {
-        return 0;
-    }
-}

resources/bytecode/javFiles/OverrideRoot.java

@@ -1,3 +0,0 @@
-public abstract class OverrideRoot {
-    public abstract int method(int a, float b);
-}

resources/bytecode/javFiles/RecordTest.jav

@@ -11,9 +11,9 @@ record Rec(Integer a, Integer b) {}
 }*/
 
 public class RecordTest {
-    Rec a = new Rec(10, 20);
+    a = new Rec(10, 20);
-    Rec b = new Rec(10, 20);
+    b = new Rec(10, 20);
-    Rec c = new Rec(20, 40);
+    c = new Rec(20, 40);
 
     public doesEqual() { return a.equals(b); }
     public doesNotEqual() { return b.equals(c); }

resources/bytecode/javFiles/Ternary.jav

@@ -1,9 +0,0 @@
-import java.lang.Boolean;
-import java.lang.String;
-import java.lang.Integer;
-
-public class Ternary {
-    public main(x) {
-        return x > 10 ? "big" : "small";
-    }
-}

resources/bytecode/javFiles/While.jav

@@ -9,13 +9,4 @@ public class While {
 		}
 		return x;
 	}
-
-	public m2() {
-        int i = 0;
-        do {
-            ++i;
-        } while(i < 10);
-
-        return i;
-    }
 }

resources/bytecode/javFiles/Y.jav

@@ -2,21 +2,41 @@ import java.lang.Integer;
 
 public class Y {
     y;
+    //factorial;
+
     public Y() {
-		y = f -> t -> f.apply(y.apply(f)).apply(t);
+		y =  f -> t -> f.apply(y.apply(f)).apply(t);
+		//factorial = y.apply(f -> n -> { if (n == 0) return 1; else return n * f.apply(n - 1); });
+    }
+  /*  
+    getY() {
+      return y;
+    }
+    */
+}
+/*
+class fac1 {
+    factorial;
+
+    fac1() {
+      var y;
+	  y = new Y<Integer,Integer,Integer,Integer,Integer>().getY();
+	  factorial = y.apply(f -> n -> { if (n == 0) return 1; else return n * f.apply(n - 1); });
     }
 }
 
-public class Fac1 {
+ergibt Parse-Error
-    public factorial;
+class fac1 {
-    public Fac1() {
+    factorial;
+
+    fac1() {
     	var y;
-    	var tmp = new Y<>(); // TODO Having new Y<>().y on one line doesn't work, see FIXME in StatementGenerator
+		y = new Y<>().y;
-		y = tmp.y;
 		factorial = y.apply(f -> n -> { if (n == 0) return 1; else return n * f.apply(n - 1); });
     }
-
+     public static void main(String args[]) {
-    public fac(v) {
+		System.out.println(new fac1().factorial.apply(3));
-        return factorial.apply(v);
     }
-}
+ 
+}
+*/

resources/packageTest/pkg/sub/Interface.jav

@@ -1,3 +0,0 @@
-package pkg.sub;
-
-public interface Interface {}

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

@@ -5,11 +5,7 @@ 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.*;
@@ -18,7 +14,6 @@ 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.*;
@@ -31,25 +26,17 @@ public class Codegen {
     private int lambdaCounter = 0;
     private final HashMap<TargetLambdaExpression, TargetMethod> lambdas = new HashMap<>();
     private final JavaTXCompiler compiler;
-    private final ASTToTargetAST converter;
 
-    private class CustomClassWriter extends ClassWriter {
+    public Codegen(TargetStructure clazz, JavaTXCompiler compiler) {
-        public CustomClassWriter() {
-            super(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
-        }
-
-        @Override
-        protected ClassLoader getClassLoader() {
-            return compiler.getClassLoader();
-        }
-    }
-
-    public Codegen(TargetStructure clazz, JavaTXCompiler compiler, ASTToTargetAST converter) {
         this.clazz = clazz;
         this.className = clazz.qualifiedName().getClassName();
-        this.cw = new CustomClassWriter();
+        this.cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS) {
+            @Override
+            protected ClassLoader getClassLoader() {
+                return compiler.getClassLoader();
+            }
+        };
         this.compiler = compiler;
-        this.converter = converter;
     }
 
     private record LocalVar(int index, String name, TargetType type) {
@@ -90,6 +77,8 @@ public class Codegen {
         int localCounter;
         MethodVisitor mv;
         TargetType returnType;
+        // This is used to remember the type from lambda expressions
+        TargetType contextType;
 
         Stack<BreakEnv> breakStack = new Stack<>();
         Stack<Integer> switchResultValue = new Stack<>();
@@ -276,43 +265,13 @@ public class Codegen {
                 mv.visitInsn(I2F);
             else if (dest.equals(TargetType.Double))
                 mv.visitInsn(I2D);
-        } else if (isFunctionalInterface(source) && isFunctionalInterface(dest) &&
-                !(source instanceof TargetFunNType && dest instanceof TargetFunNType)) {
-            boxFunctionalInterface(state, source, dest);
         } else if (!(dest instanceof TargetGenericType)) {
-            //boxPrimitive(state, source);
+            boxPrimitive(state, source);
             mv.visitTypeInsn(CHECKCAST, dest.getInternalName());
             unboxPrimitive(state, dest);
         }
     }
 
-    record TypePair(TargetType from, TargetType to) {}
-    private Map<TypePair, String> funWrapperClasses = new HashMap<>();
-
-    private void boxFunctionalInterface(State state, TargetType source, TargetType dest) {
-        var mv = state.mv;
-        var className = "FunWrapper$$" +
-                source.name().replaceAll("\\.", "\\$") +
-                "$_$" +
-                dest.name().replaceAll("\\.", "\\$");
-
-        funWrapperClasses.put(new TypePair(source, dest), className);
-        mv.visitTypeInsn(NEW, className);
-        mv.visitInsn(DUP_X1);
-        mv.visitInsn(SWAP);
-        mv.visitMethodInsn(INVOKESPECIAL, className, "<init>", "(" + source.toDescriptor() + ")V", false);
-    }
-
-    private boolean isFunctionalInterface(TargetType type) {
-        if (type instanceof TargetFunNType) return true;
-        if (type instanceof TargetRefType) {
-            var clazz = compiler.getClass(new JavaClassName(type.name()));
-            return (clazz.getModifiers() & Modifier.INTERFACE) != 0 && clazz.isFunctionalInterface();
-        }
-
-        return false;
-    }
-
     private TargetType largerType(TargetType left, TargetType right) {
         if (left.equals(TargetType.String) || right.equals(TargetType.String)) {
             return TargetType.String;
@@ -322,12 +281,9 @@ public class Codegen {
             return TargetType.Float;
         } else if (left.equals(TargetType.Long) || right.equals(TargetType.Long)) {
             return TargetType.Long;
-        } else if (left.equals(TargetType.Integer) || right.equals(TargetType.Integer)) {
+        } else {
             return TargetType.Integer;
-        } else if (left.equals(TargetType.Short) || right.equals(TargetType.Short)) {
-            return TargetType.Short;
         }
-        return left;
     }
 
     private void generateBinaryOp(State state, TargetBinaryOp op) {
@@ -762,23 +718,15 @@ public class Codegen {
     private void generateLambdaExpression(State state, TargetLambdaExpression lambda) {
         var mv = state.mv;
 
-        String methodName = "apply";
-        TargetMethod.Signature signature = new TargetMethod.Signature(Set.of(),
-                lambda.signature().parameters().stream().map(
-                        par -> par.withType(TargetType.Object)).toList(),
-                lambda.signature().returnType() != null ? TargetType.Object : null);
-
-        var parameters = new ArrayList<>(lambda.captures());
-        parameters.addAll(signature.parameters());
-        var implSignature = new TargetMethod.Signature(Set.of(), parameters, lambda.signature().returnType());
-
         TargetMethod impl;
         if (lambdas.containsKey(lambda)) {
             impl = lambdas.get(lambda);
         } else {
             var name = "lambda$" + lambdaCounter++;
+            var parameters = new ArrayList<>(lambda.captures());
+            parameters.addAll(lambda.params().stream().map(param -> param.pattern().type() instanceof TargetGenericType ? param.withType(TargetType.Object) : param).toList());
 
-            impl = new TargetMethod(0, name, lambda.block(), implSignature, null);
+            impl = new TargetMethod(0, name, lambda.block(), new TargetMethod.Signature(Set.of(), parameters, lambda.returnType() instanceof TargetGenericType ? TargetType.Object : lambda.returnType()), null);
             generateMethod(impl);
             lambdas.put(lambda, impl);
         }
@@ -786,55 +734,35 @@ public class Codegen {
         var mt = MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class, MethodType.class, MethodHandle.class, MethodType.class);
 
         var bootstrap = new Handle(H_INVOKESTATIC, "java/lang/invoke/LambdaMetafactory", "metafactory", mt.toMethodDescriptorString(), false);
-        var handle = new Handle(H_INVOKEVIRTUAL, clazz.getName(), impl.name(), implSignature.getDescriptor(), false);
+        var handle = new Handle(H_INVOKEVIRTUAL, clazz.getName(), impl.name(), impl.getDescriptor(), false);
+
+        // TODO maybe make this a function?
+        var desugared = "(";
+        for (var param : lambda.params())
+            desugared += "Ljava/lang/Object;";
+        desugared += ")";
+        if (lambda.returnType() != null)
+            desugared += "Ljava/lang/Object;";
+        else
+            desugared += "V";
 
         var params = new ArrayList<TargetType>();
         params.add(new TargetRefType(clazz.qualifiedName().getClassName()));
         params.addAll(lambda.captures().stream().map(mp -> mp.pattern().type()).toList());
 
+        var descriptor = TargetMethod.getDescriptor(state.contextType, params.toArray(TargetType[]::new));
         mv.visitVarInsn(ALOAD, 0);
-        for (var index = 0; index < lambda.captures().size(); index++) {
+        for (var capture : lambda.captures()) {
-            var capture = lambda.captures().get(index);
             var pattern = (TargetTypePattern) capture.pattern();
-            var variable = state.scope.get(pattern.name());
+            mv.visitVarInsn(ALOAD, state.scope.get(pattern.name()).index);
-            mv.visitVarInsn(ALOAD, variable.index);
-            mv.visitTypeInsn(CHECKCAST, capture.pattern().type().getInternalName());
         }
 
-        var descriptor = TargetMethod.getDescriptor(lambda.type(), params.toArray(TargetType[]::new));
+        String methodName;
-        mv.visitInvokeDynamicInsn(methodName, descriptor, bootstrap, Type.getType(signature.getSignature()), handle, Type.getType(signature.getDescriptor()));
+        var intf = compiler.getClass(new JavaClassName(state.contextType.name()));
-    }
+        if (intf == null) methodName = "apply"; // TODO Weird fallback logic here
+        else methodName = intf.getMethods().stream().filter(m -> Modifier.isAbstract(m.modifier)).findFirst().orElseThrow().getName();
 
-    private int findReturnCode(TargetType returnType) {
+        mv.visitInvokeDynamicInsn(methodName, descriptor, bootstrap, Type.getType(desugared), handle, Type.getType(TargetMethod.getDescriptor(impl.signature().returnType(), lambda.params().stream().map(mp -> mp.pattern().type()).toArray(TargetType[]::new))));
-        if (returnType.equals(TargetType.boolean_)
-                || returnType.equals(TargetType.char_)
-                || returnType.equals(TargetType.int_)
-                || returnType.equals(TargetType.short_)
-                || returnType.equals(TargetType.byte_))
-            return IRETURN;
-        else if (returnType.equals(TargetType.long_))
-            return LRETURN;
-        else if (returnType.equals(TargetType.float_))
-            return FRETURN;
-        else if (returnType.equals(TargetType.double_))
-            return DRETURN;
-        return ARETURN;
-    }
-
-    private int findLoadCode(TargetType loadType) {
-        if (loadType.equals(TargetType.boolean_)
-                || loadType.equals(TargetType.char_)
-                || loadType.equals(TargetType.int_)
-                || loadType.equals(TargetType.short_)
-                || loadType.equals(TargetType.byte_))
-            return ILOAD;
-        else if (loadType.equals(TargetType.long_))
-            return LLOAD;
-        else if (loadType.equals(TargetType.float_))
-            return FLOAD;
-        else if (loadType.equals(TargetType.double_))
-            return DLOAD;
-        return ALOAD;
     }
 
     private void generate(State state, TargetExpression expr) {
@@ -861,7 +789,10 @@ public class Codegen {
             break;
         }
         case TargetCast cast:
+            var ctx = state.contextType;
+            state.contextType = cast.type();
             generate(state, cast.expr());
+            state.contextType = ctx;
             convertTo(state, cast.expr().type(), cast.type());
             break;
         case TargetInstanceOf instanceOf:
@@ -906,7 +837,10 @@ public class Codegen {
         case TargetAssign assign: {
             switch (assign.left()) {
                 case TargetLocalVar localVar -> {
+                    var ctype = state.contextType;
+                    state.contextType = localVar.type();
                     generate(state, assign.right());
+                    state.contextType = ctype;
 
                     convertTo(state, assign.right().type(), localVar.type());
                     boxPrimitive(state, localVar.type());
@@ -919,7 +853,10 @@ public class Codegen {
                     if (!(dot.left() instanceof TargetThis && dot.isStatic()))
                         generate(state, dot.left());
 
+                    var ctype = state.contextType;
+                    state.contextType = fieldType;
                     generate(state, assign.right());
+                    state.contextType = ctype;
 
                     convertTo(state, assign.right().type(), fieldType);
                     boxPrimitive(state, fieldType);
@@ -936,8 +873,6 @@ public class Codegen {
         case TargetLocalVar localVar: {
             LocalVar local = state.scope.get(localVar.name());
             mv.visitVarInsn(ALOAD, local.index());
-            // This is a bit weird but sometimes the types don't match (see lambda expressions)
-            convertTo(state, local.type(), localVar.type());
             unboxPrimitive(state, local.type());
             break;
         }
@@ -1011,27 +946,6 @@ public class Codegen {
             mv.visitLabel(end);
             break;
         }
-        case TargetDo _do: {
-            Label start = new Label();
-            Label end = new Label();
-            Label check = new Label();
-
-            var env = new BreakEnv();
-            env.startLabel = check;
-            env.endLabel = end;
-
-            mv.visitLabel(start);
-            state.breakStack.push(env);
-            generate(state, _do.body());
-            state.breakStack.pop();
-
-            mv.visitLabel(check);
-            generate(state, _do.cond());
-            mv.visitJumpInsn(IFEQ, end);
-            mv.visitJumpInsn(GOTO, start);
-            mv.visitLabel(end);
-            break;
-        }
         case TargetIf _if: {
             generate(state, _if.cond());
             Label _else = new Label();
@@ -1048,17 +962,13 @@ public class Codegen {
         }
         case TargetReturn ret: {
             if (ret.expression() != null && state.returnType != null) {
-                if (state.returnType instanceof TargetPrimitiveType) {
+                var ctype = state.contextType;
-                    generate(state, ret.expression());
+                state.contextType = state.returnType;
-
+                generate(state, ret.expression());
-                    unboxPrimitive(state, state.returnType);
+                state.contextType = ctype;
-                    mv.visitInsn(findReturnCode(state.returnType));
+                boxPrimitive(state, ret.expression().type());
-                } else {
+                convertTo(state, ret.expression().type(), state.returnType);
-                    generate(state, ret.expression());
+                mv.visitInsn(ARETURN);
-                    boxPrimitive(state, ret.expression().type());
-                    convertTo(state, ret.expression().type(), state.returnType);
-                    mv.visitInsn(ARETURN);
-                }
             } else
                 mv.visitInsn(RETURN);
             break;
@@ -1098,28 +1008,23 @@ public class Codegen {
             break;
         }
         case TargetMethodCall call: {
-            if (!call.isStatic()) {
+            if (!call.isStatic())
                 generate(state, call.expr());
-                boxPrimitive(state, call.expr().type());
-            }
             for (var i = 0; i < call.args().size(); i++) {
                 var e = call.args().get(i);
                 var arg = call.parameterTypes().get(i);
+                var ctype = state.contextType;
+                state.contextType = arg;
                 generate(state, e);
-                convertTo(state, e.type(), arg);
                 if (!(arg instanceof TargetPrimitiveType))
                     boxPrimitive(state, e.type());
+                state.contextType = ctype;
             }
             var descriptor = call.getDescriptor();
             if (call.owner() instanceof TargetFunNType) // Decay FunN
                 descriptor = TargetMethod.getDescriptor(call.returnType() == null ? null : TargetType.Object, call.parameterTypes().stream().map(x -> TargetType.Object).toArray(TargetType[]::new));
 
-            int insn = INVOKEVIRTUAL;
+            mv.visitMethodInsn(call.isInterface() ? INVOKEINTERFACE : call.isStatic() ? INVOKESTATIC : call.name().equals("<init>") ? INVOKESPECIAL : INVOKEVIRTUAL, call.owner().getInternalName(), call.name(), descriptor, call.isInterface());
-            if (call.isStatic()) insn = INVOKESTATIC;
-            else if (call.isInterface()) insn = INVOKEINTERFACE;
-            else if (call.name().equals("<init>") || call.expr() instanceof TargetSuper || call.isPrivate()) insn = INVOKESPECIAL;
-
-            mv.visitMethodInsn(insn, call.owner().getInternalName(), call.name(), descriptor, call.isInterface());
 
             if (call.type() != null && call.returnType() != null && !(call.returnType() instanceof TargetPrimitiveType)) {
                 if (!call.returnType().equals(call.type()) && !(call.type() instanceof TargetGenericType))
@@ -1146,20 +1051,6 @@ public class Codegen {
             mv.visitInsn(ATHROW);
             break;
         }
-        case TargetTernary ternary: {
-            generate(state, ternary.cond());
-            var iffalse = new Label();
-            var end = new Label();
-            mv.visitJumpInsn(IFEQ, iffalse);
-            generate(state, ternary.iftrue());
-            convertTo(state, ternary.iftrue().type(), ternary.type());
-            mv.visitJumpInsn(GOTO, end);
-            mv.visitLabel(iffalse);
-            generate(state, ternary.iffalse());
-            convertTo(state, ternary.iffalse().type(), ternary.type());
-            mv.visitLabel(end);
-            break;
-        }
         default:
             throw new CodeGenException("Unexpected value: " + expr);
         }
@@ -1611,85 +1502,6 @@ public class Codegen {
         if (clazz instanceof TargetRecord)
             generateRecordMethods();
 
-        // Generate wrapper classes for function types
-        for (var pair : funWrapperClasses.keySet()) {
-            var className = funWrapperClasses.get(pair);
-            ClassWriter cw2 = new CustomClassWriter();
-            cw2.visit(V1_8, ACC_PUBLIC, className, null, "java/lang/Object", new String[] { pair.to.getInternalName() });
-            cw2.visitField(ACC_PRIVATE, "wrapped", pair.from.toDescriptor(), null, null).visitEnd();
-
-            // Generate constructor
-            var ctor = cw2.visitMethod(ACC_PUBLIC, "<init>", "(" + pair.from.toDescriptor() + ")V", null, null);
-            ctor.visitVarInsn(ALOAD, 0);
-            ctor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
-            ctor.visitVarInsn(ALOAD, 0);
-            ctor.visitVarInsn(ALOAD, 1);
-            ctor.visitFieldInsn(PUTFIELD, className, "wrapped", pair.from.toDescriptor());
-            ctor.visitInsn(RETURN);
-            ctor.visitMaxs(0, 0);
-            ctor.visitEnd();
-
-            String methodName = "apply";
-            String fromDescriptor = null;
-            TargetType fromReturn = null;
-            if (!(pair.from instanceof TargetFunNType funNType)) {
-                var fromClass = compiler.getClass(new JavaClassName(pair.from.name()));
-                var fromMethod = fromClass.getMethods().stream().filter(m -> (m.modifier & ACC_ABSTRACT) != 0).findFirst().orElseThrow();
-                methodName = fromMethod.name;
-
-                fromReturn = converter.convert(fromMethod.getReturnType());
-                var fromParams = converter.convert(fromMethod.getParameterList(), converter.generics.javaGenerics()).stream().map(m -> m.pattern().type()).toArray(TargetType[]::new);
-                fromDescriptor = TargetMethod.getDescriptor(fromReturn, fromParams);
-            } else {
-                fromReturn = funNType.returnArguments() > 0 ? TargetType.Object : null;
-                fromDescriptor = funNType.toMethodDescriptor();
-            }
-
-            var toClass = compiler.getClass(new JavaClassName(pair.to.name()));
-            var toMethod = toClass.getMethods().stream().filter(m -> (m.modifier & ACC_ABSTRACT) != 0).findFirst().orElseThrow();
-            var toReturn = converter.convert(toMethod.getReturnType());
-            var toParams = converter.convert(toMethod.getParameterList(), converter.generics.javaGenerics()).stream().map(m -> m.pattern().type()).toArray(TargetType[]::new);
-            var toDescriptor = TargetMethod.getDescriptor(toReturn, toParams);
-
-            // Generate wrapper method
-            var mv = cw2.visitMethod(ACC_PUBLIC, toMethod.name, toDescriptor, null, null);
-            var state = new State(null, mv, 0);
-
-            mv.visitVarInsn(ALOAD, 0);
-            mv.visitFieldInsn(GETFIELD, className, "wrapped", pair.from.toDescriptor());
-            for (var i = 0; i < toParams.length; i++) {
-                var arg = toParams[i];
-                mv.visitVarInsn(findLoadCode(arg), i + 1);
-            }
-            mv.visitMethodInsn(INVOKEINTERFACE, pair.from.getInternalName(), methodName, fromDescriptor, true);
-            if (fromReturn != null) {
-                if (toReturn instanceof TargetPrimitiveType) {
-                    convertTo(state, fromReturn, TargetType.toWrapper(toReturn));
-                } else convertTo(state, fromReturn, toReturn);
-            }
-
-            if (toReturn != null)
-                mv.visitInsn(findReturnCode(toReturn));
-
-            else mv.visitInsn(RETURN);
-            mv.visitMaxs(0, 0);
-            mv.visitEnd();
-
-            cw2.visitEnd();
-            var bytes = cw2.toByteArray();
-            converter.auxiliaries.put(className, bytes);
-
-            // TODO These class loading shenanigans happen in a few places, the tests load the classes individually.
-            // Instead we should just look at the folder.
-            try {
-                converter.classLoader.findClass(className);
-            } catch (ClassNotFoundException e) {
-                try {
-                    converter.classLoader.loadClass(bytes);
-                } catch (LinkageError ignored) {}
-            }
-        }
-
         cw.visitEnd();
         return cw.toByteArray();
     }

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

@@ -1,13 +1,11 @@
 package de.dhbwstuttgart.bytecode;
 
-import de.dhbwstuttgart.syntaxtree.statement.Break;
 import de.dhbwstuttgart.target.tree.TargetGeneric;
 import de.dhbwstuttgart.target.tree.type.*;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Type;
 
-import java.sql.Array;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -35,36 +33,6 @@ public class FunNGenerator {
     public static class GenericParameters {
         int start;
         public List<TargetType> parameters = new ArrayList<>();
-        final String descriptor;
-        public final List<TargetType> inParams;
-        public final List<TargetType> realParams;
-
-        public GenericParameters(List<TargetType> params, int numReturns) {
-            this.realParams = params;
-            this.inParams = flattenTypeParams(params);
-            var type = new TargetRefType(FunNGenerator.getSuperClassName(params.size() - 1, numReturns), params);
-            descriptor = applyDescriptor(type, this);
-        }
-
-        private static List<TargetType> flattenTypeParams(List<TargetType> params) {
-            var res = new ArrayList<TargetType>();
-            for (var param : params) {
-                if (param instanceof TargetSpecializedType tspec) {
-                    res.addAll(flattenTypeParams(tspec.params()));
-                } else {
-                    res.add(param);
-                }
-            }
-            return res;
-        }
-
-        public TargetType getReturnType() {
-            return FunNGenerator.getReturnType(realParams);
-        }
-
-        public List<TargetType> getArguments() {
-            return FunNGenerator.getArguments(realParams);
-        }
     }
 
     private static String applyDescriptor(TargetType type, GenericParameters gep) {
@@ -101,7 +69,7 @@ public class FunNGenerator {
         return applyNameDescriptor(type).replace("/", "$").replace(";", "$_$");
     }
 
-    public static byte[] generateSuperBytecode(int numberArguments, int numReturnTypes) {
+    public static byte[] generateSuperBytecode(int numberArguments) {
         StringBuilder superFunNClassSignature = new StringBuilder("<");
         StringBuilder superFunNMethodSignature = new StringBuilder("(");
         StringBuilder superFunNMethodDescriptor = new StringBuilder("(");
@@ -112,34 +80,30 @@ public class FunNGenerator {
             superFunNMethodDescriptor.append(objectSignature);
         }
         superFunNClassSignature.append(String.format("%s:%s>%s", returnGeneric, objectSignature, objectSignature));
-        if (numReturnTypes > 0) {
+        superFunNMethodSignature.append(String.format(")T%s;", returnGeneric));
-            superFunNMethodSignature.append(String.format(")T%s;", returnGeneric));
+        superFunNMethodDescriptor.append(String.format(")%s", objectSignature));
-            superFunNMethodDescriptor.append(String.format(")%s", objectSignature));
-        } else {
-            superFunNMethodSignature.append(")V");
-            superFunNMethodDescriptor.append(")V");
-        }
 
         System.out.println(superFunNMethodSignature);
 
         ClassWriter classWriter = new ClassWriter(0);
         MethodVisitor methodVisitor;
-        classWriter.visit(bytecodeVersion, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, getSuperClassName(numberArguments, numReturnTypes), superFunNClassSignature.toString(), objectSuperType, null);
+        classWriter.visit(bytecodeVersion, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, getSuperClassName(numberArguments), superFunNClassSignature.toString(), objectSuperType, null);
         methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, methodName, superFunNMethodDescriptor.toString(), superFunNMethodSignature.toString(), null);
         methodVisitor.visitEnd();
         classWriter.visitEnd();
         return classWriter.toByteArray();
     }
 
-    public static String getSuperClassName(int numberArguments, int returnArguments) {
+    public static String getSuperClassName(int numberArguments) {
-        return returnArguments > 0 ? String.format("Fun%d$$", numberArguments) : String.format("FunVoid%d$$", numberArguments);
+        return String.format("Fun%d$$", numberArguments);
     }
 
-    public static byte[] generateSpecializedBytecode(GenericParameters gep, List<String> superInterfaces) {
+    public static byte[] generateSpecializedBytecode(List<TargetType> argumentTypes, TargetType returnType, GenericParameters gep) {
-        var argumentTypes = gep.getArguments();
+        List<TargetType> parameters = Stream
-        var returnType = gep.getReturnType();
+                .concat(argumentTypes.stream(), Stream.of(returnType))
+                .toList();
 
-        StringBuilder funNClassSignature = new StringBuilder(objectSignature + gep.descriptor);
+        StringBuilder funNClassSignature = new StringBuilder(objectSignature + applyDescriptor(new TargetRefType(getSuperClassName(argumentTypes.size()), parameters), gep));
         boolean containsGeneric = false;
 
         String genericSignature = "<";
@@ -150,18 +114,10 @@ public class FunNGenerator {
 
         genericSignature += ">";
         if (containsGeneric) funNClassSignature.insert(0, genericSignature);
-
+        System.out.println(funNClassSignature.toString());
-        for (var superInterface : superInterfaces) {
-            funNClassSignature.append('L');
-            funNClassSignature.append(superInterface);
-            funNClassSignature.append(';');
-        }
-
-        var interfaces = new ArrayList<>(superInterfaces);
-        interfaces.add(getSuperClassName(argumentTypes.size(), returnType != null ? 1 : 0));
 
         ClassWriter classWriter = new ClassWriter(0);
-        classWriter.visit(bytecodeVersion, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, getSpecializedClassName(argumentTypes, returnType), funNClassSignature.toString(), objectSuperType, interfaces.toArray(String[]::new));
+        classWriter.visit(bytecodeVersion, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, getSpecializedClassName(argumentTypes, returnType), funNClassSignature.toString(), objectSuperType, new String[]{getSuperClassName(argumentTypes.size())});
         classWriter.visitEnd();
         return classWriter.toByteArray();
     }
@@ -177,24 +133,14 @@ public class FunNGenerator {
         }
     }
 
-    public static String getSpecializedClassName(GenericParameters gep) {
-        return getSpecializedClassName(gep.getArguments(), gep.getReturnType());
-    }
-
     public static String getSpecializedClassName(List<TargetType> argumentTypes, TargetType returnType) {
-        var arguments = argumentTypes
+        return String.format("Fun%d$$%s%s",
-            .stream()
-            .map(FunNGenerator::encodeType)
-            .collect(Collectors.joining());
-
-        if (returnType != null)
-            return String.format("Fun%d$$%s%s",
-                argumentTypes.size(),
-                arguments,
-                encodeType(returnType));
-        else return String.format("FunVoidImpl%d$$%s",
             argumentTypes.size(),
-            arguments);
+            argumentTypes
+                    .stream()
+                    .map(FunNGenerator::encodeType)
+                    .collect(Collectors.joining()),
+            encodeType(returnType));
     }
 
     public static List<TargetType> getArguments(List<TargetType> list) {
@@ -205,8 +151,8 @@ public class FunNGenerator {
     }
 
     public static TargetType getReturnType(List<TargetType> list) {
-        if(list.isEmpty())
+        if(list.size() == 0)
             throw new IndexOutOfBoundsException();
-        return list.getLast();
+        return list.get(list.size() - 1);
     }
 }

src/main/java/de/dhbwstuttgart/core/ConsoleInterface.java

@@ -2,8 +2,6 @@ package de.dhbwstuttgart.core;
 
 import java.io.File;
 import java.io.IOException;
-import java.io.OutputStream;
-import java.io.PrintStream;
 import java.util.*;
 public class ConsoleInterface {
 	private static final String directory = System.getProperty("user.dir");
@@ -37,9 +35,9 @@ public class ConsoleInterface {
                 input.add(new File(arg));
             }
         }
-		JavaTXCompiler compiler = new JavaTXCompiler(input, classpath, outputPath != null ? new File(outputPath) : null);
+		JavaTXCompiler compiler = new JavaTXCompiler(input, classpath);
 		//compiler.typeInference();
-		compiler.generateBytecode();
+		compiler.generateBytecode(outputPath);
 	}
 
 

src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java

@@ -1,6 +1,7 @@
 //PL 2018-12-19: typeInferenceOld nach typeInference uebertragen
 package de.dhbwstuttgart.core;
 
+import com.google.common.collect.Lists;
 import de.dhbwstuttgart.bytecode.Codegen;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
 import de.dhbwstuttgart.environment.DirectoryClassLoader;
@@ -30,6 +31,7 @@ import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
 import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.target.generate.ASTToTargetAST;
 import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.target.tree.expression.TargetBinaryOp;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
@@ -49,9 +51,13 @@ import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
 import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
 import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
 
-import java.io.*;
+import java.io.File;
-import java.lang.reflect.Modifier;
+import java.io.FileOutputStream;
-import java.nio.file.Path;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.sql.Array;
 import java.util.*;
 import java.util.Map.Entry;
 import java.util.function.Function;
@@ -68,17 +74,16 @@ public class JavaTXCompiler {
 
     Boolean log = false; //gibt an ob ein Log-File nach System.getProperty("user.dir")+""/logFiles/"" geschrieben werden soll?
     public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
-    public final DirectoryClassLoader classLoader;
+    private final DirectoryClassLoader classLoader;
 
-	public final List<File> classPath;
+	private final List<File> classPath;
-	private final File outputPath;
 
 	public DirectoryClassLoader getClassLoader() {
 		return classLoader;
 	}
    
 	public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
-		this(Arrays.asList(sourceFile), List.of(), new File("."));
+		this(Arrays.asList(sourceFile), null);
 	}
 
 	public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
@@ -87,20 +92,17 @@ public class JavaTXCompiler {
 	}
 
 	public JavaTXCompiler(List<File> sourceFiles) throws IOException, ClassNotFoundException {
-		this(sourceFiles, List.of(), new File("."));
+		this(sourceFiles, null);
 	}
 
-	public JavaTXCompiler(List<File> sources, List<File> contextPath, File outputPath) throws IOException, ClassNotFoundException {
+	public JavaTXCompiler(List<File> sources, List<File> contextPath) throws IOException, ClassNotFoundException {
-		var path = new ArrayList<>(contextPath);
+		if (contextPath == null || contextPath.isEmpty()) {
-		if (contextPath.isEmpty()) {
 			// When no contextPaths are given, the working directory is the sources root
-			path.add(new File(System.getProperty("user.dir")));
+			contextPath = Lists.newArrayList(new File(System.getProperty("user.dir")));
 		}
-		if (outputPath != null) path.add(outputPath);
+		classLoader = new DirectoryClassLoader(contextPath, ClassLoader.getSystemClassLoader());
-		classLoader = new DirectoryClassLoader(path, ClassLoader.getSystemClassLoader());
+		environment = new CompilationEnvironment(sources);
-		environment = new CompilationEnvironment(sources, classLoader);
+		classPath = contextPath;
-		classPath = path;
-		this.outputPath = outputPath;
 
 		for (File s : sources) {
 			parse(s);
@@ -113,7 +115,6 @@ public class JavaTXCompiler {
 	}
 
 	public ClassOrInterface getClass(JavaClassName name) {
-		if (loadedClasses.containsKey(name)) return loadedClasses.get(name).cif();
 		for (var sf : sourceFiles.values()) {
 			for (var clazz : sf.KlassenVektor) {
 				if (clazz.getClassName().equals(name)) return clazz;
@@ -127,48 +128,32 @@ public class JavaTXCompiler {
 		return null;
 	}
 
-	public ConstraintSet<Pair> getConstraints(File sourceFile) throws ClassNotFoundException, IOException {
+	public ConstraintSet<Pair> getConstraints() throws ClassNotFoundException, IOException {
 		Set<ClassOrInterface> allClasses = new HashSet<>();// environment.getAllAvailableClasses();
-		ClassOrInterface objectClass = ASTFactory.createClass(Object.class);
+		ClassOrInterface objectClass = ASTFactory.createClass(classLoader.loadClass(new JavaClassName("java.lang.Object").toString()));
-		var recordClass = ASTFactory.createClass(Record.class);
+		// Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
-		allClasses.add(objectClass);
+		for (Entry<File, SourceFile> source : sourceFiles.entrySet()) {
-		allClasses.add(recordClass);
+			var importedClasses = new ArrayList<ClassOrInterface>();
-
+			for (JavaClassName name : source.getValue().getImports()) {
-		var sf = sourceFiles.get(sourceFile);
+				importedClasses.addAll(getAvailableClasses(name));
-		var importedClasses = new ArrayList<ClassOrInterface>();
-		for (JavaClassName name : sf.getImports()) {
-			importedClasses.addAll(getAvailableClasses(name));
-		}
-		for (Class c : CompilationEnvironment.loadDefaultPackageClasses(sf.getPkgName(), sourceFile, this)) {
-			ClassOrInterface importedClass = ASTFactory.createClass(c);
-			importedClasses.add(importedClass);
-		}
-		sf.availableClasses.addAll(importedClasses);
-
-		SourceFile sf_new = new SourceFile(sf.getPkgName(), sf.KlassenVektor.stream().map(cl -> new ClassOrInterface(cl)).collect(Collectors.toCollection(ArrayList::new)), sf.imports);
-		// sf enthaelt neues Source-File, neue Klassen-Objekte und neue
-		// ArrayListen-Objekte fuer Fields, Construktoren und Methoden
-		// Alle anderen Objekte werden nur kopiert.
-		var isCached = false;
-		for (var clazz : sf.availableClasses) {
-			if (loadedClasses.containsKey(clazz.getClassName())) {
-				allClasses.removeIf(cl -> cl.getClassName().equals(clazz.getClassName()));
-				var cif = loadedClasses.get(clazz.getClassName()).cif();
-				allClasses.add(cif);
-				isCached = true;
 			}
+			for (Class c : CompilationEnvironment.loadDefaultPackageClasses(source.getValue().getPkgName(), source.getKey(), this)) {
+				ClassOrInterface importedClass = ASTFactory.createClass(c);
+				importedClasses.add(importedClass);
+			}
+			source.getValue().availableClasses.addAll(importedClasses);
 		}
-
+		for (File f : this.sourceFiles.keySet()) {
-		if (!isCached) {
+			SourceFile sf = sourceFiles.get(f);
+			SourceFile sf_new = new SourceFile(sf.getPkgName(), sf.KlassenVektor.stream().map(cl -> new ClassOrInterface(cl)).collect(Collectors.toCollection(ArrayList::new)), sf.imports);
+			// sf enthaelt neues Source-File, neue Klassen-Objekte und neue
+			// ArrayListen-Objekte fuer Fields, Construktoren und Methoden
+			// Alle anderen Objekte werden nur kopiert.
 			sf_new.KlassenVektor.forEach(cl -> addMethods(sf_new, cl, sf.availableClasses, objectClass));
 			allClasses.addAll(sf_new.getClasses());
 		}
-
+		TYPE ty = new TYPE(sourceFiles.values(), allClasses);
-		allClasses.addAll(sf.KlassenVektor);
+		return ty.getConstraints();
-
-		TYPE ty = new TYPE(sf, allClasses);
-		var constraints = ty.getConstraints();
-		return constraints;
 	}
 
 	void addMethods(SourceFile sf, ClassOrInterface cl, List<ClassOrInterface> importedClasses, ClassOrInterface objectClass) {
@@ -198,35 +183,36 @@ public class JavaTXCompiler {
 			while (paraIt.hasNext()) {
 				gtvs.put(tvarVarIt.next().getName(), paraIt.next());
 			}
-
+			Iterator<Method> methodIt = superclass.getMethods().iterator();
-            for (Method m : superclass.getMethods()) {
+			// TODO: PL 2020-05-06: Hier müssen ueberschriebene Methoden noch rausgefiltert
-                if (m.isInherited || Modifier.isStatic(m.modifier)) continue;
+			// werden
-				// TODO: Add gtvs from method itself
+			while (methodIt.hasNext()) {
-
+				Method m = methodIt.next();
-                ParameterList newParaList = new ParameterList(m.getParameterList().getFormalparalist().stream().map(fp -> fp.withType(fp.getType().acceptTV(new TypeExchanger(gtvs)))).collect(Collectors.toCollection(ArrayList::new)), m.getParameterList().getOffset());
+				ParameterList newParaList = new ParameterList(m.getParameterList().getFormalparalist().stream().map(fp -> fp.withType(fp.getType().acceptTV(new TypeExchanger(gtvs)))).collect(Collectors.toCollection(ArrayList::new)), m.getParameterList().getOffset());
-                cl.getMethods().add(new Method(m.modifier, m.name, m.getReturnType().acceptTV(new TypeExchanger(gtvs)), newParaList, m.block,
+				cl.getMethods().add(new Method(m.modifier, m.name, m.getReturnType().acceptTV(new TypeExchanger(gtvs)), newParaList, m.block,
-                        // new GenericDeclarationList(newGenericsList,
+						// new GenericDeclarationList(newGenericsList,
-                        // ((GenericDeclarationList)m.getGenerics()).getOffset()),
+						// ((GenericDeclarationList)m.getGenerics()).getOffset()),
-                        (GenericDeclarationList) m.getGenerics(), m.getOffset(), true, false));
+						(GenericDeclarationList) m.getGenerics(), m.getOffset(), true));
-            }
+			}
 
 		}
 		cl.setMethodsAdded();
 	}
 
-	private Set<ClassOrInterface> getAvailableClasses(JavaClassName name) throws ClassNotFoundException {
+	private List<ClassOrInterface> getAvailableClasses(JavaClassName name) throws ClassNotFoundException {
 		Set<ClassOrInterface> allClasses = new HashSet<>();
-		var clazz = loadJavaTXClass(name);
+		if (loadJavaTXClass(name)) {
-		if (clazz == null) {
+			var file = findFileForClass(name);
+			var sf = sourceFiles.get(file);
+			if (sf != null) allClasses.addAll(sf.KlassenVektor);
+		} else {
 			ClassOrInterface importedClass = ASTFactory.createClass(classLoader.loadClass(name.toString()));
 			allClasses.add(importedClass);
-		} else {
-			allClasses.add(clazz);
 		}
-		return allClasses;
+		return new ArrayList<>(allClasses);
 	}
 
-	public Set<ClassOrInterface> getAvailableClasses(SourceFile forSourceFile) throws ClassNotFoundException {
+	public List<ClassOrInterface> getAvailableClasses(SourceFile forSourceFile) throws ClassNotFoundException {
 		// PL 2018-09-18: List durch Set ersetzt, damit die Klassen nur einmal
 		// hinzugefuegt werden
 		// List<ClassOrInterface> allClasses = new
@@ -236,7 +222,7 @@ public class JavaTXCompiler {
 		for (JavaClassName name : forSourceFile.getImports()) {
 			allClasses.addAll(getAvailableClasses(name));
 		}
-		return allClasses;
+		return new ArrayList<>(allClasses);
 	}
 
 	/*
@@ -292,21 +278,17 @@ public class JavaTXCompiler {
 			allClasses.addAll(CompilationEnvironment.loadDefaultPackageClasses(sf.getPkgName(), source.getKey(), this).stream().map(ASTFactory::createClass).collect(Collectors.toList()));
 		}
 
-		final ConstraintSet<Pair> cons = new ConstraintSet<>();
+		final ConstraintSet<Pair> cons = getConstraints();
-		for (var f : this.sourceFiles.keySet()) {
-			cons.addAll(getConstraints(f));
-		}
-
 		Set<Set<UnifyPair>> results = new HashSet<>();
 		UnifyResultModel urm = null;
 		// urm.addUnifyResultListener(resultListener);
 		try {
 			logFile = logFile == null ? new FileWriter(new File("log_" + sourceFiles.keySet().iterator().next().getName())) : logFile;
-			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile, getClassLoader(), this);
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile, getClassLoader());
 			System.out.println(finiteClosure);
 			urm = new UnifyResultModel(cons, finiteClosure);
 			urm.addUnifyResultListener(resultListener);
-			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons);
+			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
 
 			Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
 				UnifyType lhs, rhs;
@@ -323,8 +305,8 @@ public class JavaTXCompiler {
 			TypeUnify unify = new TypeUnify();
 			// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
 			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
-			for (SourceFile f : this.sourceFiles.values()) {
+			for (SourceFile sf : this.sourceFiles.values()) {
-				logFile.write(ASTTypePrinter.print(f));
+				logFile.write(ASTTypePrinter.print(sf));
 			}
 			logFile.flush();
 
@@ -417,29 +399,32 @@ public class JavaTXCompiler {
 		return urm;
 	}
 
-	public List<ResultSet> typeInference(File file) throws ClassNotFoundException, IOException {
+	public List<ResultSet> typeInference() throws ClassNotFoundException, IOException {
-		var sf = sourceFiles.get(file);
+		List<ClassOrInterface> allClasses = new ArrayList<>();// environment.getAllAvailableClasses();
-		Set<ClassOrInterface> allClasses = new HashSet<>();// environment.getAllAvailableClasses();
+		// Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
-		allClasses.addAll(getAvailableClasses(sf));
+		for (Entry<File, SourceFile> source : this.sourceFiles.entrySet()) {
-		allClasses.addAll(sf.getClasses());
+			SourceFile sf = source.getValue();
-		var newClasses = CompilationEnvironment.loadDefaultPackageClasses(sf.getPkgName(), file, this).stream().map(ASTFactory::createClass).collect(Collectors.toSet());
+			allClasses.addAll(getAvailableClasses(sf));
-		for (var clazz : newClasses) {
+			allClasses.addAll(sf.getClasses());
-			// Don't load classes that get recompiled
+			var newClasses = CompilationEnvironment.loadDefaultPackageClasses(sf.getPkgName(), source.getKey(), this).stream().map(ASTFactory::createClass).collect(Collectors.toList());
-			if (sf.getClasses().stream().anyMatch(nf -> nf.getClassName().equals(clazz.getClassName())))
+			for (var clazz : newClasses) {
-				continue;
+				// Don't load classes that get recompiled
-			if (allClasses.stream().noneMatch(old -> old.getClassName().equals(clazz.getClassName())))
+				if (sf.getClasses().stream().anyMatch(nf -> nf.getClassName().equals(clazz.getClassName())))
-				allClasses.add(clazz);
+					continue;
+				if (allClasses.stream().noneMatch(old -> old.getClassName().equals(clazz.getClassName())))
+					allClasses.add(clazz);
+			}
 		}
 
-		final ConstraintSet<Pair> cons = getConstraints(file);
+		final ConstraintSet<Pair> cons = getConstraints();
 		Set<Set<UnifyPair>> results = new HashSet<>();
 		try {
 			var logFolder = new File(System.getProperty("user.dir") + "/logFiles/");
 			if (log) logFolder.mkdirs();
 			Writer logFile = log ? new FileWriter(new File(logFolder, "log_" + sourceFiles.keySet().iterator().next().getName())) : new OutputStreamWriter(new NullOutputStream());
-			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logFile, classLoader, this);
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile, classLoader);
 			System.out.println(finiteClosure);
-			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons);
+			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
 			System.out.println("xxx1");
 			Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
 				UnifyType lhs, rhs;
@@ -458,8 +443,10 @@ public class JavaTXCompiler {
 			TypeUnify unify = new TypeUnify();
 			// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
 			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
-			logFile.write(ASTTypePrinter.print(sf));
+			for (SourceFile sf : this.sourceFiles.values()) {
-			System.out.println(ASTTypePrinter.print(sf));
+				logFile.write(ASTTypePrinter.print(sf));
+				System.out.println(ASTTypePrinter.print(sf));
+			}
 			logFile.flush();
 
 			Set<String> methodParaTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().map(y -> y.getParameterList().getFormalparalist().stream().filter(z -> z.getType() instanceof TypePlaceholder).map(z -> ((TypePlaceholder) z.getType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce(new HashSet<String>(), (a, b) -> {
@@ -661,20 +648,14 @@ public class JavaTXCompiler {
 
 	public final JavaClassRegistry classRegistry = new JavaClassRegistry();
 
-	public record ClassEntry(File classFile, ClassOrInterface cif) {}
-
-	public final Map<JavaClassName, ClassEntry> loadedClasses = new HashMap<>();
-
 	private SourceFile parse(File sourceFile) throws IOException, java.lang.ClassNotFoundException {
-		if (sourceFiles.containsKey(sourceFile)) return sourceFiles.get(sourceFile);
 		SourceFileContext tree = JavaTXParser.parse(sourceFile);
 		environment.addClassesToRegistry(classRegistry, tree, sourceFile, this);
 		SyntaxTreeGenerator generator = new SyntaxTreeGenerator(this, classRegistry, new GenericsRegistry(null), sourceFile.getName());
 		var classes = new ArrayList<ClassOrInterface>();
-		var sf = new SourceFile("", classes, generator.imports);
+		var sf = new SourceFile(generator.pkgName, classes, generator.imports);
 		addSourceFile(sourceFile, sf);
 		generator.convert(classes, tree, environment.packageCrawler);
-		sf.setPackageName(generator.pkgName);
 		sf.imports.addAll(generator.imports);
 		return sf;
 	}
@@ -684,33 +665,25 @@ public class JavaTXCompiler {
 	 * if it doesn't exist it's going to compile it and add it to the source files list
 	 * @param name
 	 */
-	public ClassOrInterface loadJavaTXClass(JavaClassName name) {
+	public boolean loadJavaTXClass(JavaClassName name) {
 		var file = findFileForClass(name);
 		if (file != null) {
-			if (loadedClasses.containsKey(name)) return loadedClasses.get(name).cif();
+			if (classRegistry.contains(name)) return true;
 			try {
 				var tree = JavaTXParser.parse(file);
 				classRegistry.addName(name.toString(), 0); // TODO This gets overwritten later, is it bad if we don't know this right away?
 				environment.addClassesToRegistry(classRegistry, tree, file, this);
 				SyntaxTreeGenerator generator = new SyntaxTreeGenerator(this, classRegistry, new GenericsRegistry(null), file.getName());
 				var classes = new ArrayList<ClassOrInterface>();
-				var sf = new SourceFile("", classes, generator.imports);
+				var sf = new SourceFile(generator.pkgName, classes, generator.imports);
 				addSourceFile(file, sf);
 				generator.convert(classes, tree, environment.packageCrawler);
-				sf.setPackageName(generator.pkgName);
+				return true;
-				var classFiles = generateBytecode(file);
-
-				sf.setGenerated();
-				writeClassFile(classFiles, outputPath != null ? outputPath : new File("."), false);
-				var clazz = classLoader.loadClass(name.toString());
-				var classOrInterface = ASTFactory.createClass(clazz);
-				loadedClasses.put(name, new ClassEntry(new File(outputPath, clazz.getName() + ".class"), classOrInterface));
-				return classOrInterface;
 			} catch (Exception e) {
 				throw new RuntimeException(e);
 			}
 		}
-		return null;
+		return false;
 	}
 
 	public File findFileForClass(JavaClassName name) {
@@ -724,26 +697,25 @@ public class JavaTXCompiler {
 	}
 
 	public void generateBytecode() throws ClassNotFoundException, IOException {
-		for (var file : sourceFiles.keySet()) {
+		generateBytecode((File) null);
-			var sf = sourceFiles.get(file);
+	}
-			if (sf.isGenerated()) continue;
+
-			var classes = generateBytecode(file);
+	/**
-			sf.setGenerated();
+	 * @param path - can be null, then class file output is in the same directory as the parsed source files
-			writeClassFile(classes, outputPath == null ? file.getParentFile() : outputPath, outputPath == null);
+	 */
-		}
+	public void generateBytecode(String path) throws ClassNotFoundException, IOException {
+		if (path != null)
+			generateBytecode(new File(path));
+		else
+			generateBytecode();
 	}
 
 	/**
 	 * @param path - output-Directory can be null, then class file output is in the same directory as the parsed source files
-	 * @return
 	 */
-	public Map<JavaClassName, byte[]> generateBytecode(File sourceFile) throws ClassNotFoundException, IOException {
+	public void generateBytecode(File path) throws ClassNotFoundException, IOException {
-		var sf = sourceFiles.get(sourceFile);
+		List<ResultSet> typeinferenceResult = this.typeInference();
-		if (sf.isGenerated()) return null;
+		generateBytecode(path, typeinferenceResult);
-		List<ResultSet> typeinferenceResult = this.typeInference(sourceFile);
-		var classes = generateBytecode(sf, typeinferenceResult);
-		sf.setGenerated();
-		return classes;
 	}
 
 	private Map<SourceFile, List<GenericsResult>> generatedGenerics = new HashMap<>();
@@ -761,13 +733,15 @@ public class JavaTXCompiler {
 		for (File f : sourceFiles.keySet()) {
 			HashMap<JavaClassName, byte[]> classFiles = new HashMap<>();
 			SourceFile sf = sourceFiles.get(f);
-			File path = outputPath;
+			File path;
 			if (outputPath == null) {
 				path = f.getParentFile(); // Set path to path of the parsed .jav file
+			} else {
+				path = new File(outputPath, sf.getPkgName().replace(".", "/")); // add package path to root path
 			}
 
 			var generatedClasses = generateBytecode(sf, typeinferenceResult);
-			writeClassFile(generatedClasses, path, outputPath == null);
+			writeClassFile(generatedClasses, path);
 		}
 	}
 
@@ -775,7 +749,7 @@ public class JavaTXCompiler {
 		var converter = new ASTToTargetAST(this, typeInferenceResult, sf, classLoader);
 		var generatedClasses = new HashMap<JavaClassName, byte[]>();
 		for (var clazz : sf.getClasses()) {
-			var codegen = new Codegen(converter.convert(clazz), this, converter);
+			var codegen = new Codegen(converter.convert(clazz), this);
 			var code = codegen.generate();
 			generatedClasses.put(clazz.getClassName(), code);
 			converter.auxiliaries.forEach((name, source) -> {
@@ -783,19 +757,18 @@ public class JavaTXCompiler {
 			});
 		}
 		generatedGenerics.put(sf, converter.javaGenerics());
-		converter.generateFunNTypes();
 		return generatedClasses;
 	}
 
-	public synchronized void writeClassFile(Map<JavaClassName, byte[]> classFiles, File path, boolean preserveHierarchy) throws IOException {
+	public synchronized void writeClassFile(Map<JavaClassName, byte[]> classFiles, File path) throws IOException {
 		FileOutputStream output;
 		for (JavaClassName name : classFiles.keySet()) {
 			byte[] bytecode = classFiles.get(name);
 			System.out.println("generating " + name + ".class file ...");
-			var subPath = preserveHierarchy ? path : Path.of(path.toString(), name.getPackageName().split("\\.")).toFile();
+			// output = new FileOutputStream(new File(System.getProperty("user.dir") +
-			File outputFile = new File(subPath, name.getClassName() + ".class");
+			// "/testBytecode/generatedBC/" +name+".class"));
+			File outputFile = new File(path, name.getClassName() + ".class");
 			outputFile.getAbsoluteFile().getParentFile().mkdirs();
-			System.out.println(outputFile);
 			output = new FileOutputStream(outputFile);
 			output.write(bytecode);
 			output.close();

src/main/java/de/dhbwstuttgart/environment/CompilationEnvironment.java

@@ -34,7 +34,7 @@ public class CompilationEnvironment {
 	 * 
 	 * @param sourceFiles die zu kompilierenden Dateien
 	 */
-	public CompilationEnvironment(List<File> sourceFiles, DirectoryClassLoader classLoader) {
+	public CompilationEnvironment(List<File> sourceFiles) {
 		/**
 		 * Java 9 bringt einige Änderungen am Classloader So funktioniert der BootClassLoader nicht mehr. hier gibts ein paar Quellen zum nachlesen: http://java9.wtf/class-loading/ https://stackoverflow.com/questions/46494112/classloaders-hierarchy-in-java-9
 		 *
@@ -54,7 +54,7 @@ public class CompilationEnvironment {
 		// librarys = Arrays.asList(loader.getURLs());
 
 		this.sourceFiles = sourceFiles;
-		this.packageCrawler = new PackageCrawler(classLoader);
+		this.packageCrawler = new PackageCrawler(librarys);
 	}
 
 	public void addClassesToRegistry(JavaClassRegistry registry, SourceFileContext tree, File sourceFile, JavaTXCompiler compiler) throws ClassNotFoundException, IOException {
@@ -77,7 +77,7 @@ public class CompilationEnvironment {
 		// Set classLoader to include default package for this specific source file
 		File dir = sourceFile.getAbsoluteFile().getParentFile();
 		String dirPath = dir.toString() + "/";
-		if (!packageName.isEmpty())
+		if (packageName.length() > 0)
 			dirPath = dirPath.substring(0, dirPath.length() - packageName.length() - 1);
 		String path = dirPath;
 		ArrayList<File> defaultPath = Lists.newArrayList(new File(path));
@@ -89,10 +89,7 @@ public class CompilationEnvironment {
 				String className = classFile.getName().substring(0, classFile.getName().length() - 6);
 				if (className.matches("Fun\\d+\\$\\$.*"))
 					continue;
-				var name = packageName;
+				ret.add(classLoader.loadClass(packageName + className));
-				if (!packageName.isEmpty()) name += ".";
-				name += className;
-				ret.add(classLoader.loadClass(name));
 			}
 		return ret;
 	}
@@ -104,4 +101,12 @@ public class CompilationEnvironment {
 		return packageName;
 	}
 
+	public List<ClassOrInterface> getAllAvailableClasses() {
+		List<ClassOrInterface> ret = new ArrayList<>();
+		for (Class c : new PackageCrawler(librarys).getAllAvailableClasses()) {
+			ret.add(ASTFactory.createClass(c));
+		}
+		return ret;
+	}
+
 }

src/main/java/de/dhbwstuttgart/environment/DirectoryClassLoader.java

@@ -5,61 +5,31 @@ import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
-import java.nio.file.*;
+import java.nio.file.Files;
-import java.util.ArrayList;
+import java.nio.file.Path;
 import java.util.List;
 import java.util.stream.Collectors;
 
 public class DirectoryClassLoader extends URLClassLoader implements IByteArrayClassLoader {
-//    public DirectoryClassLoader(File directory, java.lang.ClassLoader parent) {
+    public DirectoryClassLoader(File directory, java.lang.ClassLoader parent) {
-//        super(generateURLArray(dirToURL(directory)), parent);
+        super(generateURLArray(dirToURL(directory)), parent);
-//    }
+    }
 
     public DirectoryClassLoader(List<File> directory, java.lang.ClassLoader parent) {
-        super(directory.stream().map(DirectoryClassLoader::dirToURL).flatMap(List::stream).collect(Collectors.toList()).toArray(new URL[0]), parent.getParent());
+        super(directory.stream().map(DirectoryClassLoader::dirToURL).collect(Collectors.toList()).toArray(new URL[0]), parent);
     }
 
     private static URL[] generateURLArray(URL url) {
         return new URL[]{url};
     }
 
-    private static List<URL> dirToURL(File file) {
+    private static URL dirToURL(File url){
-        //if(!url.isDirectory())throw new RuntimeException(url.toString() + " is not a directory");
+        if(!url.isDirectory())throw new RuntimeException(url.toString() + " is not a directory");
-
-        Path dir;
-        if (file.isDirectory()) {
-            try {
-                return List.of(file.toURI().toURL()); // if file is a directory, use it as is
-            } catch (MalformedURLException e) {
-                e.printStackTrace();
-                return List.of();
-            }
-        }
-
-        dir = file.toPath().getParent(); // if file is not a directory, get its parent directory
-        String pattern = file.toPath().getFileName().toString(); // use the file name as a glob pattern
-
-        List<URL> urls = new ArrayList<>();
-
         try {
-            urls = Files.walk(dir)
+            return url.toURI().toURL();
-                    .filter(Files::isRegularFile) // only consider files (not directories)
+        } catch (MalformedURLException e) {
-                    .filter(path -> {
+            throw new RuntimeException(e);
-                        PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:" + pattern);
-                        return matcher.matches(path.getFileName()); // match the file name against the pattern
-                    })
-                    .map(path -> {
-                        try {
-                            return path.toUri().toURL();
-                        } catch (MalformedURLException e) {
-                            throw new RuntimeException(e);
-                        }
-                    }) // convert the path to a URL
-                    .toList(); // print the path of each matching file
-        } catch (IOException | RuntimeException e) {
-            e.printStackTrace();
         }
-        return urls;
     }
 
     @Override
@@ -71,8 +41,4 @@ public class DirectoryClassLoader extends URLClassLoader implements IByteArrayCl
     public Class<?> findClass(String name) throws ClassNotFoundException {
         return super.findClass(name);
     }
-
-    public Class<?> _findLoadedClass(String name) throws ClassNotFoundException {
-        return super.findLoadedClass(name);
-    }
 }

src/main/java/de/dhbwstuttgart/environment/PackageCrawler.java

@@ -1,10 +1,17 @@
 package de.dhbwstuttgart.environment;
 
-import io.github.classgraph.ClassGraph;
+import java.net.URL;
-import io.github.classgraph.ScanResult;
-
 import java.util.*;
 
+import org.reflections.Reflections;
+import org.reflections.scanners.ResourcesScanner;
+import org.reflections.scanners.SubTypesScanner;
+import org.reflections.util.ConfigurationBuilder;
+import org.reflections.util.FilterBuilder;
+
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import org.reflections.vfs.SystemDir;
+
 /**
  * Hilft beim Durchsuchen von Packages
  * Benutzt die Reflections-Library (https://github.com/ronmamo/reflections)
@@ -12,30 +19,48 @@ import java.util.*;
  */
 public class PackageCrawler {
 
-	final DirectoryClassLoader classLoader;
+	final URL[] urls;
-	public PackageCrawler(DirectoryClassLoader classLoader) {
+	public PackageCrawler(List<URL> urlList) {
-		this.classLoader = classLoader;
+		urls = urlList.toArray(new URL[0]);
 	}
 	
-    public Set<Class<?>> getClassesInPackage(String packageName) {
+    public Set<Class<?>> getClassesInPackage(String packageName){
-        var res = new HashSet<Class<?>>();
+    	/*
+        List<DirectoryClassLoader> classLoadersList = new LinkedList<DirectoryClassLoader>();
+        classLoadersList.add(Thread.currentThread().getContextClassLoader());
+        classLoadersList.add(ClasspathHelper.staticClassLoader());
+        classLoadersList.add(Thread.currentThread().getContextClassLoader().getParent());
+        classLoadersList.add(DirectoryClassLoader.getSystemClassLoader());
+        String bootClassPath = System.getProperty("sun.boot.class.path");
+        ArrayList<URL> urlList = new ArrayList<>();
+        for(String path : bootClassPath.split(";")) {
+        	try {
+				urlList.add(new URL("file:"+path));
+			} catch (MalformedURLException e) {
+				new DebugException("Fehler im Classpath auf diesem System");
+			}
+        }
+        URL[] urls = urlList.toArray(new URL[0]);
+        classLoadersList.add(new URLClassLoader(urls, DirectoryClassLoader.getSystemClassLoader()));
+        */
+        Reflections reflections = new Reflections(new ConfigurationBuilder()
+                .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner())
+                .setUrls(urls)
+                .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName))));
 
-        try (ScanResult result = new ClassGraph()
+        Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);
-            .enableClassInfo()
-            .enableSystemJarsAndModules()
-            .addClassLoader(classLoader)
-            .acceptPackages(packageName)
-            .scan()) {
 
-            for (var info : result.getAllClasses()) {
+        return classes;
-                try {
+    }
-                    var clazz = Class.forName(info.getName());
-                    res.add(clazz);
-                } catch (ClassNotFoundException ignored) {}
-            }
-        };
 
-        return res;
+    public Set<Class<?>> getAllAvailableClasses(){
+        Reflections reflections = new Reflections(new ConfigurationBuilder()
+                .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner())
+                .setUrls(urls));
+
+        Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);
+
+        return classes;
     }
 
   public Map<String, Integer> getClassNames(String packageName){

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
-import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
@@ -26,8 +25,8 @@ public class FCGenerator {
      *
      * @param availableClasses - Alle geparsten Klassen
      */
-    public static Set<UnifyPair> toUnifyFC(JavaTXCompiler compiler, Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
+    public static Set<UnifyPair> toUnifyFC(Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
-        return toFC(availableClasses, classLoader).stream().map(t -> UnifyTypeFactory.convert(compiler, t)).collect(Collectors.toSet());
+        return toFC(availableClasses, classLoader).stream().map(t -> UnifyTypeFactory.convert(t)).collect(Collectors.toSet());
     }
 
     public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
@@ -158,8 +157,7 @@ public class FCGenerator {
     }
 
     /**
-     * Tauscht die GTVs in einem Typ gegen die entsprechenden Typen in der übergebenen Map aus auf der direkten Argumentebene.
+     * Tauscht die GTVs in einem Typ gegen die entsprechenden Typen in der übergebenen Map aus.
-     * Hier sind keine Wildcards zulässig
      */
     private static class TypeExchanger implements TypeVisitor<RefTypeOrTPHOrWildcardOrGeneric>{
 
@@ -169,52 +167,6 @@ public class FCGenerator {
             this.gtvs = gtvs;
         }
 
-        @Override
-        public RefTypeOrTPHOrWildcardOrGeneric visit(RefType refType) {
-            List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
-            for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
-                params.add(param.acceptTV(new TypeExchangerInner(gtvs)));
-            }
-            RefTypeOrTPHOrWildcardOrGeneric ret = new RefType(refType.getName(), params, new NullToken());
-            return ret;
-        }
-
-        @Override
-        public RefTypeOrTPHOrWildcardOrGeneric visit(SuperWildcardType superWildcardType) {
-            throw new DebugException("Dieser Fall darf nicht auftreten");
-        }
-
-        @Override
-        public RefTypeOrTPHOrWildcardOrGeneric visit(TypePlaceholder typePlaceholder) {
-            throw new DebugException("Dieser Fall darf nicht auftreten");
-        }
-
-        @Override
-        public RefTypeOrTPHOrWildcardOrGeneric visit(ExtendsWildcardType extendsWildcardType) {
-            throw new DebugException("Dieser Fall darf nicht auftreten");
-        }
-
-        @Override
-        public RefTypeOrTPHOrWildcardOrGeneric visit(GenericRefType genericRefType) {
-            if(! gtvs.containsKey(genericRefType.getParsedName()))
-                throw new DebugException("Dieser Fall darf nicht auftreten");
-            return gtvs.get(genericRefType.getParsedName());
-        }
-
-    }
-    
-    /**
-     * Tauscht die GTVs in einem Typ gegen die entsprechenden Typen in der übergebenen Map aus auf den Argumenten der Argumente.
-     * Hier sind Wildcards zulässig
-     */
-    private static class TypeExchangerInner implements TypeVisitor<RefTypeOrTPHOrWildcardOrGeneric>{
-
-        private final HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs;
-
-        TypeExchangerInner(HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs){
-            this.gtvs = gtvs;
-        }
-
         @Override
         public RefTypeOrTPHOrWildcardOrGeneric visit(RefType refType) {
             List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
@@ -227,7 +179,7 @@ public class FCGenerator {
 
         @Override
         public RefTypeOrTPHOrWildcardOrGeneric visit(SuperWildcardType superWildcardType) {
-            return superWildcardType;
+            throw new DebugException("Dieser Fall darf nicht auftreten");
         }
 
         @Override
@@ -237,7 +189,7 @@ public class FCGenerator {
 
         @Override
         public RefTypeOrTPHOrWildcardOrGeneric visit(ExtendsWildcardType extendsWildcardType) {
-            return extendsWildcardType;
+            throw new DebugException("Dieser Fall darf nicht auftreten");
         }
 
         @Override
@@ -248,5 +200,4 @@ public class FCGenerator {
         }
 
     }
-    
 }

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

@@ -279,8 +279,7 @@ public class StatementGenerator {
 
         if (!Objects.isNull(creator.classCreatorRest())) {
             ArgumentList args = convertArguments(creator.classCreatorRest().arguments().expressionList());
-            ArrayList<TypePlaceholder> argTypes = args.getArguments().stream().map(x -> TypePlaceholder.fresh(creator.getStart())).collect(Collectors.toCollection(ArrayList::new));
+            ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = args.getArguments().stream().map(x -> TypePlaceholder.fresh(creator.getStart())).collect(Collectors.toCollection(ArrayList::new));
-            argTypes.add(TypePlaceholder.fresh(creator.getStart())); // return type
             Statement ret = new NewClass(newclass, args, null, argTypes, creator.getStart());
             ret.setStatement();
             return ret;
@@ -311,7 +310,7 @@ public class StatementGenerator {
         IdentifierContext identifier = innercreator.identifier();
         RefType newclass = (RefType) TypeGenerator.convertTypeName(identifier.getText(), genericArgs, identifier.getStart(), reg, generics);
         ArgumentList args = convertArguments(innercreator.classCreatorRest().arguments().expressionList());
-        ArrayList<TypePlaceholder> argTypes = args.getArguments().stream().map(x -> TypePlaceholder.fresh(innercreator.getStart())).collect(Collectors.toCollection(ArrayList::new));
+        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = args.getArguments().stream().map(x -> TypePlaceholder.fresh(innercreator.getStart())).collect(Collectors.toCollection(ArrayList::new));
         Statement ret = new NewClass(newclass, args, null, argTypes, innercreator.getStart());
         ret.setStatement();
         return ret;
@@ -597,12 +596,8 @@ public class StatementGenerator {
     }
 
     private Statement convert(Java17Parser.ContinuestmtContext stmt) {
-        Token offset = stmt.getStart();
+        // TODO
-        if (!Objects.isNull(stmt.identifier())) {
+        throw new NotImplementedException();
-            return new Continue(localVars.get(stmt.identifier().getText()), offset);
-        } else {
-            return new Continue(TypePlaceholder.fresh(offset), offset);
-        }
     }
 
     private Statement convert(Java17Parser.SemistmtContext stmt) {
@@ -697,7 +692,6 @@ public class StatementGenerator {
         if (!Objects.isNull(expr.methodCall())) {
             return convert(expr.methodCall(), expr.expression(), offset);
         } else if (!Objects.isNull(expr.identifier())) {
-            // FIXME This is not the right way of handling any of this
             return generateLocalOrFieldVarOrClassName(expr.getText(), offset);
         } else {
             // Für alle anderen Optionen, wie Feldzugriff, Aufrufe von super oder explizite
@@ -717,7 +711,7 @@ public class StatementGenerator {
         }
 
         ArgumentList argumentList = convertArguments(expr.expressionList());
-        ArrayList<TypePlaceholder> signature = argumentList.getArguments().stream().map(x -> TypePlaceholder.fresh(offset)).collect(Collectors.toCollection(ArrayList::new));
+        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> signature = argumentList.getArguments().stream().map(x -> (RefTypeOrTPHOrWildcardOrGeneric) TypePlaceholder.fresh(offset)).collect(Collectors.toCollection(ArrayList::new));
         signature.add(TypePlaceholder.fresh(offset)); // return type
 
         MethodCall ret;
@@ -742,7 +736,7 @@ public class StatementGenerator {
             name = expr.SUPER().getText();
         }
         ArgumentList argumentList = convertArguments(expr.expressionList());
-        ArrayList<TypePlaceholder> signature = argumentList.getArguments().stream().map(x -> TypePlaceholder.fresh(offset)).collect(Collectors.toCollection(ArrayList::new));
+        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> signature = argumentList.getArguments().stream().map(x -> (RefTypeOrTPHOrWildcardOrGeneric) TypePlaceholder.fresh(offset)).collect(Collectors.toCollection(ArrayList::new));
         signature.add(TypePlaceholder.fresh(offset)); // return type
         MethodCall ret = new MethodCall(TypePlaceholder.fresh(offset), getReceiver(receiver), name, argumentList, TypePlaceholder.fresh(offset), signature, offset);
         ret.setStatement();
@@ -780,7 +774,6 @@ public class StatementGenerator {
      * @return
      */
     private Expression generateLocalOrFieldVarOrClassName(String expression, Token offset) {
-        // FIXME Why does this take a String argument???
         String[] parts = expression.split("\\.");
         if (parts.length < 2) {
             // Check for localVar:
@@ -810,7 +803,6 @@ public class StatementGenerator {
             // Check for Classname:
             if (reg.contains(whole)) {
                 receiver = generateStaticClassName(whole, offset);
-                break;
             }
             whole += ".";
         }
@@ -839,13 +831,7 @@ public class StatementGenerator {
     }
 
     private Expression convert(Java17Parser.ConditionalassignexpressionContext expression) {
-        return new Ternary(TypePlaceholder.fresh(
+        throw new NotImplementedException();
-            expression.getStart()),
-            convert(expression.expression(0)),
-            convert(expression.expression(1)),
-            convert(expression.expression(2)),
-            expression.getStart()
-        );
     }
 
     private Expression convert(Java17Parser.OrexpressionContext expression) {
@@ -898,15 +884,15 @@ public class StatementGenerator {
     }
 
     private Expression convert(Java17Parser.BitwiseorexpressionContext expression) {
-        return new BinaryExpr(BinaryExpr.Operator.OR, TypePlaceholder.fresh(expression.getStart()), convert(expression.expression(0)), convert(expression.expression(1)), expression.getStart());
+        throw new NotImplementedException();
     }
 
     private Expression convert(Java17Parser.BitwisexorexpressionContext expression) {
-        return new BinaryExpr(BinaryExpr.Operator.XOR, TypePlaceholder.fresh(expression.getStart()), convert(expression.expression(0)), convert(expression.expression(1)), expression.getStart());
+        throw new NotImplementedException();
     }
 
     private Expression convert(Java17Parser.BitwiseandexpressionContext expression) {
-        return new BinaryExpr(BinaryExpr.Operator.AND, TypePlaceholder.fresh(expression.getStart()), convert(expression.expression(0)), convert(expression.expression(1)), expression.getStart());
+        throw new NotImplementedException();
     }
 
     private Expression convert(Java17Parser.EqualityexpressionContext expression) {
@@ -971,8 +957,6 @@ public class StatementGenerator {
             return BinaryExpr.Operator.EQUAL;
         } else if (operator.equals("!=")) {
             return BinaryExpr.Operator.NOTEQUAL;
-        } else if (operator.equals("%")) {
-            return BinaryExpr.Operator.MOD;
         } else {
             throw new NotImplementedException();
         }
@@ -1011,9 +995,6 @@ public class StatementGenerator {
             ret = new UnaryExpr(UnaryExpr.Operation.PREDECREMENT, expr, TypePlaceholder.fresh(op), op);
             ret.setStatement();
             return ret;
-        } else if (op.getText().equals("!")) {
-            ret = new UnaryExpr(UnaryExpr.Operation.NOT, expr, TypePlaceholder.fresh(op), op);
-            return ret;
         } else {
             throw new NotImplementedException();
         }
@@ -1047,7 +1028,7 @@ public class StatementGenerator {
         case PrimaryThisContext primthis:
             return new This(primthis.getStart());
         case PrimarySuperContext primsuper:
-            return new Super(primsuper.getStart());
+            throw new NotImplementedException();
         case PrimaryLiteralContext primliteral:
             return convert(primliteral.literal());
         case PrimaryIdentifierContext primidentifier:
@@ -1062,17 +1043,10 @@ public class StatementGenerator {
     private Expression convert(Java17Parser.LiteralContext literal) {
         switch (literal) {
         case IntLiteralContext intliteral:
-            Number value;
+            Number value = Integer.parseInt(intliteral.getText());
-            if (intliteral.getText().endsWith("l") || intliteral.getText().endsWith("L"))
-                value = Long.parseLong(intliteral.getText().substring(0, intliteral.getText().length() - 1));
-            else value = Integer.parseInt(intliteral.getText());
             return new Literal(TypePlaceholder.fresh(literal.getStart()), value, intliteral.getStart());
         case FltLiteralContext floatliteral:
-            if (floatliteral.getText().endsWith("f") || floatliteral.getText().endsWith("F"))
+            value = Double.parseDouble(floatliteral.getText());
-                value = Float.parseFloat(floatliteral.getText().substring(0, floatliteral.getText().length() - 1));
-            else if (floatliteral.getText().endsWith("d") || floatliteral.getText().endsWith("D"))
-                value = Double.parseDouble(floatliteral.getText().substring(0, floatliteral.getText().length() - 1));
-            else value = Double.parseDouble(floatliteral.getText());
             return new Literal(TypePlaceholder.fresh(literal.getStart()), value, floatliteral.getStart());
         case CharLiteralContext charliteral:
             RefType type = new RefType(reg.getName("java.lang.Character"), charliteral.getStart());

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

@@ -34,11 +34,6 @@ public class SyntacticSugar {
         public void visit(ReturnVoid aReturn) {
             hasReturn = true;
         }
-        
-        @Override
-        public void visit(LambdaExpression le) {
-        	//PL 2024-04-09 Do nothing, as in a LambdaExpression a return could be
-        }
     }
 
     private static boolean hasReturn(Block block) {

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

@@ -71,6 +71,10 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.type.Void;
+import de.dhbwstuttgart.typeinference.constraints.GenericsResolver;
+import javassist.compiler.SyntaxError;
+
+import javax.swing.text.html.Option;
 
 public class SyntaxTreeGenerator {
   private JavaClassRegistry reg;
@@ -254,10 +258,7 @@ public class SyntaxTreeGenerator {
     List<RefType> implementedInterfaces = new ArrayList<>();
     List<Pattern> constructorParameters = new ArrayList<>();
     List<Statement> constructorStatements = new ArrayList<>();
-
+    for (RecordComponentContext component : recordDeclaration.recordHeader().recordComponentList().recordComponent()) {
-    List<Java17Parser.RecordComponentContext> components = recordDeclaration.recordHeader().recordComponentList() != null ?
-              recordDeclaration.recordHeader().recordComponentList().recordComponent(): List.of();
-    for (RecordComponentContext component : components) {
       int fieldmodifiers = allmodifiers.get("private") + allmodifiers.get("final");
       String fieldname = component.identifier().getText();
       Token fieldoffset = component.getStart();
@@ -332,7 +333,7 @@ public class SyntaxTreeGenerator {
 
   private ClassOrInterface convertInterface(Java17Parser.InterfaceDeclarationContext ctx, int modifiers) {
     this.superClass = new RefType(new JavaClassName("java.lang.Object"), new NullToken());
-    String className = (this.pkgName.length() > 0 ? this.pkgName + "." : "") + ctx.identifier().getText();
+    String className = this.pkgName.length() > 0 ? this.pkgName + "." : "" + ctx.identifier().getText();
     JavaClassName name = reg.getName(className); // Holt den Package Namen mit dazu
     if (!name.toString().equals(className)) { // Kommt die Klasse schon in einem anderen Package vor?
       throw new TypeinferenceException("Name " + className + " bereits vorhanden in " + reg.getName(className).toString(), ctx.getStart());
@@ -451,8 +452,8 @@ public class SyntaxTreeGenerator {
   protected static Block prepareBlock(Block constructorBlock, RefType superClass) {
     List<Statement> statements = constructorBlock.getStatements();
     if (statements.isEmpty() || !(statements.get(0) instanceof SuperCall || statements.get(0) instanceof ThisCall))  {
-      var signature = new ArrayList<TypePlaceholder>();
+      var signature = new ArrayList<RefTypeOrTPHOrWildcardOrGeneric>();
-      signature.add(TypePlaceholder.fresh(new NullToken()));
+      signature.add(new Void(new NullToken()));
       statements.add(0, new SuperCall(superClass, signature, constructorBlock.getOffset()));
     }
     /* statements.addAll(fieldInitializations); geloescht PL 2018-11-24 */

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

@@ -68,8 +68,6 @@ public class TypeGenerator {
                 return new RefType(ASTFactory.createClass(Integer.class).getClassName(), typeContext.getStart());
             case "double":
                 return new RefType(ASTFactory.createClass(Double.class).getClassName(), typeContext.getStart());
-            case "float":
-                return new RefType(ASTFactory.createClass(Float.class).getClassName(), typeContext.getStart());
             default:
                 throw new NotImplementedException();
             }

src/main/java/de/dhbwstuttgart/parser/scope/GatherNames.java

@@ -140,8 +140,7 @@ public class GatherNames {
 			if (importDeclCtx.MUL() == null) {
 				var name = importDeclCtx.qualifiedName().getText();
 				var className = new JavaClassName(name);
-				var clazz = compiler.loadJavaTXClass(className);
+				if (compiler.loadJavaTXClass(className)) {
-				if (clazz != null) {
 					ret.put(name, compiler.classRegistry.getNumberOfGenerics(name));
 				} else {
 					Class<?> cl = compiler.getClassLoader().loadClass(name);

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

@@ -236,11 +236,6 @@ public abstract class AbstractASTWalker implements ASTVisitor {
         aBreak.accept(this);
     }
 
-    @Override
-    public void visit(Continue aContinue) {
-        aContinue.accept(this);
-    }
-
     @Override
     public void visit(StaticClassName staticClassName) {
 
@@ -337,11 +332,4 @@ public abstract class AbstractASTWalker implements ASTVisitor {
     public void visit(GuardedPattern aGuardedPattern) {
 
     }
-
-    @Override
-    public void visit(Ternary ternary) {
-        ternary.cond.accept(this);
-        ternary.iftrue.accept(this);
-        ternary.iffalse.accept(this);
-    }
 }

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

@@ -9,7 +9,10 @@ import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import org.antlr.v4.runtime.Token;
 
 import java.lang.reflect.Modifier;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
 
 /**
  * Stellt jede Art von Klasse dar. Auch abstrakte Klassen und Interfaces
@@ -125,6 +128,7 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope {
   public List<Method> getMethods() {
     return this.methods;
   }
+
   /*
    * public RefType getType() { return generateTypeOfClass(this.getClassName(), this.getGenerics(), this.getOffset()); }
    */
@@ -185,15 +189,4 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope {
     return this.name.toString() + this.genericClassParameters.toString();
   }
 
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (!(o instanceof ClassOrInterface other)) return false;
-    return Objects.equals(name, other.name);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(name);
-  }
 }

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

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.syntaxtree;
 
 import java.util.ArrayList;
-import java.util.Objects;
 
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
@@ -33,7 +32,6 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 	private GenericDeclarationList generics;
 	private final RefTypeOrTPHOrWildcardOrGeneric returnType;
 	public final Boolean isInherited; 
-	public final Boolean isImplemented;
 	
 	/*
 	 * its Constraints
@@ -51,11 +49,10 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 		this.block = block;
 		this.generics = gtvDeclarations;
 		this.isInherited = false;
-		this.isImplemented = false;
 	}
 	
 	public Method(int modifier, String name, RefTypeOrTPHOrWildcardOrGeneric returnType, ParameterList parameterList, Block block,
-			  GenericDeclarationList gtvDeclarations, Token offset, Boolean isInherited, Boolean isOverridden) {
+			  GenericDeclarationList gtvDeclarations, Token offset, Boolean isInherited) {
 		super(offset);
 		this.name = name;
 		this.modifier = modifier;
@@ -64,7 +61,6 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 		this.block = block;
 		this.generics = gtvDeclarations;
 		this.isInherited = isInherited;
-		this.isImplemented = isOverridden;
 	}
 
 	public ParameterList getParameterList() {
@@ -97,23 +93,4 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 	public String getName() {
 		return name;
 	}
-
-	@Override
-	public boolean equals(Object o) {
-		if (this == o) return true;
-		if (o == null || getClass() != o.getClass()) return false;
-		Method method = (Method) o;
-		return Objects.equals(name, method.name) && Objects.equals(parameterlist, method.parameterlist) && Objects.equals(returnType, method.returnType);
-	}
-
-	@Override
-	public int hashCode() {
-		return Objects.hash(name, parameterlist, returnType);
-	}
-	
-	@Override
-	public String toString() {
-		return name;
-	
-	}
 }

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

@@ -15,8 +15,6 @@ public class SourceFile extends SyntaxTreeNode {
   public final List<ClassOrInterface> KlassenVektor;
   public final Set<JavaClassName> imports;
 
-  private boolean isGenerated;
-
   public List<ClassOrInterface> availableClasses = new ArrayList<>();
 
   /**
@@ -40,18 +38,6 @@ public class SourceFile extends SyntaxTreeNode {
     this.imports = new HashSet<>(sf.imports);
   }
 
-  public void setPackageName(String packageName) {
-    this.pkgName = packageName;
-  }
-
-  public void setGenerated() {
-    this.isGenerated = true;
-  }
-
-  public boolean isGenerated() {
-    return this.isGenerated;
-  }
-
   public String getPkgName() {
     return this.pkgName;
   }

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

@@ -53,8 +53,6 @@ public interface StatementVisitor {
 
     void visit(Break aBreak);
 
-    void visit(Continue aContinue);
-
     void visit(Yield aYield);
     
     void visit(StaticClassName staticClassName);
@@ -82,6 +80,4 @@ public interface StatementVisitor {
     void visit(Literal literal);
 
     void visit(Throw aThrow);
-
-    void visit(Ternary ternary);
 }

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);
 
@@ -106,46 +105,11 @@ public class ASTFactory {
 		allInheritedMethods.removeAll(allDeclaredMethods);
 		for (java.lang.reflect.Method method : allDeclaredMethods) {
 			var signature = methodSignatures.get(new Pair<>(method.getName(), org.objectweb.asm.Type.getMethodDescriptor(method)));
-			if (jreClass.getSuperclass()==null) {
+			methoden.add(createMethod(method, signature, jreClass, false));
-				methoden.add(createMethod(method, signature, jreClass, false, false));
+		}
-			}
-			else {
-				Boolean isImplemented = false;
-				isImplemented = Arrays.stream(jreClass.getInterfaces()).
-									   reduce(false, 
-											  (x,y) -> {
-												  try { 
-													  y.getDeclaredMethod(method.getName(), method.getParameterTypes());
-													  return true;
-												  }
-												  catch (java.lang.NoSuchMethodException e) {
-													  return false;
-												  }},
-											  (x,y) -> (x || y)
-											 );
-					
-			    if (isImplemented) {
-			    	methoden.add(createMethod(method, signature, jreClass, false, true));
-			    }
-			    else {
-			    	if (Modifier.isAbstract(jreClass.getSuperclass().getModifiers())) {	
-			    		try {
-			    			jreClass.getSuperclass().getDeclaredMethod(method.getName(), method.getParameterTypes());
-			    			methoden.add(createMethod(method, signature, jreClass, false, true));
-			    		}
-			    		catch (java.lang.NoSuchMethodException e) { 
-								methoden.add(createMethod(method, signature, jreClass, false, false));	
-			    		}
-			    	}
-			    	else {
-			    		methoden.add(createMethod(method, signature, jreClass, false, false));
-			    	}
-			    	
-			    }
-		}}
 		for (java.lang.reflect.Method method : allInheritedMethods) {
 			var signature = methodSignatures.get(new Pair<>(method.getName(), org.objectweb.asm.Type.getMethodDescriptor(method)));
-			methoden.add(createMethod(method, signature, jreClass, true, false));
+			methoden.add(createMethod(method, signature, jreClass, true));
 		}
 		List<Field> felder = new ArrayList<>();
 		for (java.lang.reflect.Field field : jreClass.getDeclaredFields()) {
@@ -174,7 +138,6 @@ 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));
 		}
@@ -229,7 +192,7 @@ public class ASTFactory {
 		return Optional.of(new de.dhbwstuttgart.syntaxtree.Constructor(modifier, name, returnType, parameterList, block, gtvDeclarations, offset /* , new ArrayList<>() geloescht PL 2018-11-24 */));
 	}
 
-	public static Method createMethod(java.lang.reflect.Method jreMethod, String signature, java.lang.Class inClass, Boolean isInherited, Boolean isImplemented) {
+	public static Method createMethod(java.lang.reflect.Method jreMethod, String signature, java.lang.Class inClass, Boolean isInherited) {
 		String name = jreMethod.getName();
 		RefTypeOrTPHOrWildcardOrGeneric returnType;
 		Type jreRetType;
@@ -255,7 +218,7 @@ public class ASTFactory {
 		GenericDeclarationList gtvDeclarations = createGenerics(jreMethod.getTypeParameters(), inClass, jreMethod.getName(), signature);
 		Token offset = new NullToken();
 
-		return new Method(jreMethod.getModifiers(), name, returnType, parameterList, block, gtvDeclarations, offset, isInherited, isImplemented);
+		return new Method(jreMethod.getModifiers(), name, returnType, parameterList, block, gtvDeclarations, offset, isInherited);
 	}
 
 	public static GenericDeclarationList createGenerics(TypeVariable[] typeParameters, Class context, String methodName, String signature) {
@@ -405,8 +368,6 @@ public class ASTFactory {
 			return new RefType(new JavaClassName("java.lang.Character"), new ArrayList<>(), new NullToken(), true);
 		} else if (type.getTypeName().equals("short")) {
 			return new RefType(new JavaClassName("java.lang.Short"), new ArrayList<>(), new NullToken(), true);
-		} else if (type.getTypeName().equals("float")) {
-			return new RefType(new JavaClassName("java.lang.Float"), new ArrayList<>(), new NullToken(), true);
 		} else if (type.getTypeName().equals("double")) {
 			return new RefType(new JavaClassName("java.lang.Double"), new ArrayList<>(), new NullToken(), true);
 		} else if (type.getTypeName().equals("long")) {

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

@@ -1,21 +1,17 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
 import java.io.Writer;
-import java.lang.reflect.Modifier;
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
 
-import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SourceLoc;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.syntaxtree.type.WildcardType;
@@ -33,7 +29,7 @@ public class UnifyTypeFactory {
 	
 	private static ArrayList<PlaceholderType> PLACEHOLDERS = new ArrayList<>(); 
 
-    public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses, Writer logFile, ClassLoader classLoader, JavaTXCompiler compiler) throws ClassNotFoundException {
+    public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses, Writer logFile, ClassLoader classLoader) throws ClassNotFoundException {
         /*
         Die transitive Hülle muss funktionieren.
         Man darf schreiben List<A> extends AL<A>
@@ -44,7 +40,7 @@ public class UnifyTypeFactory {
         Generell dürfen sie immer die gleichen Namen haben.
         TODO: die transitive Hülle bilden
          */
-        return new FiniteClosure(FCGenerator.toUnifyFC(compiler, fromClasses, classLoader), logFile, compiler);
+        return new FiniteClosure(FCGenerator.toUnifyFC(fromClasses, classLoader), logFile);
     }
 
     public static UnifyPair generateSmallerPair(UnifyType tl, UnifyType tr, SourceLoc location){
@@ -67,23 +63,23 @@ public class UnifyTypeFactory {
      * Convert from
      * ASTType -> UnifyType
      */
-    public static UnifyType convert(JavaTXCompiler compiler, RefTypeOrTPHOrWildcardOrGeneric t, Boolean innerType){
+    public static UnifyType convert(RefTypeOrTPHOrWildcardOrGeneric t, Boolean innerType){
-        if (t instanceof GenericRefType){
+        if(t instanceof GenericRefType){
-            return UnifyTypeFactory.convert(compiler, (GenericRefType)t, innerType);
+            return UnifyTypeFactory.convert((GenericRefType)t, innerType);
-        } else if (t instanceof TypePlaceholder){
+        }else if(t instanceof TypePlaceholder){
-            return UnifyTypeFactory.convert(compiler, (TypePlaceholder)t, innerType);
+            return UnifyTypeFactory.convert((TypePlaceholder)t, innerType);
-        } else if (t instanceof ExtendsWildcardType){
+        }else if(t instanceof ExtendsWildcardType){
-            return UnifyTypeFactory.convert(compiler, (ExtendsWildcardType)t, innerType);
+            return UnifyTypeFactory.convert((ExtendsWildcardType)t, innerType);
-        } else if (t instanceof SuperWildcardType) {
+        }else if(t instanceof SuperWildcardType){
-            return UnifyTypeFactory.convert(compiler, (SuperWildcardType) t, innerType);
+            return UnifyTypeFactory.convert((SuperWildcardType)t, innerType);
-        } else if (t instanceof RefType){
+        }else if(t instanceof RefType){
-            return UnifyTypeFactory.convert(compiler, (RefType)t, innerType);
+            return UnifyTypeFactory.convert((RefType)t, innerType);
         }
         //Es wurde versucht ein Typ umzuwandeln, welcher noch nicht von der Factory abgedeckt ist
         throw new NotImplementedException("Der Typ "+t+" kann nicht umgewandelt werden");
     }
 
-    public static UnifyType convert(JavaTXCompiler compiler, RefType t, Boolean innerType){
+    public static UnifyType convert(RefType t, Boolean innerType){
         //Check if it is a FunN Type:
         Pattern p = Pattern.compile("Fun(\\d+)[$][$]");
         Matcher m = p.matcher(t.getName().toString());
@@ -91,41 +87,35 @@ public class UnifyTypeFactory {
         if(b){
             Integer N = Integer.valueOf(m.group(1));
             if((N + 1) == t.getParaList().size()){
-                return convertFunN(compiler, t.getParaList(), false);
+                return convertFunN(t.getParaList(), false);
             }
         }
         UnifyType ret;
-        List<UnifyType> params = new ArrayList<>();
+        if(t.getParaList() != null && t.getParaList().size() > 0){
-        if (t.getParaList() != null) {
+            List<UnifyType> params = new ArrayList<>();
-            for (RefTypeOrTPHOrWildcardOrGeneric pT : t.getParaList()) {
+            for(RefTypeOrTPHOrWildcardOrGeneric pT : t.getParaList()){
-                params.add(UnifyTypeFactory.convert(compiler, pT, true));
+                params.add(UnifyTypeFactory.convert(pT, true));
             }
+            ret = new ReferenceType(t.getName().toString(),new TypeParams(params));
+        }else{
+            ret = new ReferenceType(t.getName().toString(), false);
         }
-
+        return ret;
-        var clazz = compiler.getClass(t.getName());
-        if (clazz != null && clazz.isInterface() && clazz.isFunctionalInterface()) {
-            var method = clazz.getMethods().stream().filter(x -> Modifier.isAbstract(x.modifier)).findFirst().orElseThrow();
-            var methodParams = method.getParameterList().getFormalparalist().stream().map(x -> convert(compiler, x.getType(), true)).toList();
-            var generics = StreamSupport.stream(clazz.getGenerics().spliterator(), false).map(GenericTypeVar::getName).toList();
-            return new FunInterfaceType(t.getName().toString(), new TypeParams(params), methodParams, convert(compiler, method.getReturnType(), true), generics);
-        }
-
-        return new ReferenceType(t.getName().toString(),new TypeParams(params));
     }
 
-    public static UnifyType convertFunN(JavaTXCompiler compiler, List<RefTypeOrTPHOrWildcardOrGeneric> paraList, Boolean innerType){
+    public static UnifyType convertFunN(List<RefTypeOrTPHOrWildcardOrGeneric> paraList, Boolean innerType){
         UnifyType ret;
         List<UnifyType> params = new ArrayList<>();
         if(paraList != null && paraList.size() > 0){
             for(RefTypeOrTPHOrWildcardOrGeneric pT : paraList){
-                params.add(UnifyTypeFactory.convert(compiler, pT, false));
+                params.add(UnifyTypeFactory.convert(pT, false));
             }
         }
         ret = FunNType.getFunNType(new TypeParams(params));
         return ret;
     }
 
-    public static UnifyType convert(JavaTXCompiler compiler, TypePlaceholder tph, Boolean innerType){
+    public static UnifyType convert(TypePlaceholder tph, Boolean innerType){
     	if (tph.getName().equals("AFR")) {
     		System.out.println("XXX"+innerType);
     	}
@@ -145,21 +135,21 @@ public class UnifyTypeFactory {
 		}
     }
 
-    public static UnifyType convert(JavaTXCompiler compiler, GenericRefType t, Boolean innerType){
+    public static UnifyType convert(GenericRefType t, Boolean innerType){
         return new ReferenceType(t.getParsedName(), true);
     }
 
-    public static UnifyType convert(JavaTXCompiler compiler, WildcardType t, Boolean innerType){
+    public static UnifyType convert(WildcardType t, Boolean innerType){
         if(t.isExtends())
-            return new ExtendsType(UnifyTypeFactory.convert(compiler, t.getInnerType(), false));
+            return new ExtendsType(UnifyTypeFactory.convert(t.getInnerType(), false));
         else if(t.isSuper())
-            return new SuperType(UnifyTypeFactory.convert(compiler, t.getInnerType(), false));
+            return new SuperType(UnifyTypeFactory.convert(t.getInnerType(), false));
         else throw new NotImplementedException();
     }
 
 
-    public static ConstraintSet<UnifyPair> convert(JavaTXCompiler compiler, ConstraintSet<Pair> constraints) {
+    public static ConstraintSet<UnifyPair> convert(ConstraintSet<Pair> constraints) {
-        return constraints.map(c -> UnifyTypeFactory.convert(compiler, c));
+        return constraints.map(UnifyTypeFactory::convert);
     }
 
     //NEVER USED
@@ -170,23 +160,23 @@ public class UnifyTypeFactory {
     //	return unifyPairConstraint;
     //}
 
-    public static UnifyPair convert(JavaTXCompiler compiler, Pair p) {
+    public static UnifyPair convert(Pair p) {
     	UnifyPair ret = null;
         if(p.GetOperator().equals(PairOperator.SMALLERDOT)) {
-             ret = generateSmallerDotPair(UnifyTypeFactory.convert(compiler, p.TA1, false)
+             ret = generateSmallerDotPair(UnifyTypeFactory.convert(p.TA1, false)
-                    , UnifyTypeFactory.convert(compiler, p.TA2, false), p.getLocation());
+                    , UnifyTypeFactory.convert(p.TA2, false), p.getLocation());
             //return ret;
         }else if(p.GetOperator().equals(PairOperator.SMALLERNEQDOT)) {
-             ret = generateSmallNotEqualDotPair(UnifyTypeFactory.convert(compiler, p.TA1, false)
+             ret = generateSmallNotEqualDotPair(UnifyTypeFactory.convert(p.TA1, false)
-                    , UnifyTypeFactory.convert(compiler, p.TA2, false), p.getLocation());
+                    , UnifyTypeFactory.convert(p.TA2, false), p.getLocation());
             //return ret;
         }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)) {
-             ret = generateEqualDotPair(UnifyTypeFactory.convert(compiler, p.TA1, false)
+             ret = generateEqualDotPair(UnifyTypeFactory.convert(p.TA1, false)
-                    , UnifyTypeFactory.convert(compiler, p.TA2, false), p.getLocation());
+                    , UnifyTypeFactory.convert(p.TA2, false), p.getLocation());
             //return ret;
         }else if(p.GetOperator().equals(PairOperator.SMALLER)){
-            ret =  generateSmallerPair(UnifyTypeFactory.convert(compiler, p.TA1, false),
+            ret =  generateSmallerPair(UnifyTypeFactory.convert(p.TA1, false),
-                    UnifyTypeFactory.convert(compiler, p.TA2, false), p.getLocation());
+                    UnifyTypeFactory.convert(p.TA2, false), p.getLocation());
         }else            throw new NotImplementedException();
         UnifyType lhs, rhs;
         if (((lhs = ret.getLhsType()) instanceof PlaceholderType) 

src/main/java/de/dhbwstuttgart/syntaxtree/statement/BinaryExpr.java

@@ -17,7 +17,6 @@ public class BinaryExpr extends Expression {
         MOD, // Modulo Operator %
         AND, // &
         OR, // |
-        XOR, // ^
         DIV, // /
         LESSTHAN, // <
         BIGGERTHAN, // >

src/main/java/de/dhbwstuttgart/syntaxtree/statement/Continue.java

@@ -1,18 +0,0 @@
-package de.dhbwstuttgart.syntaxtree.statement;
-
-import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import org.antlr.v4.runtime.Token;
-
-public class Continue extends Statement {
-
-  public Continue(RefTypeOrTPHOrWildcardOrGeneric type, Token offset) {
-    super(type, offset);
-  }
-
-  @Override
-  public void accept(StatementVisitor visitor) {
-    visitor.visit(this);
-  }
-
-}

src/main/java/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java

@@ -27,10 +27,10 @@ public class MethodCall extends Statement
     public RefTypeOrTPHOrWildcardOrGeneric receiverType;
     
     //sind Tphs, repraesentieren im Resultset die Signatur der aufgerufenen Methoden, letztes Element ist der Returntyp
-    public final ArrayList<TypePlaceholder> signature;  
+    public final ArrayList<RefTypeOrTPHOrWildcardOrGeneric> signature;  
     
     public MethodCall(RefTypeOrTPHOrWildcardOrGeneric retType, Receiver receiver, String methodName, ArgumentList argumentList, 
-    		          RefTypeOrTPHOrWildcardOrGeneric receiverType, ArrayList<TypePlaceholder> signature, Token offset){
+    		          RefTypeOrTPHOrWildcardOrGeneric receiverType, ArrayList<RefTypeOrTPHOrWildcardOrGeneric> signature, Token offset){
 		super(retType,offset);
 		this.arglist = argumentList;
         this.name = methodName;
@@ -40,7 +40,7 @@ public class MethodCall extends Statement
         if (signature == null) throw new NullPointerException();
 	}
 
-    public List<TypePlaceholder> signatureArguments() {
+    public List<RefTypeOrTPHOrWildcardOrGeneric> signatureArguments() {
         return signature.subList(0, signature.size() - 1);
     }
 

src/main/java/de/dhbwstuttgart/syntaxtree/statement/NewClass.java

@@ -11,7 +11,6 @@ import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
@@ -31,9 +30,9 @@ public class NewClass extends MethodCall
      * @param start
      */
     public NewClass(RefType newClass, ArgumentList args, RefTypeOrTPHOrWildcardOrGeneric receiverType, 
-    		ArrayList<TypePlaceholder> signature, Token start) {
+    		ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes, Token start) {
         super(newClass, new ExpressionReceiver(new EmptyStmt(start)), newClass.getName().toString(), 
-        		args, receiverType, signature, start);
+        		args, receiverType, argTypes, start);
     }
 
     @Override

src/main/java/de/dhbwstuttgart/syntaxtree/statement/Super.java

@@ -3,7 +3,6 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
@@ -11,12 +10,8 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 
-public class Super extends Expression {
+public class Super extends Expression
-
+{
-    public Super(Token offset) {
-        super(TypePlaceholder.fresh(offset), offset);
-    }
-
     public Super(RefTypeOrTPHOrWildcardOrGeneric type, Token offset)
     {
         super(type, offset);

src/main/java/de/dhbwstuttgart/syntaxtree/statement/SuperCall.java

@@ -4,7 +4,6 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import org.antlr.v4.runtime.Token;
 
@@ -17,12 +16,12 @@ import java.util.List;
 public class SuperCall extends MethodCall
 {
     public SuperCall(RefTypeOrTPHOrWildcardOrGeneric receiverType, 
-    		ArrayList<TypePlaceholder> argTypes, Token offset){
+    		ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes, Token offset){
         this(new ArgumentList(new ArrayList<Expression>(), offset), receiverType, argTypes, offset);
     }
 
     public SuperCall(ArgumentList argumentList, RefTypeOrTPHOrWildcardOrGeneric receiverType, 
-    		ArrayList<TypePlaceholder> argTypes, Token offset){
+    		ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes, Token offset){
         super(new Void(offset), new ExpressionReceiver(new Super(receiverType, offset)), "<init>", argumentList, receiverType, argTypes, offset);
     }
 

src/main/java/de/dhbwstuttgart/syntaxtree/statement/Ternary.java

@@ -1,24 +0,0 @@
-package de.dhbwstuttgart.syntaxtree.statement;
-
-import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import org.antlr.v4.runtime.Token;
-
-public class Ternary extends Expression {
-
-    public final Expression cond;
-    public final Expression iftrue;
-    public final Expression iffalse;
-
-    public Ternary(RefTypeOrTPHOrWildcardOrGeneric type, Expression cond, Expression iftrue, Expression iffalse, Token offset) {
-        super(type, offset);
-        this.cond = cond;
-        this.iftrue = iftrue;
-        this.iffalse = iffalse;
-    }
-
-    @Override
-    public void accept(StatementVisitor visitor) {
-        visitor.visit(this);
-    }
-}

src/main/java/de/dhbwstuttgart/syntaxtree/statement/This.java

@@ -8,8 +8,9 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
 
 public class This extends Expression
 {
-    public This(Token offset) {
+    public This(Token offset)
-        super(TypePlaceholder.fresh(offset), offset);
+    {
+        super(TypePlaceholder.fresh(offset),offset);
     }
     
     public ArgumentList arglist;

src/main/java/de/dhbwstuttgart/syntaxtree/statement/ThisCall.java

@@ -3,7 +3,6 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import de.dhbwstuttgart.syntaxtree.Constructor;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import org.antlr.v4.runtime.Token;
 
@@ -12,7 +11,7 @@ import java.util.ArrayList;
 
 public class ThisCall extends MethodCall
 {
-    public ThisCall(ArgumentList argumentList, RefTypeOrTPHOrWildcardOrGeneric receiverType, ArrayList<TypePlaceholder> argTypes, Token offset) {
+    public ThisCall(ArgumentList argumentList, RefTypeOrTPHOrWildcardOrGeneric receiverType, ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes, Token offset) {
         super(new Void(offset), new ExpressionReceiver(new This(offset)), "<init>", argumentList, receiverType, argTypes, offset);
     }
 

src/main/java/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java

@@ -333,11 +333,6 @@ public class OutputGenerator implements ASTVisitor {
         out.append("break");
     }
 
-    @Override
-    public void visit(Continue aContinue) {
-        out.append("continue");
-    }
-
     @Override
     public void visit(StaticClassName staticClassName) {
 
@@ -385,7 +380,6 @@ public class OutputGenerator implements ASTVisitor {
         out.append("super(");
         superCall.arglist.accept(this);
         out.append(")");
-        out.append(" Signature: " + superCall.signature);
     }
 
     @Override
@@ -393,7 +387,6 @@ public class OutputGenerator implements ASTVisitor {
         out.append("this(");
         thisCall.arglist.accept(this);
         out.append(")");
-        out.append(" Signature: " + thisCall.signature);
     }
 
     @Override
@@ -434,18 +427,6 @@ public class OutputGenerator implements ASTVisitor {
         // TODO implement
     }
 
-    @Override
-    public void visit(Ternary ternary) {
-        out.append("(");
-        ternary.cond.accept(this);
-        out.append(" ? ");
-        ternary.iftrue.accept(this);
-        out.append(" : ");
-        ternary.iffalse.accept(this);
-        out.append(")::");
-        ternary.getType().accept(this);
-    }
-
     @Override
     public void visit(Switch switchStmt) {
         out.append("switch(");

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

@@ -1,12 +1,11 @@
 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.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.Record;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
@@ -17,6 +16,8 @@ import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
 import de.dhbwstuttgart.typeinference.result.*;
 
+import javax.sql.rowset.RowSetWarning;
+import java.lang.annotation.Target;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -26,19 +27,16 @@ import java.util.stream.Stream;
  */
 public class ASTToTargetAST {
 
-    record SignaturePair(TypePlaceholder signature, RefTypeOrTPHOrWildcardOrGeneric parameter) {};
-    record SignaturePairTarget(TargetType signature, TargetType parameter) {}
-
     public static RefType OBJECT = ASTFactory.createObjectType(); // TODO It would be better if I could call this directly but the hashcode seems to change
 
     protected List<Generics> all;
-    public Generics generics;
+    protected Generics generics;
     final Map<ClassOrInterface, Set<GenericTypeVar>> userDefinedGenerics = new HashMap<>();
-    final Map<Method, Set<SignaturePair>> tphsInMethods = new HashMap<>();
-    private Method currentMethod;
 
     public final JavaTXCompiler compiler;
 
+    protected ClassOrInterface currentClass; // TODO This is only needed because of SuperCall, maybe there's
+
     public List<GenericsResult> txGenerics() {
         return all.stream().map(generics -> new GenericsResult(generics.txGenerics)).toList();
     }
@@ -53,11 +51,11 @@ public class ASTToTargetAST {
         return converter.result;
     }
 
-    public record Generics(JavaGenerics javaGenerics, TxGenerics txGenerics) {
+    record Generics(JavaGenerics javaGenerics, TxGenerics txGenerics) {
     }
 
 
-    public IByteArrayClassLoader classLoader;
+    protected IByteArrayClassLoader classLoader;
     protected SourceFile sourceFile;
 
     public ASTToTargetAST(List<ResultSet> resultSets) {
@@ -79,26 +77,15 @@ public class ASTToTargetAST {
         this.generics = all.get(0);
     }
 
-    public void addSignaturePair(TypePlaceholder signature, RefTypeOrTPHOrWildcardOrGeneric parameter) {
-        var set = tphsInMethods.getOrDefault(currentMethod, new HashSet<>());
-        set.add(new SignaturePair(signature, parameter));
-        tphsInMethods.put(currentMethod, set);
-    }
-
     Optional<Method> findMethod(ClassOrInterface owner, String name, List<TargetType> argumentList) {
         Optional<Method> method = Optional.empty();
-        while (method.isEmpty()) {
+        while (method.isEmpty() && !owner.getClassName().toString().equals("java.lang.Object")) {
             method = owner.getMethods().stream().filter(m -> m.name.equals(name) && parameterEquals(m.getParameterList(), argumentList)).findFirst();
-            if (owner.getClassName().toString().equals("java.lang.Object")) break;
             owner = compiler.getClass(owner.getSuperClass().getName());
         }
         return method;
     }
 
-    Optional<Constructor> findConstructor(ClassOrInterface owner, List<TargetType> argumentList) {
-        return owner.getConstructors().stream().filter(c -> parameterEquals(c.getParameterList(), argumentList)).findFirst();
-    }
-
     boolean parameterEquals(ParameterList parameterList, List<TargetType> arguments) {
         var pars = parameterList.getFormalparalist();
         if (pars.size() != arguments.size())
@@ -138,41 +125,8 @@ public class ASTToTargetAST {
         return ret;
     }
 
-    public List<List<TargetMethod>> groupOverloads(ClassOrInterface input, List<Method> methods) {
-        var res = new ArrayList<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<TargetMethod>();
-            for (var methodsWithSignature : mapOfSignatures.values()) {
-                outer: for (var m1 : methodsWithSignature) {
-                    for (var m2 : methodsWithSignature) {
-                        for (var i = 0; i < m1.args.size(); i++) {
-                            var arg1 = m1.args.get(i);
-                            var arg2 = m2.args.get(i);
-                            if (arg1.parameter.equals(arg2.parameter)) {
-                                if (isSupertype(arg1.signature, arg2.signature) &&
-                                    !arg1.signature.equals(arg2.signature)) continue outer;
-                            }
-                        }
-                    }
-                    resMethods.add(m1.method);
-                }
-            }
-            res.add(resMethods.stream().toList());
-        }
-        return res;
-    }
-
     public TargetStructure convert(ClassOrInterface input) {
+        currentClass = input;
         Set<TargetGeneric> javaGenerics = new HashSet<>();
         Set<TargetGeneric> txGenerics = new HashSet<>();
 
@@ -200,13 +154,13 @@ public class ASTToTargetAST {
         TargetBlock finalFieldInitializer = fieldInitializer;
 
         var superInterfaces = input.getSuperInterfaces().stream().map(clazz -> convert(clazz, generics.javaGenerics)).toList();
-        var constructors = input.getConstructors().stream().map(constructor -> this.convert(input, constructor, finalFieldInitializer)).flatMap(List::stream).toList();
+        var constructors = input.getConstructors().stream().map(constructor -> this.convert(constructor, finalFieldInitializer)).flatMap(List::stream).toList();
         var fields = input.getFieldDecl().stream().map(this::convert).toList();
-        var methods = groupOverloads(input, input.getMethods()).stream().flatMap(List::stream).toList();
+        var methods = groupOverloads(input.getMethods()).stream().map(this::convert).flatMap(List::stream).toList();
 
         TargetMethod staticConstructor = null;
         if (input.getStaticInitializer().isPresent())
-            staticConstructor = this.convert(input, input.getStaticInitializer().get()).stream().findFirst().orElseThrow().method;
+            staticConstructor = this.convert(input.getStaticInitializer().get()).get(0);
 
         if (input instanceof Record)
             return new TargetRecord(input.getModifiers(), input.getClassName(), javaGenerics, txGenerics, superInterfaces, constructors, staticConstructor, fields, methods);
@@ -215,7 +169,7 @@ public class ASTToTargetAST {
         else return new TargetClass(input.getModifiers(), input.getClassName(), convert(input.getSuperClass(), generics.javaGenerics), javaGenerics, txGenerics, superInterfaces, constructors, staticConstructor, fields, methods);
     }
 
-    public List<MethodParameter> convert(ParameterList input, GenerateGenerics generics) {
+    private List<MethodParameter> convert(ParameterList input, GenerateGenerics generics) {
         return input.getFormalparalist().stream().map(param ->
             new MethodParameter((TargetPattern) convert(param))
         ).toList();
@@ -225,10 +179,10 @@ public class ASTToTargetAST {
         return generics.stream().anyMatch(g -> g.name().equals(type.getParsedName()));
     }
 
-    private Set<TargetGeneric> collectMethodGenerics(ClassOrInterface clazz, GenerateGenerics generateGenerics, Set<GenerateGenerics.Pair> generics, Method input) {
+    private Set<TargetGeneric> collectMethodGenerics(GenerateGenerics generateGenerics, Set<GenerateGenerics.Pair> generics, Method input) {
         var convertedGenerics = new HashSet<>(convert(generics, generateGenerics));
         outer: for (GenericTypeVar typeVar : input.getGenerics()) {
-            for (var classGeneric : clazz.getGenerics()) {
+            for (var classGeneric : currentClass.getGenerics()) {
                 if (classGeneric.equals(typeVar)) {
                     continue outer;
                 }
@@ -243,11 +197,10 @@ public class ASTToTargetAST {
         return convertedGenerics;
     }
 
-    private List<TargetConstructor> convert(ClassOrInterface currentClass, Constructor input, TargetBlock fieldInitializer) {
+    private List<TargetConstructor> convert(Constructor input, TargetBlock fieldInitializer) {
         generics = all.get(0);
         List<TargetConstructor> result = new ArrayList<>();
         Set<List<MethodParameter>> parameterSet = new HashSet<>();
-        this.currentMethod = input;
 
         for (var s : all) {
             generics = s;
@@ -256,8 +209,8 @@ public class ASTToTargetAST {
             List<MethodParameter> params = convert(input.getParameterList(), this.generics.javaGenerics);
             if (parameterSet.stream().noneMatch(p -> p.equals(params))) {
                 List<MethodParameter> txParams = convert(input.getParameterList(), this.generics.txGenerics);
-                var javaMethodGenerics = collectMethodGenerics(currentClass, generics.javaGenerics(), javaGenerics, input);
+                var javaMethodGenerics = collectMethodGenerics(generics.javaGenerics(), javaGenerics, input);
-                var txMethodGenerics = collectMethodGenerics(currentClass, generics.txGenerics(), txGenerics, input);
+                var txMethodGenerics = collectMethodGenerics(generics.txGenerics(), txGenerics, input);
 
                 result.add(new TargetConstructor(input.modifier, javaMethodGenerics, txMethodGenerics, params, txParams, convert(input.block), fieldInitializer));
                 parameterSet.add(params);
@@ -267,6 +220,56 @@ public class ASTToTargetAST {
         return result;
     }
 
+    /**
+     * This only considers type patterns, all other methods aren't grouped together
+     * @param a
+     * @param b
+     * @return
+     */
+    private boolean signatureEquals(Method a, Method b) {
+        if (!a.name.equals(b.name)) return false;
+        var para = a.getParameterList().getFormalparalist();
+        var parb = b.getParameterList().getFormalparalist();
+        if (para.size() != parb.size()) return false;
+
+        for (var i = 0; i < para.size(); i++) {
+            var pa = para.get(i);
+            var pb = parb.get(i);
+
+            if (pa instanceof RecordPattern rpa) {
+                if (pb instanceof RecordPattern rpb) {
+                    if (rpa.getType().equals(rpb.getType())) continue;
+                }
+                return false;
+            } else if (pa.getType().equals(pb.getType())) {
+                continue;
+            }
+            return false;
+        }
+
+        return true;
+    }
+
+    // TODO Nested patterns
+    private List<List<Method>> groupOverloads(List<Method> input) {
+        var done = new HashSet<Method>();
+        var res = new ArrayList<List<Method>>();
+        for (var method : input) {
+            if (done.contains(method)) continue;
+            var overloads = new ArrayList<Method>();
+            overloads.add(method);
+            done.add(method);
+            for (var method2 : input) {
+                if (!done.contains(method2) && signatureEquals(method, method2)) {
+                    done.add(method2);
+                    overloads.add(method2);
+                }
+            }
+            res.add(overloads);
+        }
+        return res;
+    }
+
     private String encodeName(String name, ParameterList params) {
         var res = new StringBuilder();
         res.append(name);
@@ -282,11 +285,11 @@ public class ASTToTargetAST {
         return res.toString();
     }
 
-    private List<TargetMethod> convert(ClassOrInterface clazz, List<Method> overloadedMethods) {
+    private List<TargetMethod> convert(List<Method> overloadedMethods) {
         if (overloadedMethods.size() == 1) {
-            return convert(clazz, overloadedMethods.getFirst()).stream().map(m -> m.method()).toList();
+            return convert(overloadedMethods.get(0));
         }
-        var methods = new ArrayList<Method>();
+        var res = new ArrayList<Method>();
         for (var method : overloadedMethods) {
             var newMethod = new Method(
                     method.modifier,
@@ -298,7 +301,7 @@ public class ASTToTargetAST {
                     method.getGenerics(),
                     method.getOffset()
             );
-            methods.add(newMethod);
+            res.add(newMethod);
         }
 
         // TODO Record overloading
@@ -321,16 +324,7 @@ public class ASTToTargetAST {
         var entryPoint = new Method(template.modifier, template.name, template.getReturnType(), params, block, template.getGenerics(), new NullToken());
 
         res.add(entryPoint); // TODO*/
-        var res = new ArrayList<TargetMethod>();
+        return res.stream().map(this::convert).flatMap(List::stream).toList();
-        for (var method : methods) {
-            var overloads = convert(clazz, method);
-            for (var m : overloads) {
-                var overload = m.method;
-                if (res.contains(overload)) throw new CodeGenException("Duplicate method found: " + overload.name() + " with signature " + overload.signature().getSignature());
-                res.add(overload);
-            }
-        }
-        return res;
     }
 
     private Expression makeRecordSwitch(RefTypeOrTPHOrWildcardOrGeneric returnType, ParameterList params, List<Method> overloadedMethods) {
@@ -354,75 +348,31 @@ public class ASTToTargetAST {
         return swtch;
     }
 
-    private Optional<Method> findSuperMethodToOverride(ClassOrInterface currentClass, String name, List<MethodParameter> params) {
+    private List<TargetMethod> convert(Method method) {
-        var superClass = compiler.getClass(currentClass.getSuperClass().getName());
+        generics = all.get(0);
-        var methodStream = superClass.getMethods().stream();
+        List<TargetMethod> result = new ArrayList<>();
-        for (var superInterface : currentClass.getSuperInterfaces()) {
+        Set<List<MethodParameter>> parameterSet = new HashSet<>();
-            methodStream = Stream.concat(methodStream, compiler.getClass(superInterface.getName()).getMethods().stream());
-        }
-
-        return methodStream.filter(m -> {
-            if (!m.name.equals(name)) return false;
-            var sParams = m.getParameterList();
-            if (sParams.getFormalparalist().size() != params.size()) return false;
-            for (var i = 0; i < params.size(); i++) {
-                var a = TargetType.toPrimitive(params.get(i).pattern().type());
-                var b = convert(sParams.getFormalparalist().get(i).getType());
-                if (!Objects.equals(a, b)) return false;
-            }
-            return true;
-        }).findFirst();
-    }
-
-    record MethodWithTphs(TargetMethod method, List<SignaturePairTarget> args) {}
-
-    private List<MethodWithTphs> convert(ClassOrInterface currentClass, Method method) {
-        generics = all.getFirst();
-        List<MethodWithTphs> result = new ArrayList<>();
-        this.currentMethod = method;
 
         for (var s : all) {
             generics = s;
             var javaGenerics = this.generics.javaGenerics.generics(currentClass, method);
             var txGenerics = this.generics.txGenerics.generics(currentClass, method);
             List<MethodParameter> params = convert(method.getParameterList(), this.generics.javaGenerics);
-            var returnType = convert(method.getReturnType(), this.generics.javaGenerics);
+            if (parameterSet.stream().noneMatch(p -> p.equals(params))) {
-            var superMethod = findSuperMethodToOverride(currentClass, method.getName(), params);
+                List<MethodParameter> txParams = convert(method.getParameterList(), this.generics.txGenerics);
-            if (superMethod.isPresent()) {
+
-                // If we find a super method to override, use its parameters and return types
+                var javaMethodGenerics = collectMethodGenerics(generics.javaGenerics(), javaGenerics, method);
-                var newReturnType = convert(superMethod.get().getReturnType(), this.generics.javaGenerics);
+                var txMethodGenerics = collectMethodGenerics(generics.txGenerics(), txGenerics, method);
-                if (newReturnType instanceof TargetPrimitiveType && TargetType.toPrimitive(returnType).equals(newReturnType)) {
+
-                    returnType = newReturnType;
+                var javaSignature = new TargetMethod.Signature(javaMethodGenerics, params, convert(method.getReturnType(), this.generics.javaGenerics));
-                    params = convert(superMethod.get().getParameterList(), method.getParameterList(), this.generics.javaGenerics);
+                var txSignature = new TargetMethod.Signature(txMethodGenerics, txParams, convert(method.getReturnType(), this.generics.txGenerics));
-                }
+                result.add(new TargetMethod(method.modifier, method.name, convert(method.block), javaSignature, txSignature));
+                parameterSet.add(params);
             }
-
-            List<MethodParameter> txParams = convert(method.getParameterList(), this.generics.txGenerics);
-
-            var javaMethodGenerics = collectMethodGenerics(currentClass, generics.javaGenerics(), javaGenerics, method);
-            var txMethodGenerics = collectMethodGenerics(currentClass, generics.txGenerics(), txGenerics, method);
-
-            var javaSignature = new TargetMethod.Signature(javaMethodGenerics, params, returnType);
-            var txSignature = new TargetMethod.Signature(txMethodGenerics, txParams, convert(method.getReturnType(), this.generics.txGenerics));
-            var newMethod = new TargetMethod(method.modifier, method.name, convert(method.block), javaSignature, txSignature);
-
-            var concreteParams = tphsInMethods.getOrDefault(method, new HashSet<>()).stream().map(sig -> new SignaturePairTarget(convert(sig.signature), convert(sig.parameter))).toList();
-
-            result.add(new MethodWithTphs(newMethod, concreteParams));
         }
-
         return result;
     }
 
-    private List<MethodParameter> convert(ParameterList superList, ParameterList paraList, JavaGenerics generics) {
-        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)));
-        }
-        return list;
-    }
-
     protected TargetSwitch.Case convert(SwitchBlock block) {
         return new TargetSwitch.Case(block.getLabels().stream().map(this::convert).toList(), convert((Block) block), block.isExpression);
     }
@@ -454,7 +404,7 @@ public class ASTToTargetAST {
 
     public Map<String, byte[]> auxiliaries = new HashMap<>();
 
-    public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input) {
+    protected TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input) {
         return convert(input, generics.javaGenerics);
     }
 
@@ -480,59 +430,10 @@ public class ASTToTargetAST {
         }
         var filteredParams = new ArrayList<TargetType>();
         for (var i = 0; i < newParams.size(); i++) {
-            if (i < gep.inParams.size() && gep.inParams.get(i) != null)
+            if (gep.parameters.get(i) != null)
                 filteredParams.add(newParams.get(i));
         }
-        return TargetFunNType.fromParams(params, filteredParams, gep.getReturnType() != null ? 1 : 0);
+        return TargetFunNType.fromParams(params, filteredParams);
-    }
-
-    private boolean isSubtype(TargetType test, TargetType other) {
-        var testClass = compiler.getClass(new JavaClassName(test.name()));
-        var otherClass = compiler.getClass(new JavaClassName(other.name()));
-        if (testClass == null) return false;
-        while (testClass != null) {
-            if (testClass.equals(otherClass)) return true;
-            if (testClass.getClassName().equals(new JavaClassName("java.lang.Object"))) break;
-            testClass = compiler.getClass(testClass.getSuperClass().getName());
-        }
-        return false;
-    }
-
-    private boolean isSupertype(TargetType test, TargetType other) {
-        return isSubtype(other, test);
-    }
-
-    private boolean isSubtype(FunNGenerator.GenericParameters test, FunNGenerator.GenericParameters other) {
-        if (test.getArguments().size() != other.getArguments().size()) return false;
-        if (!isSubtype(test.getReturnType(), other.getReturnType())) return false;
-        for (int i = 0; i < test.getArguments().size(); i++) {
-            var arg1 = test.getArguments().get(i);
-            var arg2 = other.getArguments().get(i);
-            if (!isSupertype(arg1, arg2)) return false;
-        }
-        return true;
-    }
-
-    public void generateFunNTypes() {
-        for (var entry : usedFunN.entrySet()) {
-            var gep = entry.getValue();
-            var superInterfaces = usedFunN.values().stream()
-                .filter(g -> !g.equals(gep))
-                .filter(genericParameters -> isSubtype(gep, genericParameters))
-                .map(FunNGenerator::getSpecializedClassName)
-                .toList();
-
-            var code = FunNGenerator.generateSpecializedBytecode(gep, superInterfaces);
-
-            try {
-                classLoader.findClass(entry.getKey());
-            } catch (ClassNotFoundException e) {
-                try {
-                    classLoader.loadClass(code);
-                } catch (LinkageError ignored) {}
-            }
-            auxiliaries.put(entry.getKey(), code);
-        }
     }
 
     protected TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, GenerateGenerics generics) {
@@ -547,16 +448,17 @@ public class ASTToTargetAST {
                 }
 
                 var params = refType.getParaList().stream().map(type -> {
-                    return convert(type, generics);
+                    var res = convert(type, generics);
+                    if (res == null) res = new TargetRefType("java.lang.Void");
+                    return res;
                 }).toList();
 
                 if (name.matches("Fun\\d+\\$\\$")) { // TODO This seems like a bad idea
-                    var returnType = FunNGenerator.getReturnType(params);
+                    var className = FunNGenerator.getSpecializedClassName(FunNGenerator.getArguments(params), FunNGenerator.getReturnType(params));
-                    var className = FunNGenerator.getSpecializedClassName(FunNGenerator.getArguments(params), returnType);
                     if (!usedFunNSuperTypes.contains(params.size())) {
                         usedFunNSuperTypes.add(params.size());
-                        var code = FunNGenerator.generateSuperBytecode(params.size() - 1, returnType != null ? 1 : 0);
+                        var code = FunNGenerator.generateSuperBytecode(params.size() - 1);
-                        var superClassName = FunNGenerator.getSuperClassName(params.size() - 1, returnType != null ? 1 : 0);
+                        var superClassName = FunNGenerator.getSuperClassName(params.size() - 1);
                         try {
                             classLoader.findClass(superClassName);
                         } catch (ClassNotFoundException e) {
@@ -568,8 +470,17 @@ public class ASTToTargetAST {
                     }
                     FunNGenerator.GenericParameters gep = null;
                     if (!usedFunN.containsKey(className)) {
-                        gep = new FunNGenerator.GenericParameters(params, returnType != null ? 1 : 0);
+                        gep = new FunNGenerator.GenericParameters();
+                        var code = FunNGenerator.generateSpecializedBytecode(FunNGenerator.getArguments(params), FunNGenerator.getReturnType(params), gep);
+                        try {
+                            classLoader.findClass(className);
+                        } catch (ClassNotFoundException e) {
+                            try {
+                                classLoader.loadClass(code);
+                            } catch (LinkageError ignored) {}
+                        }
                         usedFunN.put(className, gep);
+                        auxiliaries.put(className, code);
                     } else {
                         gep = usedFunN.get(className);
                     }

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

@@ -652,12 +652,14 @@ public abstract class GenerateGenerics {
     }
 
     void normalize(Set<Pair> result, Set<Pair> classGenerics, Set<TPH> usedTphs) {
-        for (var p1 : new HashSet<>(result)) {
+        outer:
-            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) {
+            for (var p1 : new HashSet<>(result)) {
+                if (p1 instanceof PairLT ptph && ptph.left.equals(ptph.right))
+                    result.remove(p1); // TODO This is a bit strange
+                if (p1.left.equals(tph)) continue outer;
+            }
+
             if (classGenerics == null || classGenerics.stream().noneMatch((pair) -> pair.left.equals(tph)))
                 addToPairs(result, new PairEQ(tph, ASTToTargetAST.OBJECT));
         }

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.target.generate;
 
-import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
@@ -10,8 +9,6 @@ import de.dhbwstuttgart.syntaxtree.factory.PrimitiveMethodsGenerator;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.target.tree.MethodParameter;
-import de.dhbwstuttgart.target.tree.TargetGeneric;
-import de.dhbwstuttgart.target.tree.TargetMethod;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
 
@@ -84,9 +81,7 @@ public class StatementToTargetExpression implements ASTVisitor {
             } // Don't look at lambda expressions
         });
 
-        TargetMethod.Signature signature = new TargetMethod.Signature(Set.of(), parameters, converter.convert(lambdaExpression.getReturnType()));;
+        result = new TargetLambdaExpression(converter.convert(lambdaExpression.getType()), captures, parameters, converter.convert(lambdaExpression.getReturnType()), converter.convert(lambdaExpression.methodBody));
-        var tpe = converter.convert(lambdaExpression.getType());
-        result = new TargetLambdaExpression(tpe, captures, signature, converter.convert(lambdaExpression.methodBody));
     }
 
     @Override
@@ -108,9 +103,8 @@ public class StatementToTargetExpression implements ASTVisitor {
         case SUB -> new TargetBinaryOp.Sub(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
         case MUL -> new TargetBinaryOp.Mul(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
         case MOD -> new TargetBinaryOp.Rem(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
-        case AND -> new TargetBinaryOp.BAnd(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
+        case AND -> new TargetBinaryOp.And(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
-        case OR -> new TargetBinaryOp.BOr(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
+        case OR -> new TargetBinaryOp.Or(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
-        case XOR -> new TargetBinaryOp.XOr(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
         case DIV -> new TargetBinaryOp.Div(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
         case LESSTHAN -> new TargetBinaryOp.Less(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
         case BIGGERTHAN -> new TargetBinaryOp.Greater(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
@@ -205,23 +199,14 @@ public class StatementToTargetExpression implements ASTVisitor {
         Method foundMethod = null;
         var isStatic = false;
         var isInterface = true;
-        var isPrivate = false;
         var signature = methodCall.signatureArguments().stream().map(converter::convert).toList();
 
-        // Add used TPHs to containing method
+        var receiverClass = converter.currentClass;
-        for (var i = 0; i < methodCall.signatureArguments().size(); i++) {
-            converter.addSignaturePair(methodCall.signatureArguments().get(i), methodCall.arglist.getArguments().get(i).getType());
-        }
-
-        var receiverClass = converter.compiler.getClass(receiverName);
         if (methodCall.receiver instanceof ExpressionReceiver expressionReceiver && expressionReceiver.expr instanceof This) {
-            if (receiverClass == null) throw new DebugException("Class " + receiverName + " does not exist!");
+            var thisMethod = converter.findMethod(converter.currentClass, methodCall.name, signature);
-            var thisMethod = converter.findMethod(receiverClass, methodCall.name, signature);
+            foundMethod = thisMethod.orElseGet(() -> findMethod(converter.currentClass.getSuperClass().getName(), methodCall.name, signature).orElseThrow());
-            ClassOrInterface finalReceiverClass = receiverClass;
-            foundMethod = thisMethod.orElseGet(() -> findMethod(finalReceiverClass.getSuperClass().getName(), methodCall.name, signature).orElseThrow());
         } else if (!isFunNType) {
             receiverClass = converter.compiler.getClass(receiverName);
-            if (receiverClass == null) throw new DebugException("Class " + receiverName + " does not exist!");
             foundMethod = findMethod(receiverName, methodCall.name, signature).orElseThrow();
         }
 
@@ -229,20 +214,15 @@ public class StatementToTargetExpression implements ASTVisitor {
             returnType = converter.convert(foundMethod.getReturnType());
             argList = foundMethod.getParameterList().getFormalparalist().stream().map(e -> converter.convert(e.getType())).toList();
             isStatic = Modifier.isStatic(foundMethod.modifier);
-            isPrivate = Modifier.isPrivate(foundMethod.modifier);
             isInterface = receiverClass.isInterface();
         }
 
-        System.out.println(argList);
+        result = new TargetMethodCall(converter.convert(methodCall.getType()), returnType, argList, converter.convert(methodCall.receiver), methodCall.getArgumentList().getArguments().stream().map(converter::convert).toList(), receiverType, methodCall.name, isStatic, isInterface);
-        result = new TargetMethodCall(converter.convert(methodCall.getType()), returnType, argList, converter.convert(methodCall.receiver), methodCall.getArgumentList().getArguments().stream().map(converter::convert).toList(), receiverType, methodCall.name, isStatic, isInterface, isPrivate);
     }
 
     @Override
     public void visit(NewClass newClass) {
-        var receiverName = new JavaClassName(newClass.name);
+        result = new TargetNew(new TargetRefType(newClass.name), newClass.getArgumentList().getArguments().stream().map(converter::convert).toList());
-        var ctor = converter.findConstructor(converter.compiler.getClass(receiverName), newClass.signatureArguments().stream().map(converter::convert).toList());
-        var signature = ctor.orElseThrow().getParameterList().getFormalparalist().stream().map(e -> converter.convert(e.getType())).toList();
-        result = new TargetNew(new TargetRefType(newClass.name), signature, newClass.getArgumentList().getArguments().stream().map(converter::convert).toList());
     }
 
     @Override
@@ -266,11 +246,6 @@ public class StatementToTargetExpression implements ASTVisitor {
         result = new TargetBreak();
     }
 
-    @Override
-    public void visit(Continue aContinue) {
-        result = new TargetContinue();
-    }
-
     @Override
     public void visit(StaticClassName staticClassName) {
         result = new TargetClassName(converter.convert(staticClassName.getType()));
@@ -293,7 +268,7 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(DoStmt whileStmt) {
-        result = new TargetDo(converter.convert(whileStmt.expr), converter.convert(whileStmt.loopBlock));
+        throw new NotImplementedException();
     }
 
     // TODO These two might not be necessary
@@ -309,31 +284,20 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(SuperCall superCall) {
-        var aSuper = converter.convert(superCall.receiver.getType());
+        var aSuper = converter.convert(converter.currentClass.getSuperClass());
         var type = converter.convert(superCall.getType());
-        var receiverName = new JavaClassName(converter.convert(superCall.receiver.getType()).name());
+        var parameters = superCall.arglist.getArguments().stream().map(par -> converter.convert(par.getType())).toList();
-        var clazz = converter.compiler.getClass(receiverName);
-        var signature = superCall.signatureArguments().stream().map(converter::convert).toList();
-        var method = converter.findConstructor(clazz, signature);
-        var params = superCall.getArgumentList().getArguments().stream().map(converter::convert).toList();
 
-        List<TargetType> argList;
+        result = new TargetMethodCall(type, type, parameters, new TargetSuper(aSuper), superCall.getArgumentList().getArguments().stream().map(converter::convert).toList(), aSuper, superCall.name, false, false);
-        if (method.isPresent()) {
-            argList = method.get().getParameterList().getFormalparalist().stream().map(e -> converter.convert(e.getType())).toList();
-        } else {
-            argList = params.stream().map(TargetExpression::type).toList();
-        }
-
-        result = new TargetMethodCall(type, null, argList, new TargetSuper(aSuper), params, aSuper, superCall.name, false, false, false);
     }
 
     @Override
     public void visit(ThisCall thisCall) {
-        var aThis = converter.convert(thisCall.receiver.getType());
+        var aThis = converter.convert(new RefType(converter.currentClass.getClassName(), new NullToken()));
         var type = converter.convert(thisCall.getType());
         var parameters = thisCall.arglist.getArguments().stream().map(par -> converter.convert(par.getType())).toList();
 
-        result = new TargetMethodCall(type, type, parameters, new TargetThis(aThis), thisCall.getArgumentList().getArguments().stream().map(converter::convert).toList(), aThis, thisCall.name, false, false, false);
+        result = new TargetMethodCall(type, type, parameters, new TargetThis(aThis), thisCall.getArgumentList().getArguments().stream().map(converter::convert).toList(), aThis, thisCall.name, false, false);
     }
 
     @Override
@@ -381,11 +345,6 @@ public class StatementToTargetExpression implements ASTVisitor {
         result = new TargetThrow(converter.convert(aThrow.expr));
     }
 
-    @Override
-    public void visit(Ternary ternary) {
-        result = new TargetTernary(converter.convert(ternary.getType()), converter.convert(ternary.cond), converter.convert(ternary.iftrue), converter.convert(ternary.iffalse));
-    }
-
     @Override
     public void visit(Switch switchStmt) {
         var cases = switchStmt.getBlocks().stream().filter(s -> !s.isDefault()).map(converter::convert).toList();

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

@@ -124,11 +124,6 @@ public abstract class TracingStatementVisitor implements StatementVisitor {
 
     }
 
-    @Override
-    public void visit(Continue aContinue) {
-
-    }
-
     @Override
     public void visit(StaticClassName staticClassName) {
 
@@ -208,11 +203,4 @@ public abstract class TracingStatementVisitor implements StatementVisitor {
     public void visit(Yield aYield) {
 
     }
-
-    @Override
-    public void visit(Ternary ternary) {
-        ternary.cond.accept(this);
-        ternary.iftrue.accept(this);
-        ternary.iffalse.accept(this);
-    }
 }

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

@@ -1,24 +1,14 @@
 package de.dhbwstuttgart.target.tree;
 
 import de.dhbwstuttgart.target.tree.expression.TargetBlock;
-import de.dhbwstuttgart.target.tree.expression.TargetPattern;
 import de.dhbwstuttgart.target.tree.type.TargetType;
 import org.objectweb.asm.Opcodes;
 
 import java.util.List;
-import java.util.Objects;
 import java.util.Set;
 
 public record TargetMethod(int access, String name, TargetBlock block, Signature signature, Signature txSignature) {
-    public record Signature(Set<TargetGeneric> generics, List<MethodParameter> parameters, TargetType returnType) {
+    public record Signature(Set<TargetGeneric> generics, List<MethodParameter> parameters, TargetType returnType) { }
-        public String getSignature() {
-            return TargetMethod.getSignature(generics, parameters, returnType);
-        }
-
-        public String getDescriptor() {
-            return TargetMethod.getDescriptor(returnType, parameters.stream().map(MethodParameter::pattern).map(TargetPattern::type).toArray(TargetType[]::new));
-        }
-    }
 
     public static String getDescriptor(TargetType returnType, TargetType... parameters) {
         String ret = "(";
@@ -65,16 +55,5 @@ public record TargetMethod(int access, String name, TargetBlock block, Signature
     public boolean isStatic() {
         return (access & Opcodes.ACC_STATIC) != 0;
     }
-
-    @Override
-    public boolean equals(Object other) {
-        if (!(other instanceof TargetMethod otherMethod)) return false;
-        return otherMethod.signature.equals(this.signature) && otherMethod.name.equals(this.name);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(name, signature);
-    }
 }
 

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

@@ -1,4 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-public record TargetDo(TargetExpression cond, TargetExpression body) implements TargetExpression {
-}

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

@@ -3,7 +3,7 @@ package de.dhbwstuttgart.target.tree.expression;
 import de.dhbwstuttgart.target.tree.type.*;
 
 public sealed interface TargetExpression
-        permits TargetBinaryOp, TargetBlock, TargetBreak, TargetCast, TargetClassName, TargetContinue, TargetDo, TargetFieldVar, TargetFor, TargetForEach, TargetIf, TargetInstanceOf, TargetLambdaExpression, TargetLiteral, TargetLocalVar, TargetPattern, TargetReturn, TargetStatementExpression, TargetSuper, TargetSwitch, TargetTernary, TargetThis, TargetThrow, TargetUnaryOp, TargetVarDecl, TargetWhile, TargetYield {
+        permits TargetBinaryOp, TargetBlock, TargetBreak, TargetCast, TargetClassName, TargetContinue, TargetFieldVar, TargetFor, TargetForEach, TargetIf, TargetInstanceOf, TargetLambdaExpression, TargetLiteral, TargetLocalVar, TargetPattern, TargetReturn, TargetStatementExpression, TargetSuper, TargetSwitch, TargetTernary, TargetThis, TargetThrow, TargetUnaryOp, TargetVarDecl, TargetWhile, TargetYield {
 
     default TargetType type() {
         return null;

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

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

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

@@ -2,10 +2,9 @@ package de.dhbwstuttgart.target.tree.expression;
 
 import de.dhbwstuttgart.target.tree.MethodParameter;
 import de.dhbwstuttgart.target.tree.TargetField;
-import de.dhbwstuttgart.target.tree.TargetMethod;
 import de.dhbwstuttgart.target.tree.type.TargetType;
 
 import java.util.List;
 
-public record TargetLambdaExpression(TargetType type, List<MethodParameter> captures, TargetMethod.Signature signature, TargetBlock block) implements TargetExpression {
+public record TargetLambdaExpression(TargetType type, List<MethodParameter> captures, List<MethodParameter> params, TargetType returnType, TargetBlock block) implements TargetExpression {
 }

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

@@ -1,13 +1,15 @@
 package de.dhbwstuttgart.target.tree.expression;
 
+import de.dhbwstuttgart.target.tree.MethodParameter;
 import de.dhbwstuttgart.target.tree.TargetMethod;
+import de.dhbwstuttgart.target.tree.type.TargetRefType;
 import de.dhbwstuttgart.target.tree.type.TargetType;
 
 import java.util.List;
 
-public record TargetMethodCall(TargetType type, TargetType returnType, List<TargetType> parameterTypes, TargetExpression expr, List<TargetExpression> args, TargetType owner, String name, boolean isStatic, boolean isInterface, boolean isPrivate) implements TargetStatementExpression {
+public record TargetMethodCall(TargetType type, TargetType returnType, List<TargetType> parameterTypes, TargetExpression expr, List<TargetExpression> args, TargetType owner, String name, boolean isStatic, boolean isInterface) implements TargetStatementExpression {
-    public TargetMethodCall(TargetType type, TargetExpression expr, List<TargetExpression> args, TargetType owner, String name, boolean isStatic, boolean isInterface, boolean isPrivate) {
+    public TargetMethodCall(TargetType type, TargetExpression expr, List<TargetExpression> args, TargetType owner, String name, boolean isStatic, boolean isInterface) {
-        this(type, type, args.stream().map(TargetExpression::type).toList(), expr, args, owner, name, isStatic, isInterface, isPrivate);
+        this(type, type, args.stream().map(TargetExpression::type).toList(), expr, args, owner, name, isStatic, isInterface);
     }
 
 

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

@@ -5,8 +5,8 @@ import de.dhbwstuttgart.target.tree.type.TargetType;
 
 import java.util.List;
 
-public record TargetNew(TargetType type, List<TargetType> signature, List<TargetExpression> params) implements TargetStatementExpression {
+public record TargetNew(TargetType type, List<TargetExpression> params) implements TargetStatementExpression {
     public String getDescriptor() {
-        return TargetMethod.getDescriptor(null, signature.toArray(TargetType[]::new));
+        return TargetMethod.getDescriptor(null, params.stream().map(TargetExpression::type).toArray(TargetType[]::new));
     }
 }

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

@@ -8,6 +8,4 @@ public sealed interface TargetPattern extends TargetExpression permits TargetCom
     }
 
     TargetPattern withType(TargetType type);
-
-    TargetType type();
 }

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

@@ -2,5 +2,5 @@ package de.dhbwstuttgart.target.tree.expression;
 
 import de.dhbwstuttgart.target.tree.type.TargetType;
 
-public record TargetTernary(TargetType type, TargetExpression cond, TargetExpression iftrue, TargetExpression iffalse) implements TargetExpression {
+public record TargetTernary(TargetType type, TargetExpression cond, TargetExpression ifTrue, TargetExpression ifFalse) implements TargetExpression {
 }

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

@@ -1,4 +1,6 @@
 package de.dhbwstuttgart.target.tree.expression;
 
+import de.dhbwstuttgart.target.tree.type.TargetType;
+
 public record TargetWhile(TargetExpression cond, TargetExpression body) implements TargetExpression {
 }

src/main/java/de/dhbwstuttgart/target/tree/type/TargetFunNType.java

@@ -4,29 +4,15 @@ import de.dhbwstuttgart.bytecode.FunNGenerator;
 
 import java.util.List;
 
-public record TargetFunNType(String name, List<TargetType> funNParams, List<TargetType> params, int returnArguments) implements TargetSpecializedType {
+public record TargetFunNType(String name, List<TargetType> params) implements TargetSpecializedType {
 
-    public static TargetFunNType fromParams(List<TargetType> params, int returnArguments) {
+    public static TargetFunNType fromParams(List<TargetType> params) {
-        return fromParams(params, params, returnArguments);
+        return fromParams(params, params);
     }
 
-    public static TargetFunNType fromParams(List<TargetType> params, List<TargetType> realParams, int returnArguments) {
+    public static TargetFunNType fromParams(List<TargetType> params, List<TargetType> realParams) {
         var name = FunNGenerator.getSpecializedClassName(FunNGenerator.getArguments(params), FunNGenerator.getReturnType(params));
-        return new TargetFunNType(name, params, realParams, returnArguments);
+        return new TargetFunNType(name, realParams);
-    }
-
-    public String toMethodDescriptor() {
-        var res = "(";
-        for (var i = 0; i < funNParams.size() - 1; i++) {
-            res += "Ljava/lang/Object;";
-        }
-        res += ")";
-        if (returnArguments > 0) {
-            res += "Ljava/lang/Object;";
-        } else {
-            res += "V";
-        }
-        return res;
     }
 
     @Override

src/main/java/de/dhbwstuttgart/target/tree/type/TargetType.java

@@ -53,17 +53,19 @@ public sealed interface TargetType
         };
     }
 
-    static TargetType toWrapper(TargetType f) {
+    static TargetType toTargetType(Class<?> clazz) {
-        if (f.equals(boolean_))    return Boolean;
+        if (clazz.isPrimitive()) {
-        if (f.equals(char_))       return Char;
+            if (clazz.equals(boolean.class))    return boolean_;
-        if (f.equals(byte_))       return Byte;
+            if (clazz.equals(char.class))       return char_;
-        if (f.equals(short_))      return Short;
+            if (clazz.equals(byte.class))       return byte_;
-        if (f.equals(int_))        return Integer;
+            if (clazz.equals(short.class))      return short_;
-        if (f.equals(long_))       return Long;
+            if (clazz.equals(int.class))        return int_;
-        if (f.equals(float_))      return Float;
+            if (clazz.equals(long.class))       return long_;
-        if (f.equals(double_))     return Double;
+            if (clazz.equals(float.class))      return float_;
-
+            if (clazz.equals(double.class))     return double_;
-        return f;
+        }
+        if (clazz.equals(void.class)) return null;
+        return new TargetRefType(clazz.getName());
     }
 
     String toSignature();

src/main/java/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java

@@ -10,7 +10,6 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.typeinference.constraints.GenericsResolver;
-import de.dhbwstuttgart.typeinference.typeAlgo.TYPEStmt;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -20,16 +19,14 @@ public class MethodAssumption extends Assumption{
     private RefTypeOrTPHOrWildcardOrGeneric retType;
     List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
     private final Boolean isInherited;
-    private final Boolean isOverridden;
 
     public MethodAssumption(ClassOrInterface receiver, RefTypeOrTPHOrWildcardOrGeneric retType,
-                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope, Boolean isInherited, Boolean isOverridden){
+                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope, Boolean isInherited){
         super(scope);
         this.receiver = receiver;
         this.retType = retType;
         this.params = params;
         this.isInherited = isInherited;
-        this.isOverridden = isOverridden;
     }
 
     /*
@@ -70,14 +67,23 @@ public class MethodAssumption extends Assumption{
      * @return
      */
     public RefTypeOrTPHOrWildcardOrGeneric getReceiverType(GenericsResolver resolver) {
-        return TYPEStmt.getReceiverType(receiver, resolver);
+        if (receiver == null) return null;
+        List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+        for(GenericTypeVar gtv : receiver.getGenerics()){
+            //Die Generics werden alle zu TPHs umgewandelt.
+            params.add(resolver.resolve(new GenericRefType(gtv.getName(), new NullToken())));
+        }
+        RefTypeOrTPHOrWildcardOrGeneric receiverType;
+        if(receiver instanceof FunNClass){
+            receiverType = new RefType(new JavaClassName(receiver.getClassName().toString()+"$$"), params, new NullToken()); // new FunN(params);
+        }else{
+            receiverType = new RefType(receiver.getClassName(), params, new NullToken());
+        }
+
+        return receiverType;
     }
     
     public Boolean isInherited() {
     	return isInherited;
     }
-    
-    public Boolean isOverridden() {
-    	return isOverridden;
-    }
 }

src/main/java/de/dhbwstuttgart/typeinference/assumptions/TypeInferenceBlockInformation.java

@@ -2,8 +2,6 @@ package de.dhbwstuttgart.typeinference.assumptions;
 
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Iterators;
-import de.dhbwstuttgart.bytecode.CodeGenException;
-import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
@@ -32,14 +30,6 @@ public class TypeInferenceBlockInformation extends TypeInferenceInformation {
     public ClassOrInterface getCurrentClass() {
         return currentClass;
     }
-
-    public ClassOrInterface getSuperClass() {
-        for (var clazz : getAvailableClasses()) {
-            if (clazz.getClassName().equals(currentClass.getSuperClass().getName()))
-                return clazz;
-        }
-        throw new DebugException("Class has no superclass!");
-    }
     public TypeScope getCurrentTypeScope() {
         return methodContext;
     }

src/main/java/de/dhbwstuttgart/typeinference/constraints/Constraint.java

@@ -8,8 +8,7 @@ import java.util.Set;
 
 public class Constraint<A> extends HashSet<A> {
 	private static final long serialVersionUID = 1L;
-	private Boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
+	private Boolean isInherited = false;//wird nur für die Method-Constraints benoetigt
-	private Boolean isImplemented = false;
 	
 	/*
 	 * wird verwendet um bei der Codegenerierung die richtige Methoden - Signatur
@@ -23,14 +22,12 @@ public class Constraint<A> extends HashSet<A> {
 		super();
 	}
 	
-	public Constraint(Boolean isInherited, Boolean isImplemented) {
+	public Constraint(Boolean isInherited) {
 		this.isInherited = isInherited;
-		this.isImplemented = isImplemented;
 	}
 	
-	public Constraint(Boolean isInherited, Boolean isImplemented, Constraint<A> extendConstraint, Set<A> methodSignatureConstraint) {
+	public Constraint(Boolean isInherited, Constraint<A> extendConstraint, Set<A> methodSignatureConstraint) {
 		this.isInherited = isInherited;
-		this.isImplemented = isImplemented;
 		this.extendConstraint = extendConstraint;
 		this.methodSignatureConstraint = methodSignatureConstraint;
 	}
@@ -43,10 +40,6 @@ public class Constraint<A> extends HashSet<A> {
 		return isInherited;
 	}
 	
-	public Boolean isImplemented() {
-		return isImplemented;
-	}
-	
 	public Constraint<A> getExtendConstraint() {
 		return extendConstraint;
 	}
@@ -64,8 +57,7 @@ public class Constraint<A> extends HashSet<A> {
 	}
 
 	public String toString() {
-		return super.toString() + "\nisInherited = " + isInherited + " isOveridden = " + isImplemented
+		return super.toString() + "\nisInherited = " + isInherited 
-				+ methodSignatureConstraint
 				//" + extendsContraint: "  + (extendConstraint != null ? extendConstraint.toStringBase() : "null" ) 
 				+ "\n" ;
 	}

src/main/java/de/dhbwstuttgart/typeinference/constraints/ConstraintSet.java

@@ -71,13 +71,12 @@ public class ConstraintSet<A> {
         
         for(Set<Constraint<A>> oderConstraint : oderConstraints){
             newOder.add(
-                    oderConstraint.stream().map((Constraint<A> as) -> {
+                    oderConstraint.parallelStream().map((Constraint<A> as) -> {
                     	
                     	Constraint<B> newConst = as.stream()
                     			.map(o)
                     			.collect(Collectors.toCollection((
                     					() -> new Constraint<B> (as.isInherited(),
-                    											 as.isImplemented(),
                     											 (as.getExtendConstraint() != null)
                     											     ? as.getExtendConstraint().stream().map(o).collect(Collectors.toCollection(Constraint::new))
                     											     : null,

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

@@ -15,22 +15,24 @@ import java.util.*;
 
 public class TYPE {
 
-    private final SourceFile sf;
+    private final Collection<SourceFile> sfs;
     private final Set<ClassOrInterface> allAvailableClasses;
     
-    public TYPE(SourceFile sf, Set<ClassOrInterface> allAvailableClasses){
+    public TYPE(Collection<SourceFile> sourceFiles, Set<ClassOrInterface> allAvailableClasses){
-        this.sf = sf;
+        sfs = sourceFiles;
         this.allAvailableClasses = allAvailableClasses;
     }
 
     public ConstraintSet getConstraints() {
         ConstraintSet ret = new ConstraintSet();
-        for (ClassOrInterface cl : sf.KlassenVektor) {
+        for(SourceFile sf : sfs)
-            var allClasses = new HashSet<ClassOrInterface>();
+            for (ClassOrInterface cl : sf.KlassenVektor) {
-            allClasses.addAll(allAvailableClasses);
+                System.out.println(sf.availableClasses);
-            allClasses.addAll(sf.availableClasses);
+                var allClasses = new HashSet<ClassOrInterface>();
-            ret.addAll(getConstraintsClass(cl, new TypeInferenceInformation(allClasses)));
+                allClasses.addAll(allAvailableClasses);
-        }
+                allClasses.addAll(sf.availableClasses);
+                ret.addAll(getConstraintsClass(cl, new TypeInferenceInformation(allClasses)));
+            }
         return ret;
     }
 

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

@@ -1,7 +1,6 @@
 //PL 2018-12-19: Merge chekcen
 package de.dhbwstuttgart.typeinference.typeAlgo;
 
-import java.sql.Ref;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -246,9 +245,6 @@ public class TYPEStmt implements StatementVisitor {
             constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), number, PairOperator.SMALLERNEQDOT, loc(unaryExpr.getOffset())));
             // The type of the postfix increment expression is the type of the variable
             constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), unaryExpr.getType(), PairOperator.EQUALSDOT, loc(unaryExpr.getOffset())));
-        } else if (unaryExpr.operation == UnaryExpr.Operation.NOT) {
-            constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), unaryExpr.getType(), PairOperator.EQUALSDOT, loc(unaryExpr.getOffset())));
-            constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), new RefType(ASTFactory.createClass(java.lang.Boolean.class).getClassName(), new NullToken()), PairOperator.EQUALSDOT, loc(unaryExpr.getOffset())));
         } else {
             throw new NotImplementedException();
         }
@@ -260,15 +256,7 @@ public class TYPEStmt implements StatementVisitor {
     public void visit(BinaryExpr binary) {
         binary.lexpr.accept(this);
         binary.rexpr.accept(this);
-        if (binary.operation.equals(BinaryExpr.Operator.DIV)
+        if (binary.operation.equals(BinaryExpr.Operator.DIV) || binary.operation.equals(BinaryExpr.Operator.MUL) || binary.operation.equals(BinaryExpr.Operator.MOD) || binary.operation.equals(BinaryExpr.Operator.ADD) || binary.operation.equals(BinaryExpr.Operator.SUB)) {
-            || binary.operation.equals(BinaryExpr.Operator.MUL)
-            || binary.operation.equals(BinaryExpr.Operator.MOD)
-            || binary.operation.equals(BinaryExpr.Operator.ADD)
-            || binary.operation.equals(BinaryExpr.Operator.SUB)
-            || binary.operation.equals(BinaryExpr.Operator.OR)
-            || binary.operation.equals(BinaryExpr.Operator.AND)
-            || binary.operation.equals(BinaryExpr.Operator.XOR)) {
-
             Set<Constraint<Pair>> numericAdditionOrStringConcatenation = new HashSet<>();
 
             // TODO PL 2018-11-06
@@ -488,16 +476,6 @@ public class TYPEStmt implements StatementVisitor {
         aThrow.expr.accept(this);
     }
 
-    @Override
-    public void visit(Ternary ternary) {
-        ternary.cond.accept(this);
-        ternary.iftrue.accept(this);
-        ternary.iffalse.accept(this);
-        constraintsSet.addUndConstraint(new Pair(ternary.cond.getType(), bool, PairOperator.EQUALSDOT));
-        constraintsSet.addUndConstraint(new Pair(ternary.iftrue.getType(), ternary.getType(), PairOperator.SMALLERDOT));
-        constraintsSet.addUndConstraint(new Pair(ternary.iffalse.getType(), ternary.getType(), PairOperator.SMALLERDOT));
-    }
-
     @Override
     public void visit(Return returnExpr) {
         returnExpr.retexpr.accept(this);
@@ -514,11 +492,6 @@ public class TYPEStmt implements StatementVisitor {
 
     }
 
-    @Override
-    public void visit(Continue aContinue) {
-
-    }
-
     @Override
     public void visit(StaticClassName staticClassName) {
         // Hier entstehen keine Constraints
@@ -526,13 +499,7 @@ public class TYPEStmt implements StatementVisitor {
 
     @Override
     public void visit(Super aSuper) {
-        var superClass = info.getSuperClass();
+        throw new NotImplementedException();
-        var params = new ArrayList<RefTypeOrTPHOrWildcardOrGeneric>();
-        for (var gtv : superClass.getGenerics()) {
-            params.add(new GenericRefType(gtv.getName(), aSuper.getOffset()));
-        }
-        var superType = new RefType(superClass.getClassName(), params, aSuper.getOffset());
-        constraintsSet.addUndConstraint(new Pair(aSuper.getType(), superType, PairOperator.EQUALSDOT, loc(aSuper.getOffset())));
     }
 
     @Override
@@ -574,10 +541,7 @@ public class TYPEStmt implements StatementVisitor {
 
     @Override
     public void visit(DoStmt whileStmt) {
-        RefType booleanType = new RefType(ASTFactory.createClass(java.lang.Boolean.class).getClassName(), new NullToken());
+        throw new NotImplementedException();
-        whileStmt.expr.accept(this);
-        constraintsSet.addUndConstraint(new Pair(whileStmt.expr.getType(), booleanType, PairOperator.EQUALSDOT, loc(whileStmt.expr.getOffset())));
-        whileStmt.loopBlock.accept(this);
     }
 
     @Override
@@ -595,17 +559,20 @@ public class TYPEStmt implements StatementVisitor {
     @Override
     public void visit(SuperCall superCall) {
         Set<Constraint<Pair>> methodConstraints = new HashSet<>();
-        var clazz = info.getSuperClass();
+        for (var clazz : info.getAvailableClasses()) {
-        for (var ctor : clazz.getConstructors()) {
+            if (clazz.getClassName().equals(info.getCurrentClass().getSuperClass().getName())) {
-            var params = convertParams(ctor.getParameterList(), info);
+                for (var ctor : clazz.getConstructors()) {
-            if (params.size() != superCall.arglist.getArguments().size()) continue;
+                    var params = convertParams(ctor.getParameterList(), info);
-            var assumption = new MethodAssumption(null, new Void(new NullToken()), params, createTypeScope(clazz, ctor), ctor.isInherited, false);
+                    if (params.size() != superCall.arglist.getArguments().size()) continue;
+                    var assumption = new MethodAssumption(null, new Void(new NullToken()), params, createTypeScope(clazz, ctor), ctor.isInherited);
 
-            GenericsResolver resolver = getResolverInstance();
+                    GenericsResolver resolver = getResolverInstance();
-            Set<Constraint<Pair>> oneMethodConstraints = generateConstraint(superCall, assumption, info, resolver);
+                    Set<Constraint<Pair>> oneMethodConstraints = generateConstraint(superCall, assumption, info, resolver);
-            methodConstraints.addAll(oneMethodConstraints);
+                    methodConstraints.addAll(oneMethodConstraints);
+                }
+                break;
+            }
         }
-        constraintsSet.addUndConstraint(new Pair(superCall.receiver.getType(), getReceiverType(info.getSuperClass(), getResolverInstance()), PairOperator.EQUALSDOT));
         constraintsSet.addOderConstraint(methodConstraints);
     }
 
@@ -615,41 +582,23 @@ public class TYPEStmt implements StatementVisitor {
         for (var ctor : info.getCurrentClass().getConstructors()) {
             var params = convertParams(ctor.getParameterList(), info);
             if (params.size() != thisCall.arglist.getArguments().size()) continue;
-            var assumption = new MethodAssumption(null, new Void(new NullToken()), params, createTypeScope(info.getCurrentClass(), ctor), ctor.isInherited, false);
+            var assumption = new MethodAssumption(null, new Void(new NullToken()), params, createTypeScope(info.getCurrentClass(), ctor), ctor.isInherited);
 
             GenericsResolver resolver = getResolverInstance();
             Set<Constraint<Pair>> oneMethodConstraints = generateConstraint(thisCall, assumption, info, resolver);
             methodConstraints.addAll(oneMethodConstraints);
         }
-        constraintsSet.addUndConstraint(new Pair(thisCall.receiver.getType(), getReceiverType(info.getCurrentClass(), getResolverInstance()), PairOperator.EQUALSDOT));
         constraintsSet.addOderConstraint(methodConstraints);
     }
 
-    public static RefTypeOrTPHOrWildcardOrGeneric getReceiverType(ClassOrInterface receiver, GenericsResolver resolver) {
-        if (receiver == null) return null;
-        List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
-        for(GenericTypeVar gtv : receiver.getGenerics()){
-            //Die Generics werden alle zu TPHs umgewandelt.
-            params.add(resolver.resolve(new GenericRefType(gtv.getName(), new NullToken())));
-        }
-        RefTypeOrTPHOrWildcardOrGeneric receiverType;
-        if(receiver instanceof FunNClass){
-            receiverType = new RefType(new JavaClassName(receiver.getClassName().toString()+"$$"), params, new NullToken()); // new FunN(params);
-        }else{
-            receiverType = new RefType(receiver.getClassName(), params, new NullToken());
-        }
-
-        return receiverType;
-    }
-
     /*
      * METHOD CALL Section:
      */
 
     protected Set<Constraint<Pair>> generateConstraint(MethodCall forMethod, MethodAssumption assumption, TypeInferenceBlockInformation info, GenericsResolver resolver) {
         Constraint<Pair> methodConstraint, extendsMethodConstraint;
-        methodConstraint = new Constraint<>(assumption.isInherited(), assumption.isOverridden());
+        methodConstraint = new Constraint<>(assumption.isInherited());
-        extendsMethodConstraint = new Constraint<>(assumption.isInherited(), assumption.isOverridden());// PL 2023-01-24: Ersetzt die Dopplung in visit(MethodCall)
+        extendsMethodConstraint = new Constraint<>(assumption.isInherited());// PL 2023-01-24: Ersetzt die Dopplung in visit(MethodCall)
 
         ClassOrInterface receiverCl = assumption.getReceiver();
         /*
@@ -691,8 +640,7 @@ public class TYPEStmt implements StatementVisitor {
 
         Set<Pair> methodSignatureConstraint = generatemethodSignatureConstraint(forMethod, assumption, info, resolver);
 
-        //System.out.println("methodSignatureConstraint: " + methodSignatureConstraint);
+        System.out.println("methodSignatureConstraint; " + methodSignatureConstraint);
-        //System.out.println("methodConstraint: " + methodConstraint);
 
         methodConstraint.setmethodSignatureConstraint(methodSignatureConstraint);
         extendsMethodConstraint.setmethodSignatureConstraint(methodSignatureConstraint);
@@ -700,7 +648,6 @@ public class TYPEStmt implements StatementVisitor {
         Set<Constraint<Pair>> ret = new HashSet<>();
         ret.add(methodConstraint);
         ret.add(extendsMethodConstraint);
-
         return ret;
     }
 
@@ -724,6 +671,7 @@ public class TYPEStmt implements StatementVisitor {
         Set<Pair> ret = new HashSet<>();
 
         for (int i = 0; i < foMethod.arglist.getArguments().size(); i++) {
+
             // Zuordnung von MethoCall.signature (Argumenttypen) zu der Argumenttypen der ausgewaehlten Methode (assumption.params)
             ret.add(new Pair(foMethod.signature.get(i), assumption.getArgTypes().get(i), PairOperator.EQUALSDOT));
 
@@ -754,14 +702,14 @@ public class TYPEStmt implements StatementVisitor {
                 public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
                     throw new NotImplementedException();
                 }
-            }, false, false));
+            }, false));
         }
         for (ClassOrInterface cl : info.getAvailableClasses()) {
             for (Method m : cl.getMethods()) {
                 if (m.getName().equals(name) && m.getParameterList().getFormalparalist().size() == numArgs) {
                     RefTypeOrTPHOrWildcardOrGeneric retType = m.getReturnType();// info.checkGTV(m.getReturnType());
 
-                    ret.add(new MethodAssumption(cl, retType, convertParams(m.getParameterList(), info), createTypeScope(cl, m), m.isInherited, m.isImplemented));
+                    ret.add(new MethodAssumption(cl, retType, convertParams(m.getParameterList(), info), createTypeScope(cl, m), m.isInherited));
                 }
             }
         }
@@ -792,8 +740,7 @@ public class TYPEStmt implements StatementVisitor {
             if (cl.getClassName().equals(ofType.getName())) {
                 for (Method m : cl.getConstructors()) {
                     if (m.getParameterList().getFormalparalist().size() == argList.getArguments().size()) {
-                        var params = convertParams(m.getParameterList(), info);
+                        ret.add(new MethodAssumption(cl, cl.generateTypeOfThisClass(), convertParams(m.getParameterList(), info), createTypeScope(cl, m), m.isInherited));
-                        ret.add(new MethodAssumption(cl, cl.generateTypeOfThisClass(), params, createTypeScope(cl, m), m.isInherited, m.isImplemented));
                     }
                 }
             }
@@ -808,12 +755,6 @@ public class TYPEStmt implements StatementVisitor {
         methodConstraint.add(new Pair(assumption.getReturnType(resolver), forConstructor.getType(), PairOperator.SMALLERDOT, loc(forConstructor.getOffset())));
         // WELCHEN SINN MACHT DIESER CONSTRAINT???
         methodConstraint.addAll(generateParameterConstraints(forConstructor, assumption, info, resolver));
-
-        Set<Pair> methodSignatureConstraint = generatemethodSignatureConstraint(forConstructor, assumption, info, resolver);
-        methodConstraint.setmethodSignatureConstraint(methodSignatureConstraint);
-
-        methodConstraint.addAll(methodSignatureConstraint);
-
         return methodConstraint;
     }
 

src/main/java/de/dhbwstuttgart/typeinference/unify/Match.java

@@ -79,10 +79,9 @@ public class Match implements IMatch {
 			// SUBST - Rule
 			if(lhsType instanceof PlaceholderType) {
 				mgu.add((PlaceholderType) lhsType, rhsType);
+				termsList = termsList.stream().map(mgu::applyleft).collect(Collectors.toCollection(ArrayList::new));
 				idx = idx+1 == termsList.size() ? 0 : idx+1;
-				//PL 2024-04-08 falsch da es sich nicht um Unifikation handelt
+				continue;
-				//termsList = termsList.stream().map(mgu::applyleft).collect(Collectors.toCollection(ArrayList::new));
-				//continue;
 			}
 			
 			idx++;

src/main/java/de/dhbwstuttgart/typeinference/unify/RuleSet.java

@@ -12,14 +12,21 @@ import java.util.Stack;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.exceptions.DebugException;
-import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
 import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IRuleSet;
-import de.dhbwstuttgart.typeinference.unify.model.*;
+import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
+import de.dhbwstuttgart.typeinference.unify.model.FunNType;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
+import de.dhbwstuttgart.typeinference.unify.model.SuperType;
+import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
+import de.dhbwstuttgart.typeinference.unify.model.Unifier;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+import de.dhbwstuttgart.typeinference.unify.model.WildcardType;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 
@@ -702,10 +709,9 @@ public class RuleSet implements IRuleSet{
 						x -> uni.apply(pair,x)).collect(Collectors.toCollection((b.getExtendConstraint() != null)
 								? () -> new Constraint<UnifyPair>(
 										  b.isInherited(),
-										  b.isImplemented(),
 										  b.getExtendConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(Constraint::new)),
 										  b.getmethodSignatureConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(HashSet::new)))
-								: () -> new Constraint<UnifyPair>(b.isInherited(), b.isImplemented())
+								: () -> new Constraint<UnifyPair>(b.isInherited())
 									));
 				oderConstraints.replaceAll(oc -> oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new)));
 				/*
@@ -886,42 +892,38 @@ public class RuleSet implements IRuleSet{
 		
 		//FunN$$<...> <. FunctinalInterface<...> wird umgewandelt in FunN$$<...> <. FunN$$<... args aus FuntionalInterface ...>
 		if (rhsType instanceof ReferenceType) {
+		
 			UnifyType typeFI = pair.getRhsType();
 			
 			Optional<UnifyType> opt = fc.getRightHandedFunctionalInterfaceType(typeFI.getName());
 			if(!opt.isPresent())
 				return Optional.empty();
 			
-			if (!(typeFI instanceof ReferenceType refType) || !(refType instanceof FunInterfaceType intf))
+			// The generic Version of typeFI (FI<a1, a2, a3, ... >)
+			UnifyType typeDgen = opt.get();
+		
+			// Actually greater+ because the types are ensured to have different names
+			Set<UnifyType> smaller = fc.getChildren(typeDgen);
+			opt = smaller.stream().filter(x -> x.getName().equals(pair.getLhsType().getName())).findAny();
+
+			if(!opt.isPresent())
 				return Optional.empty();
-
+			
-			var fiArgs = intf.getFunctionalInterfaceTypeArguments(refType);
+			TypeParams typeDParams = typeFI.getTypeParams();
-			var retType = fiArgs.getFirst();
+			TypeParams typeDgenParams = typeDgen.getTypeParams();
-			var lhsArgs = intf.getFunctionalInterfaceTypeArguments(lhsType);
+			
-			var lhsRet = lhsArgs.getFirst();
+			Unifier unif = Unifier.identity();
-
+			for(int i = 0; i < typeDParams.size(); i++) {
+				if (typeDgenParams.get(i) instanceof PlaceholderType) 
+				unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
+				else System.out.println("ERROR");
+			}
+			
+			UnifyType newRhsType = opt.get();
+			
 			Set<UnifyPair> result = new HashSet<>();
-			if (retType instanceof ExtendsType) {
+			result.add(new UnifyPair(lhsType, unif.apply(newRhsType), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
-				result.add(new UnifyPair(lhsRet, retType, PairOperator.SMALLERDOTWC));
+			
-			} else if (retType instanceof SuperType) {
-				return Optional.empty();
-			} else {
-				result.add(new UnifyPair(lhsRet, retType, PairOperator.EQUALSDOT));
-			}
-
-			for (var i = 1; i < fiArgs.size(); i++) {
-				var lh = lhsArgs.get(i);
-				var rh = fiArgs.get(i);
-
-				if (rh instanceof SuperType) {
-					result.add(new UnifyPair(lh, rh, PairOperator.SMALLERDOTWC));
-				} else if (rh instanceof ExtendsType) {
-					return Optional.empty();
-				} else {
-					result.add(new UnifyPair(lh, rh, PairOperator.EQUALSDOT));
-				}
-			}
-
 			return Optional.of(result);
 		}
 

src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java

@@ -253,14 +253,13 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		one = true;
 		Set<UnifyPair> neweq = new HashSet<>(eq);
 		/* 1-elementige Oder-Constraints werden in und-Constraints umgewandelt */
-		Set<UnifyPair> methodSignatureConstraint = new HashSet<>();
 		oderConstraintsField.stream()
         	.filter(x -> x.size()==1)
-        	.map(y -> y.stream().findFirst().get()).forEach(x -> { neweq.addAll(x); methodSignatureConstraint.addAll(x.getmethodSignatureConstraint());} );
+        	.map(y -> y.stream().findFirst().get()).forEach(x -> neweq.addAll(x));
 		ArrayList<Set<Constraint<UnifyPair>>> remainingOderconstraints = oderConstraintsField.stream()
 				.filter(x -> x.size()>1)
 				.collect(Collectors.toCollection(ArrayList::new));
-		Set<Set<UnifyPair>> res = unify(neweq, remainingOderconstraints, fc, parallel, rekTiefeField, methodSignatureConstraint);
+		Set<Set<UnifyPair>> res = unify(neweq, remainingOderconstraints, fc, parallel, rekTiefeField, new HashSet<>());
 		noOfThread--;
 		try {
 			logFile.close();
@@ -595,17 +594,15 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 						/* methodconstraintsets werden zum Ergebnis hinzugefuegt
 						 * Anfang
 						 */
-						//System.out.println("methodSignatureConstraint Return: " + methodSignatureConstraint + "\n");
+						//System.out.println("methodSignatureConstraint Return: " + methodSignatureConstraint);
 						eqPrimePrimeSet.forEach(x -> x.addAll(methodSignatureConstraint));
 						
 						//Substitutionen in methodcontraintsets werdne ausgeführt
-						/* PL auskommentiert 2024-05-02
 						eqPrimePrimeSet = eqPrimePrimeSet.stream().map(
 									x -> { Optional<Set<UnifyPair>> help = rules.subst(x); 
 										   return help.isPresent() ? 
 												   help.get(): 
 													   x; }).collect(Collectors.toSet());
-						*/							   
 						/*
 						 * Ende
 						 */
@@ -816,7 +813,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			writeLog("nextSetasList: " + nextSetasList.toString());
 			if (variance == 1) {
 				a = oup.max(nextSetasList.iterator());
-				writeLog("Max: a in " + variance + " "+ a);
 				nextSetasList.remove(a);
 				if (oderConstraint) {
 					nextSetasListOderConstraints.add(((Constraint<UnifyPair>)a).getExtendConstraint());
@@ -889,11 +885,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			
 			if (oderConstraint) {//Methodconstraints werden abgespeichert für die Bytecodegenerierung von Methodenaufrufen
 				methodSignatureConstraint.addAll(((Constraint<UnifyPair>)a).getmethodSignatureConstraint());
-				writeLog("ERSTELLUNG methodSignatureConstraint: " + methodSignatureConstraint);
+				//System.out.println("ERSTELLUNG: " +methodSignatureConstraint);
-				//System.out.println("ERSTELLUNG methodSignatureConstraint: " +noOfThread+" "+methodSignatureConstraint);
-				//System.out.println("a: " +a);
-				//System.out.println("eq: " +eq);
-				//System.out.println();
 			}
 
 			i++;
@@ -1142,22 +1134,14 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					writeLog("a in " + variance + " "+ a);
 					writeLog("nextSetasListRest: " + nextSetasListRest.toString());
 				}
-		    	
-		    	//Fuer parallele Berechnung der Oder-Contraints wird methodSignature kopiert
-		    	//und jeweils die methodSignature von a bzw. nSaL wieder gelöscht, wenn es keine Lösung ist. 
-		    	Set<UnifyPair> methodSignatureConstraintForParallel = new HashSet<>(methodSignatureConstraint);
-		    	Set<UnifyPair> nSaL = a;
-		    	
 		    	while (!nextSetasListRest.isEmpty()) {
-		    		methodSignatureConstraintForParallel.removeAll(((Constraint<UnifyPair>)nSaL).getmethodSignatureConstraint());
+		    		Set<UnifyPair> nSaL = nextSetasListRest.remove(0);
-		    		nSaL = nextSetasListRest.remove(0);
 		    		nextSetasList.remove(nSaL); //PL einkommentiert 20-02-03
-		    		methodSignatureConstraintForParallel.addAll(((Constraint<UnifyPair>)nSaL).getmethodSignatureConstraint());
 		    		Set<UnifyPair> newEq = new HashSet<>(eq);
 		    		Set<Set<UnifyPair>> newElems = new HashSet<>(elems);
 		    		List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
 		    		newElems.add(nSaL);
-		    		TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, parallel, logFile, log, rekTiefe, urm, usedTasks, new HashSet<>(methodSignatureConstraintForParallel));
+		    		TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, parallel, logFile, log, rekTiefe, urm, usedTasks, methodSignatureConstraint);
 		    		forks.add(fork);
 		    		synchronized(usedTasks) {
 						if (this.myIsCancelled()) {
@@ -1354,15 +1338,12 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 						while(aParDefIt.hasNext()) {
 							Set<UnifyPair> a_new = aParDefIt.next();
 							List<Set<UnifyPair>> smallerSetasList = oup.smallerThan(a_new, nextSetasList);
-							writeLog("smallerSetasList: " + smallerSetasList);
 							List<Set<UnifyPair>> notInherited = smallerSetasList.stream()
-								.filter(x -> !((Constraint<UnifyPair>)x).isInherited() && !((Constraint<UnifyPair>)x).isImplemented())
+								.filter(x -> !((Constraint<UnifyPair>)x).isInherited())
 								.collect(Collectors.toCollection(ArrayList::new));
-							writeLog("notInherited: " + notInherited+"\n");
 							List<Set<UnifyPair>> notErased = new ArrayList<>();
 							notInherited.stream().forEach(x -> { notErased.addAll(oup.smallerEqThan(x, smallerSetasList)); });
 							List<Set<UnifyPair>> erased = new ArrayList<>(smallerSetasList); 
-							writeLog("notErased: " + notErased+"\n");
 							erased.removeAll(notErased);
 							nextSetasList.removeAll(erased);
 							

src/main/java/de/dhbwstuttgart/typeinference/unify/interfaces/IFiniteClosure.java

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.typeinference.unify.interfaces;
 
-import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 

src/main/java/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java

@@ -3,8 +3,6 @@ package de.dhbwstuttgart.typeinference.unify.model;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
-import java.lang.reflect.Modifier;
-import java.sql.Array;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -22,12 +20,7 @@ import com.google.common.collect.Ordering;
 
 //PL 18-02-05/18-04-05 Unifier durch Matcher ersetzt
 //muss greater noch ersetzt werden ja erledigt 18--04-05
-import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.parser.SourceLoc;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.unify.MartelliMontanariUnify;
 
 import de.dhbwstuttgart.typeinference.unify.Match;
@@ -36,7 +29,6 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IUnify;
 import de.dhbwstuttgart.util.Pair;
 import org.antlr.v4.runtime.Token;
-import org.apache.commons.io.output.NullWriter;
 
 /**
  * The finite closure for the type unification
@@ -45,8 +37,6 @@ import org.apache.commons.io.output.NullWriter;
 public class FiniteClosure //extends Ordering<UnifyType> //entfernt PL 2018-12-11
 implements IFiniteClosure  {
 
-	final JavaTXCompiler compiler;
-
 	Writer logFile;
 	static Boolean log = false;
 	public void setLogTrue() {
@@ -81,8 +71,7 @@ implements IFiniteClosure  {
 	/**
 	 * Creates a new instance using the inheritance tree defined in the pairs.
 	 */
-	public FiniteClosure(Set<UnifyPair> pairs, Writer logFile, JavaTXCompiler compiler) {
+	public FiniteClosure(Set<UnifyPair> pairs, Writer logFile) {
-		this.compiler = compiler;
 		this.logFile = logFile;
 		this.pairs = new HashSet<>(pairs);
 		inheritanceGraph = new HashMap<UnifyType, Node<UnifyType>>();
@@ -141,10 +130,6 @@ implements IFiniteClosure  {
 		}
 	}
 	
-	public FiniteClosure(Set<UnifyPair> constraints, Writer writer) {
-		this(constraints, writer, null);
-	}
-
 	void testSmaller() {
 		UnifyType tq1, tq2, tq3;
 		tq1 = new ExtendsType(PlaceholderType.freshPlaceholder());
@@ -611,7 +596,7 @@ implements IFiniteClosure  {
 			return new HashSet<>();
 		return strInheritanceGraph.get(typeName).stream().map(x -> x.getContent()).collect(Collectors.toCollection(HashSet::new));
 	}
-
+	
 	@Override
 	public Optional<UnifyType> getLeftHandedType(String typeName) {
 		if(!strInheritanceGraph.containsKey(typeName))
@@ -699,7 +684,7 @@ implements IFiniteClosure  {
 	*/
 	
 	public int compare (UnifyType left, UnifyType right, PairOperator pairop) {
-		try {logFile.write("left: "+ left + " right: " + right + " pairop: " + pairop +"\n");} catch (IOException ie) {}
+		//try {logFile.write("left: "+ left + " right: " + right + " pairop: " + pairop);} catch (IOException ie) {}
 		if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
 			System.out.println("");
 		/*
@@ -756,15 +741,15 @@ implements IFiniteClosure  {
 		HashSet<UnifyPair> hs = new HashSet<>();
 		hs.add(up);
 		Set<UnifyPair> smallerRes = unifyTask.applyTypeUnificationRules(hs, this);
-		
+		/*
-		//if (left.getName().equals("Vector") || right.getName().equals("AbstractList")) 
+		//if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
 		{try { 
 			logFile.write("\nsmallerRes: " + smallerRes);//"smallerHash: " + greaterHash.toString());
 			logFile.flush();
 		}
 		catch (IOException e) {
 			System.err.println("no LogFile");}}
-		
+		*/
 		//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok.
 		Predicate<UnifyPair> delFun = x -> !((x.getLhsType() instanceof PlaceholderType || 
 											 x.getRhsType() instanceof PlaceholderType)
@@ -772,12 +757,6 @@ implements IFiniteClosure  {
 													 ((WildcardType)x.getLhsType()).getWildcardedType().equals(x.getRhsType()))
 											 );
 		long smallerLen = smallerRes.stream().filter(delFun).count();
-		try { 
-			logFile.write("\nsmallerLen: " + smallerLen +"\n");
-			logFile.flush();
-		}
-		catch (IOException e) {
-			System.err.println("no LogFile");}
 		if (smallerLen == 0) return -1;
 		else {
 			up = new UnifyPair(right, left, pairop);
@@ -785,15 +764,15 @@ implements IFiniteClosure  {
 			hs = new HashSet<>();
 			hs.add(up);
 			Set<UnifyPair> greaterRes = unifyTask.applyTypeUnificationRules(hs, this);
-			
+			/*
-			//if (left.getName().equals("Vector") || right.getName().equals("AbstractList")) 
+			//if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
 			{try { 
 				logFile.write("\ngreaterRes: " + greaterRes);//"smallerHash: " + greaterHash.toString());
 				logFile.flush();
 			}
 			catch (IOException e) {
 				System.err.println("no LogFile");}}
-			
+			*/
 			//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok. 
 			long greaterLen = greaterRes.stream().filter(delFun).count();
 			if (greaterLen == 0) return 1;

src/main/java/de/dhbwstuttgart/typeinference/unify/model/FunInterfaceType.java

@@ -1,49 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify.model;
-
-import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
-
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-public class FunInterfaceType extends ReferenceType  {
-    final List<UnifyType> intfArgTypes;
-    final UnifyType intfReturnType;
-    final List<String> generics;
-
-    public FunInterfaceType(String name, TypeParams params, List<UnifyType> intfArgTypes, UnifyType intfReturnType, List<String> generics) {
-        super(name, params);
-        this.intfArgTypes = intfArgTypes;
-        this.intfReturnType = intfReturnType;
-        this.generics = generics;
-    }
-
-    public List<UnifyType> getFunctionalInterfaceTypeArguments(UnifyType t) {
-        if (t instanceof FunNType) {
-            var ret = new ArrayList<UnifyType>();
-            if (t.getTypeParams().size() > 0) {
-                ret.add(t.getTypeParams().get(t.getTypeParams().size() - 1));
-                ret.addAll(Arrays.asList(t.getTypeParams().get()).subList(0, t.getTypeParams().size() - 1));
-            }
-            return ret;
-        }
-
-        var args = new ArrayList<UnifyType>();
-        args.add(intfReturnType);
-        args.addAll(intfArgTypes);
-
-        // TODO There might be a better way of dealing with this
-        var i = 0;
-        for (var generic : generics) {
-            for (var j = 0; j < args.size(); j++) {
-                if (args.get(j).getName().equals(generic))
-                    args.set(j, t.getTypeParams().get(i));
-            }
-            i += 1;
-        }
-
-        return args;
-    }
-}