WIP

revert .gitea/workflows/sonarqube.yml aktualisiert

.gitea/workflows/build_and_test.yml

@@ -1,5 +1,8 @@
 name: Build and Test with Maven
-on: [push]
+on:
+  push:
+    branches-ignore:
+      - master
 
 jobs:
   Build-and-test-with-Maven:
@@ -15,11 +18,11 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
-          java-version: '23'
+          java-version: '25'
           cache: 'maven'
       - name: Compile project
         run: |
           mvn compile
       - name: Run tests
         run: |
-          mvn test
+          mvn test

.gitea/workflows/sonarqube.yml

@@ -0,0 +1,45 @@
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+      types: [opened, synchronize, reopened]
+
+name: SonarQube Scan
+jobs:
+  sonarqube:
+    name: SonarQube Trigger
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checking out
+      uses: actions/checkout@v4
+      with:
+        # Disabling shallow clone is recommended for improving relevancy of reporting
+        fetch-depth: 0
+    - name: Install maven
+      run: |
+        apt update
+        apt install -y maven
+    - name: Install java
+      uses: actions/setup-java@v4
+      with:
+        distribution: 'temurin'
+        java-version: '25'
+        cache: 'maven'
+    - name: Compile project
+      run: |
+        mvn clean dependency:copy-dependencies verify
+    - name: SonarQube Scan
+      uses: SonarSource/sonarqube-scan-action@v5.3.0
+      env:
+        SONAR_HOST_URL: ${{ secrets.SONARQUBE_HOST }}
+        SONAR_TOKEN: ${{ secrets.SONARQUBE_TOKEN }}
+      with:
+        args: >
+          -Dsonar.projectKey=Java-TX
+          -Dsonar.sources=src/main/java
+          -Dsonar.tests=src/test/java
+          -Dsonar.junit.reportPaths=target/test-reports
+          -Dsonar.java.binaries=target/classes
+          -Dsonar.java.libraries=target/dependency/*.jar
+          -Dsonar.coverage.jacoco.xmlReportPaths=target/site/jacoco/jacoco.xml

README.md

@@ -0,0 +1,7 @@
+## Java-TX Compiler
+
+[![Lines of Code](https://gitea.hb.dhbw-stuttgart.de/sonarqube/api/project_badges/measure?project=Java-TX&metric=ncloc&token=sqb_d4a372fca7a6b86441243728a6ea5f88183db5eb)](https://gitea.hb.dhbw-stuttgart.de/sonarqube/dashboard?id=Java-TX)
+[![Coverage](https://gitea.hb.dhbw-stuttgart.de/sonarqube/api/project_badges/measure?project=Java-TX&metric=coverage&token=sqb_d4a372fca7a6b86441243728a6ea5f88183db5eb)](https://gitea.hb.dhbw-stuttgart.de/sonarqube/dashboard?id=Java-TX)
+[![Quality Gate Status](https://gitea.hb.dhbw-stuttgart.de/sonarqube/api/project_badges/measure?project=Java-TX&metric=alert_status&token=sqb_d4a372fca7a6b86441243728a6ea5f88183db5eb)](https://gitea.hb.dhbw-stuttgart.de/sonarqube/dashboard?id=Java-TX)
+
+Work in Progress Java-TX Compiler repository!

independentTest.sh

@@ -10,6 +10,7 @@ mkdir $TDIR
 cd $TDIR
 git clone $REPO .
 git checkout feat/unify-server
+# git checkout 93e1a8787cd94c73f4538f6a348f58613893a584
 # git checkout dad468368b86bdd5a3d3b2754b17617cee0a9107 # 1:55
 # git checkout a0c11b60e8c9d7addcbe0d3a09c9ce2924e9d5c0 # 2:25
 # git checkout 4cddf73e6d6c9116d3e1705c4b27a8e7f18d80c3 # 2:27
@@ -19,15 +20,14 @@ git checkout feat/unify-server
 # git checkout 1391206dfe59263cdb22f93371cfd1dd5465d97f # 1:29
 
 date "+%Y.%m.%d %H:%M:%S"
-
-# mvn clean compile -DskipTests package
-## prefix each stderr line with " | "
-# exec 2> >(trap "" INT TERM; sed 's/^/ | /' >&2)
-# echo -e "\nMatrix test:\n |"
-# time java -jar target/JavaTXcompiler-0.1-jar-with-dependencies.jar resources/bytecode/javFiles/Matrix.jav >/dev/null;
+# sed -i -e 's/source>21/source>23/g' pom.xml
+# sed -i -e 's/target>21/target>23/g' pom.xml
 
 
-mvn clean compile test
+mvn clean compile -DskipTests package
+time java -jar target/JavaTXcompiler-0.1-jar-with-dependencies.jar resources/bytecode/javFiles/Matrix.jav;
+
+# mvn clean compile test
 
 
 echo -e "\nCleanup... "

pom.xml

@@ -12,37 +12,37 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 	<url>http://maven.apache.org</url>
 	<dependencies>
 		<dependency>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
-			<version>4.13.2</version>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter-api</artifactId>
+			<version>5.13.2</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.antlr/antlr4 -->
 		<dependency>
 			<groupId>org.antlr</groupId>
 			<artifactId>antlr4</artifactId>
-			<version>4.11.1</version>
+			<version>4.13.2</version>
 		</dependency>
 		<dependency>
 			<groupId>commons-io</groupId>
 			<artifactId>commons-io</artifactId>
-			<version>2.16.1</version>
+			<version>2.19.0</version>
 		</dependency>
 		<dependency>
 			<groupId>io.github.classgraph</groupId>
 			<artifactId>classgraph</artifactId>
-			<version>4.8.172</version>
+			<version>4.8.180</version>
 		</dependency>
 		<dependency>
 			<groupId>com.google.guava</groupId>
 			<artifactId>guava</artifactId>
-			<version>33.2.0-jre</version>
+			<version>33.4.8-jre</version>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm -->
 		<dependency>
 			<groupId>org.ow2.asm</groupId>
 			<artifactId>asm</artifactId>
-			<version>9.5</version>
+			<version>9.8</version>
 		</dependency>
 		<dependency>
 			<groupId>org.java-websocket</groupId>
@@ -64,28 +64,51 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<artifactId>JColor</artifactId>
 			<version>5.5.1</version>
 		</dependency>
+		<dependency>
+			<groupId>org.jcommander</groupId>
+			<artifactId>jcommander</artifactId>
+			<version>3.0</version>
+		</dependency>
 	</dependencies>
 
 	<build>
 		<plugins>
+			<plugin>
+				<groupId>org.jacoco</groupId>
+				<artifactId>jacoco-maven-plugin</artifactId>
+				<version>0.8.13</version>
+				<executions>
+					<execution>
+						<goals>
+							<goal>prepare-agent</goal>
+						</goals>
+					</execution>
+					<execution>
+						<id>report</id>
+						<phase>prepare-package</phase>
+						<goals>
+							<goal>report</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.11.0</version>
+				<version>3.14.0</version>
 				<configuration>
-					<compilerArgs>--enable-preview</compilerArgs>
-                    <source>23</source>
-                    <target>23</target>
+                    <source>25</source>
+                    <target>25</target>
                 </configuration>
 			</plugin>
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.1.0</version>
+				<version>3.5.3</version>
 				<configuration>
 					<redirectTestOutputToFile>true</redirectTestOutputToFile>
 					<reportsDirectory>${project.build.directory}/test-reports</reportsDirectory>
-					<argLine>--enable-preview</argLine>
+					<argLine>${argLine} --enable-preview</argLine>
 					<trimStackTrace>false</trimStackTrace>
 					<excludes>
 						<exclude>**/JavaTXCompilerTest.java</exclude>
@@ -97,7 +120,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.antlr</groupId>
 				<artifactId>antlr4-maven-plugin</artifactId>
-				<version>4.11.1</version>
+				<version>4.13.2</version>
 				<executions>
 					<execution>
 						<id>antlr</id>
@@ -110,7 +133,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-jar-plugin</artifactId>
-				<version>3.3.0</version>
+				<version>3.4.2</version>
 				<configuration>
 					<archive>
 						<manifest>
@@ -158,4 +181,4 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<url>file:///${project.basedir}/maven-repository/</url>
 		</repository>
 	</distributionManagement>
-</project>
+</project>

resources/bytecode/javFiles/Bug325.jav

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

resources/bytecode/javFiles/Bug363.jav

@@ -0,0 +1,22 @@
+import java.lang.String;
+
+
+public class Bug363 {
+  uncurry (f){
+    return x -> f.apply(x);
+  }
+
+  uncurry (f){
+    return (x, y) -> f.apply(x).apply(y);
+  }
+
+  uncurry (f){
+    return (x, y, z) -> f.apply(x).apply(y).apply(z);
+  }
+
+  public test(){
+    var f = x -> y -> z -> x + y + z;
+    var g = uncurry(f);
+    return g.apply("A", "B", "C"); // Outputs: 6
+  }
+}

resources/bytecode/javFiles/Bug364.jav

@@ -0,0 +1,8 @@
+import java.lang.String;
+
+public class Bug364{
+  public main(){
+    var f = x -> y -> z -> x + y + z;
+    return f.apply("A").apply("B").apply("C");
+  }
+}

resources/bytecode/javFiles/Bug365.jav

@@ -0,0 +1,21 @@
+import java.lang.String;
+import java.lang.Object;
+
+public class Bug365{
+  swap(f){
+    return x -> y -> f.apply(y).apply(x);
+  }
+
+  swap(Fun1$$<String, Fun1$$<String, Fun1$$<String, Object>>> f){
+    return x -> y -> z -> f.apply(z).apply(y).apply(x);
+  }
+
+  public ex1() {
+    var func = x -> y -> z -> x + y + z;
+    return func.apply("A").apply("B").apply("C");
+  }
+  public ex2() {
+    var func = x -> y -> z -> x + y + z;
+    return swap(func).apply("A").apply("B").apply("C");
+  }
+}

resources/bytecode/javFiles/Bug366.jav

@@ -0,0 +1,12 @@
+import java.lang.Integer;
+
+public class Bug366 {
+    public static lambda() {
+        return (a, b) -> a + b;
+    }
+
+    public static test() {
+        var l = lambda();
+        return l.apply(10, 20);
+    }
+}

resources/bytecode/javFiles/Bug371.jav

@@ -0,0 +1,10 @@
+import java.lang.Boolean;
+
+public class Bug371 {
+    static m1(x, y) { return x || y; }
+    static m2(x, y) { return x && y; }
+
+    public static test() {
+        return m2(m1(true, false), true);
+    }
+}

resources/bytecode/javFiles/Bug373.jav

@@ -0,0 +1,17 @@
+import java.lang.Boolean;
+import java.lang.Integer;
+import java.lang.System;
+import java.io.PrintStream;
+import java.lang.Character;
+
+public class Bug373 {
+    public static main() {
+        System.out.println(true);
+        System.out.println(false);
+        System.out.println(1);
+        System.out.println(1l);
+        System.out.println(1.0);
+        System.out.println(1.0f);
+        System.out.println('a');
+    }
+}

resources/bytecode/javFiles/Bug378Id.jav

@@ -0,0 +1,3 @@
+class Bug378Id {
+    id2 = x -> x;
+}

resources/bytecode/javFiles/Bug378Main.jav

@@ -0,0 +1,8 @@
+import Bug378Id;
+import java.lang.Integer;
+
+public class Bug378Main {
+    public static main(args) {
+        var hallo = (new Bug378Id<Integer>().id2).apply(1);
+    }
+}

resources/bytecode/javFiles/Bug379.jav

@@ -0,0 +1,24 @@
+import java.lang.Integer;
+import java.lang.Double;
+import java.lang.System;
+import java.io.PrintStream;
+
+public class Bug379 {
+    public Fun1$$<Double, Double> fact = (x) -> {
+        if (x == 1) {
+            return 1;
+        } else {
+            return x * (fact.apply(x-1));
+        }
+    };
+
+    public getFact(x) {
+        return fact.apply(x);
+    }
+
+    public static void main(x) {
+		var f = new Bug379();
+        var intRes = f.getFact(3);
+		System.out.println(intRes);
+	}
+}

resources/bytecode/javFiles/Bug380.jav

@@ -0,0 +1,12 @@
+sealed interface List<T> permits Cons, Empty {}
+record Cons<T>(T a , List<T> l ) implements List <T> {}
+record Empty<T>() implements List <T> {}
+
+public class Bug380 {
+    public <T> List<T> append(l1, List<T> l2) {
+        return switch ( l1 ) {
+            case Cons(e, rest) -> new Cons<>(e, append(rest, l2)); //::Typ TPH A
+            case Empty() -> l2;//::TPH B
+        };
+    }
+}

resources/bytecode/javFiles/Bug382.jav

@@ -0,0 +1,13 @@
+import java.lang.Runnable;
+import java.lang.String;
+import java.lang.System;
+import java.io.PrintStream;
+import java.lang.Thread;
+
+public class Bug382 {
+    public static main(a) {
+        var f = () -> System.out.println("Hallo Welt!");
+        new Thread(f).run();
+    }
+}
+

resources/bytecode/javFiles/Bug383.jav

@@ -0,0 +1,10 @@
+import java.lang.String;
+import java.lang.System;
+import java.io.PrintStream;
+
+public class Bug383 {
+    public static main(a) {
+        var f = () -> System.out.println("Hello from Thread!");
+        f.apply();
+    }
+}

resources/bytecode/javFiles/Bug389.jav

@@ -0,0 +1,10 @@
+import java.lang.String;
+
+public class Bug389 {
+    public swap(f) {
+        return x -> y -> f.apply(y).apply(x);
+    }
+    public swap(f) {
+        return x -> y -> z -> f.apply(z).apply(x).apply(y);
+    }
+}

resources/bytecode/javFiles/Bug389Main.jav

@@ -0,0 +1,12 @@
+import Bug389;
+import java.util.List;
+import java.lang.String;
+import java.lang.Integer;
+
+public class Bug389Main {
+    public static main(args) {
+        var func = x -> y -> z -> x + y + z;
+        var swap = new Bug389();
+        swap.swap(func).apply(1).apply(2).apply(3);
+    }
+}

resources/bytecode/javFiles/Bug390.jav

@@ -0,0 +1,8 @@
+import java.lang.Math;
+import java.lang.Double;
+
+public class Bug390 {
+    public static main(args) {
+        var pi = Math.PI;
+    }
+}

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/Main.jav

@@ -0,0 +1,14 @@
+import java.lang.Object;
+import java.lang.System;
+import java.lang.Iterable;
+import java.io.PrintStream;
+import java.util.List;
+import java.lang.String;
+
+class Main {
+    static main(args) {
+        for (var arg : args) {
+            System.out.println(arg);
+        }
+    }
+}

resources/bytecode/javFiles/MatrixOP.jav

@@ -4,7 +4,7 @@ import java.lang.Integer;
 import java.lang.Boolean;
 
 public class MatrixOP    extends Vector<Vector<Integer>> {
-   
+
 	MatrixOP () {
     }
 
@@ -36,8 +36,8 @@ public class MatrixOP    extends Vector<Vector<Integer>> {
                 v2.addElement(erg);
                 j++; }
             ret.addElement(v2);
-            i++; 
+            i++;
          }
         return ret;
     };
-}
+}

resources/bytecode/javFiles/OLFun.jav

@@ -4,16 +4,10 @@ import java.lang.Double;
 import java.util.Vector;
 import java.lang.Boolean; 
 
-public class OLFun    {
-
-	//f = x -> {return x + x;};
-	m(f, x) {
-	    x = f.apply(x+x);
-	    return x;
-	}
-
-	m2(y) {
-	   m(x -> x * 2, y);
-	   return;
-	}
+public class OLFun {
+    m(f) {
+        var x;
+        x = f.apply(x + x);
+        return x;
+    }
 }

resources/bytecode/javFiles/OLFun2.jav

@@ -1,13 +0,0 @@
-import java.lang.String;
-import java.lang.Integer;
-import java.lang.Double;
-import java.util.Vector;
-import java.lang.Boolean;
-
-public class OLFun2 {
-
-    x;
-	m(f){
-	    x = f.apply(x + x);
-	}
-}

resources/bytecode/javFiles/PatternMatching.jav

@@ -0,0 +1,24 @@
+import Cons;
+import Empty;
+import List;
+import Pair;
+
+public class PatternMatching {
+    public zip(Cons(x, xs), Cons(y, ys)) {
+        return new Cons<>(new Pair<>(x, y), zip(xs, ys));
+    }
+    public zip(Empty x, Empty y) { return new Empty<>(); }
+
+    /*public zip(Empty x, Cons y) { return new Empty(); }
+    public zip(Cons x, Empty y) { return new Empty(); }
+    public zip(Empty x, Empty y) { return new Empty(); }
+    */
+
+    /*
+    Generiert:
+    Cons zip<T>(Cons(T x, Cons xs), Cons(T y, Cons ys))
+    Cons zip<T>(Cons(T x, Cons xs), Cons(T y, Empty ys))
+    Cons zip<T>(Cons(T x, Empty xs), Cons(T y, Cons ys))
+    Cons zip<T>(Cons(T x, Empty xs), Cons(T y, Empty ys))
+    */
+}

resources/bytecode/javFiles/PatternMatchingJava.jav

@@ -0,0 +1,25 @@
+import java.lang.Object;
+import List;
+import Cons;
+import Empty;
+import Pair;
+
+public class PatternMatchingJava {
+    public <A, B> Cons<Pair<A, B>> zip(Cons<A> a, Cons<B> b) {
+        switch (a) {
+            case Cons(x, Cons xs) -> {
+                switch (b) {
+                    case Cons(y, Cons ys) -> { return new Cons<>(new Pair<>(x, y), zip(xs, ys)); }
+                };
+            }
+            case Cons(x, Empty xs) -> {
+                switch (b) {
+                    case Cons(y, Empty ys) -> { return new Cons<>(new Pair<>(x, y), zip(xs, ys)); }
+                };
+            }
+        };
+    }
+    public <A, B> Empty<Pair<A, B>> zip(Empty<A> a, Empty<B>) {
+        return new Empty<>();
+    }
+}

resources/bytecode/javFiles/PatternMatchingJava2.jav

@@ -0,0 +1,5 @@
+public sealed interface List<T> permits Cons, Empty {}
+
+public record Cons<T>(T a, List<T> l) implements List<T> {}
+public record Empty<T>() implements List<T> {}
+public record Pair<T1, T2>(T1 a, T2 b) {}

resources/bytecode/javFiles/PatternMatchingLiteralStyle.jav

@@ -1,17 +1,18 @@
 import java.lang.Integer;
-import java.lang.Double;
-import java.lang.Number;
 import java.lang.String;
 
-public record R(Number n) {}
+public record R(String n) {}
 
 public class SwitchOverload {
 
-    public f(){}
+    f() { return 10; }
+    g() { return 20; }
 
     public m(r) {
         return switch(r) {
             case R("test") -> f();
+            case R("foo") -> g();
+            case R r -> 0;
         };
     }
 }

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

@@ -39,6 +39,10 @@ public class FunNGenerator {
         public final List<TargetType> inParams;
         public final List<TargetType> realParams;
 
+        public GenericParameters(TargetFunNType funNType) {
+            this(funNType.funNParams(), funNType.returnArguments());
+        }
+
         public GenericParameters(List<TargetType> params, int numReturns) {
             this.realParams = params;
             this.inParams = flattenTypeParams(params);
@@ -71,7 +75,7 @@ public class FunNGenerator {
         if (type == null) return VOID;
         var res = "L" + type.getInternalName();
         if (type instanceof TargetSpecializedType a) {
-            if (a.params().size() > 0) {
+            if (!a.params().isEmpty() && !(a.params().size() == 1 && a.params().getFirst() == null)) {
                 res += "<";
                 for (var param : a.params()) {
                     if (param instanceof TargetGenericType gp) {
@@ -94,7 +98,7 @@ public class FunNGenerator {
     }
 
     private static String applySignature(TargetType a) { return a.toSignature(); }
-    private static String applyNameDescriptor(TargetType a){ return a instanceof TargetGenericType ? "LTPH;" : String.format("%s", applySignature(a)); }
+    private static String applyNameDescriptor(TargetType a){ return a instanceof TargetGenericType ? "LTPH;" : String.format("%s", a.toDescriptor()); }
 
     public static String encodeType(TargetType type) {
         if (type == null) return VOID;
@@ -111,11 +115,12 @@ public class FunNGenerator {
             superFunNMethodSignature.append(String.format("T%s;", argumentGenericBase + currentParameter));
             superFunNMethodDescriptor.append(objectSignature);
         }
-        superFunNClassSignature.append(String.format("%s:%s>%s", returnGeneric, objectSignature, objectSignature));
         if (numReturnTypes > 0) {
+            superFunNClassSignature.append(String.format("%s:%s>%s", returnGeneric, objectSignature, objectSignature));
             superFunNMethodSignature.append(String.format(")T%s;", returnGeneric));
             superFunNMethodDescriptor.append(String.format(")%s", objectSignature));
         } else {
+            superFunNClassSignature = new StringBuilder(objectSignature);
             superFunNMethodSignature.append(")V");
             superFunNMethodDescriptor.append(")V");
         }

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

@@ -1,77 +1,83 @@
 package de.dhbwstuttgart.core;
 
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.Parameter;
+import com.beust.jcommander.ParameterException;
+import de.dhbwstuttgart.server.SocketClient;
 import de.dhbwstuttgart.util.Logger;
+
 import java.io.File;
 import java.io.IOException;
 import java.util.*;
 
-public class ConsoleInterface {
-
-  public static Logger.LogLevel logLevel = Logger.LogLevel.ERROR;
-  public static boolean writeLogFiles = false;
-
-  public static void main(String[] args) throws IOException, ClassNotFoundException {
-    List<File> input = new ArrayList<>();
-    List<File> classpath = new ArrayList<>();
-    String outputPath = null;
-    Iterator<String> it = Arrays.asList(args).iterator();
-    Optional<Integer> serverPort = Optional.empty();
-    Optional<String> unifyServer = Optional.empty();
-
-    if (args.length == 0) {
-      System.out.println("No input files given. Get help with --help");
-      System.exit(1);
-    } else if (args.length == 1 && args[0].equals("--help")) {
-      System.out.println("Usage: javatx [OPTION]... [FILE]...\n" +
-        "\t-cp\tSet Classpath\n" +
-        "\t-d\tSet destination directory\n" +
-        "\t[--server-mode <port>]\n" +
-        "\t[--unify-server <url>]\n" +
-        "\t[--write-logs]\n" +
-        "\t[-v|-vv-|-vvv]");
-      System.exit(1);
-    }
-    while (it.hasNext()) {
-      String arg = it.next();
-      if (arg.equals("-d")) {
-        outputPath = it.next();
-      } else if (arg.startsWith("-d")) {
-        outputPath = arg.substring(2);
-      } else if (arg.equals("-cp") || arg.equals("-classpath")) {
-        String[] cps = it.next().split(":");
-        for (String cp : cps) {
-          classpath.add(new File(cp));
-        }
-      } else if (arg.equals("--server-mode")) {
-        serverPort = Optional.of(Integer.parseInt(it.next()));
-      } else if (arg.equals("--unify-server")) {
-        unifyServer = Optional.of(it.next());
-      } else if (arg.equals("--write-logs")) {
-        ConsoleInterface.writeLogFiles = true;
-      } else if (arg.startsWith("-v")) {
-        logLevel = switch (arg) {
-          case "-v" -> Logger.LogLevel.WARNING;
-          case "-vv" -> Logger.LogLevel.INFO;
-          case "-vvv" -> Logger.LogLevel.DEBUG;
-          default -> throw new IllegalArgumentException("Argument " + arg + " is not a valid verbosity level");
-        };
-      } else {
-        input.add(new File(arg));
-      }
-    }
-
-    if (serverPort.isPresent()) {
-      if (unifyServer.isPresent()) throw new RuntimeException("Cannot use unifyServer when in server mode!");
-
-      JavaTXServer server = new JavaTXServer(serverPort.get());
-      server.listen();
-    }
-    else {
-      JavaTXCompiler compiler = new JavaTXCompiler(input, classpath, outputPath != null ? new File(outputPath) : null, unifyServer);
-      //compiler.typeInference();
-      compiler.generateBytecode();
-    }
-  }
-
-
+class Args {
+    @Parameter(description = "Set destination directory", names = "-d")
+    File outputPath;
+    @Parameter(description = "Set class path", names = {"-cp", "-classpath"})
+    String classpath;
+    @Parameter(description = "[FILE]...")
+    List<File> input;
+    @Parameter(description = "Server mode", names = "--server-port")
+    Integer serverPort;
+    @Parameter(description = "Unify server url", names = "--unify-server")
+    String serverUrl;
+    @Parameter(description = "Write logs", names = "--write-logs")
+    boolean writeLogs = false;
+    @Parameter(names = "-v", description = "Verbosity level")
+    int verbosity = 0;
+    @Parameter(names = "--infer-together", description = "Runs the type inference on all input files together instead of sequentially")
+    boolean inferTogether = false;
+    @Parameter(names = "--help", help = true)
+    boolean help;
+}
+
+public class ConsoleInterface {
+    public static Logger.LogLevel logLevel = Logger.LogLevel.ERROR;
+    public static boolean writeLogFiles = false;
+    public static boolean inferTogether = false;
+    public static Optional<String> unifyServerUrl = Optional.empty();
+
+	public static void main(String[] argv) throws IOException, ClassNotFoundException {
+        var args = new Args();
+        var builder = JCommander.newBuilder().addObject(args).build();
+        builder.setProgramName("javatx");
+        try {
+            builder.parse(argv);
+            if (args.help) {
+                builder.usage();
+                return;
+            }
+        } catch (ParameterException e) {
+            System.err.println(e.getMessage());
+            System.err.println();
+            builder.usage();
+            System.exit(1);
+        }
+
+        inferTogether = args.inferTogether;
+        unifyServerUrl = Optional.ofNullable(args.serverUrl);
+        writeLogFiles = args.writeLogs;
+        switch (args.verbosity) {
+            case 1 -> logLevel = Logger.LogLevel.WARNING;
+            case 2 -> logLevel = Logger.LogLevel.INFO;
+            case 3 -> logLevel = Logger.LogLevel.DEBUG;
+            default -> logLevel = Logger.LogLevel.ERROR;
+        }
+
+
+        if (args.serverPort != null) {
+            if (unifyServerUrl.isPresent()) throw new RuntimeException("Cannot use unifyServer when in server mode!");
+            JavaTXServer server = new JavaTXServer(args.serverPort);
+            server.listen();
+        } else {
+            if (args.input == null) {
+                System.err.println("No input files given. Get help with --help");
+                System.exit(1);
+            }
+            List<File> classpath = args.classpath == null ? List.of() : Arrays.stream(args.classpath.split(File.pathSeparator)).map(File::new).toList();
+            JavaTXCompiler compiler = new JavaTXCompiler(args.input, classpath, args.outputPath, inferTogether);
+            compiler.generateBytecode();
+            SocketClient.closeIfOpen();
+        }
+	}
 }

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

@@ -2,17 +2,24 @@
 package de.dhbwstuttgart.core;
 
 import de.dhbwstuttgart.bytecode.Codegen;
+import de.dhbwstuttgart.bytecode.FunNGenerator;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
 import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.DebugException;
+import de.dhbwstuttgart.languageServerInterface.model.LanguageServerTransferObject;
 import de.dhbwstuttgart.parser.JavaTXParser;
 import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.antlr.Java17Parser;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.antlr.Java17Parser.SourceFileContext;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.packet.SetAutoclosePacket;
+import de.dhbwstuttgart.server.packet.UnifyRequestPacket;
+import de.dhbwstuttgart.server.packet.UnifyResultPacket;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
@@ -57,6 +64,7 @@ import de.dhbwstuttgart.util.Logger;
 import java.io.*;
 import java.lang.reflect.Modifier;
 import java.nio.file.Path;
+import java.sql.Array;
 import java.util.*;
 import java.util.Map.Entry;
 import java.util.function.Function;
@@ -69,11 +77,13 @@ public class JavaTXCompiler {
 	// do not use this in any code, that can be executed serverside!
 	public static PlaceholderRegistry defaultClientPlaceholderRegistry = new PlaceholderRegistry();
 	public static Logger defaultLogger = new Logger();
+	private final boolean inferTogether;
 
 	// public static JavaTXCompiler INSTANCE;
 	final CompilationEnvironment environment;
 	Boolean resultmodel = true;
 	public final Map<File, SourceFile> sourceFiles = new HashMap<>();
+	public final Set<JavaClassName> input = new HashSet<>();
 
 	public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
 	public final DirectoryClassLoader classLoader;
@@ -81,42 +91,72 @@ public class JavaTXCompiler {
 	public final List<File> classPath;
 	private final File outputPath;
 
-	private final Optional<String> unifyServer;
+	public final Map<String, FunNGenerator.GenericParameters> usedFunN = new HashMap<>();
+	public final Set<Integer> usedFunNSuperTypes = new HashSet<>();
+
+	private final Map<JavaClassName, ClassOrInterface> loadedClasses = new HashMap<>();
+	public Map<String, byte[]> auxiliaries = new HashMap<>();
 
 	public DirectoryClassLoader getClassLoader() {
 		return classLoader;
 	}
 
 	public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
-		this(Arrays.asList(sourceFile), List.of(), new File("."), Optional.empty());
+		this(Collections.singletonList(sourceFile), List.of(), new File("."), ConsoleInterface.inferTogether);
 	}
 
 	public JavaTXCompiler(List<File> sourceFiles) throws IOException, ClassNotFoundException {
-		this(sourceFiles, List.of(), new File("."), Optional.empty());
+		this(sourceFiles, List.of(), new File("."), ConsoleInterface.inferTogether);
 	}
 
-	public JavaTXCompiler(List<File> sources, List<File> contextPath, File outputPath) throws IOException, ClassNotFoundException {
-		this(sources, contextPath, outputPath, Optional.empty());
-	}
-
-	public JavaTXCompiler(List<File> sources, List<File> contextPath, File outputPath, Optional<String> unifyServer) throws IOException, ClassNotFoundException {
+	public JavaTXCompiler(List<File> sources, List<File> contextPath, File outputPath, boolean inferTogether) throws IOException, ClassNotFoundException {
 		// ensure new default placeholder registry for tests
 		defaultClientPlaceholderRegistry = new PlaceholderRegistry();
+		this.inferTogether = inferTogether;
 
-		this.unifyServer = unifyServer;
 		var path = new ArrayList<>(contextPath);
 		if (contextPath.isEmpty()) {
 			// When no contextPaths are given, the working directory is the sources root
 			path.add(new File(System.getProperty("user.dir")));
 		}
 		if (outputPath != null) path.add(outputPath);
-		classLoader = new DirectoryClassLoader(path, ClassLoader.getSystemClassLoader());
+		classLoader = new DirectoryClassLoader(path, ClassLoader.getSystemClassLoader().getParent());
 		environment = new CompilationEnvironment(sources, classLoader);
 		classPath = path;
 		this.outputPath = outputPath;
 
-		for (File s : sources) {
-			parse(s);
+		// TODO This should maybe be moved elsewhere
+		var treeList = new ArrayList<SourceFileContext>(sources.size());
+		for (var s : sources) {
+			var tree = (Java17Parser.SrcfileContext) JavaTXParser.parse(s);
+			treeList.add(tree);
+			// Find defined classes
+			var pkgName = tree.packageDeclaration() != null ? tree.packageDeclaration().qualifiedName().getText(): "";
+			for (var ctx : tree.classOrInterface()) {
+				if (ctx instanceof Java17Parser.NoclassorinterfaceContext) continue;
+				var classContext = (Java17Parser.ClassorinterfacedeclContext) ctx;
+				String name = null;
+				Java17Parser.GenericDeclarationListContext decl = null;
+				if (classContext.classDeclaration() != null) {
+					name = classContext.classDeclaration().identifier().getText();
+					decl = classContext.classDeclaration().genericDeclarationList();
+				} else if (classContext.recordDeclaration() != null) {
+					name = classContext.recordDeclaration().identifier().getText();
+					decl = classContext.recordDeclaration().genericDeclarationList();
+				} else if (classContext.interfaceDeclaration() != null) {
+					name = classContext.interfaceDeclaration().identifier().getText();
+					decl = classContext.interfaceDeclaration().genericDeclarationList();
+				}
+
+				var numberOfGenerics = decl == null ? 0 : decl.genericTypeVar().size();
+				var className = pkgName + (!pkgName.isEmpty() ? "." : "") + name;
+				classRegistry.addName(className, numberOfGenerics);
+				input.add(classRegistry.getName(className));
+			}
+		}
+
+		for (var i = 0; i < sources.size(); i++) {
+			parse(treeList.get(i), sources.get(i));
 		}
 		// INSTANCE = this;
 	}
@@ -126,21 +166,26 @@ public class JavaTXCompiler {
 	}
 
 	public ClassOrInterface getClass(JavaClassName name) {
-		if (loadedClasses.containsKey(name)) return loadedClasses.get(name).cif();
+		if (loadedClasses.containsKey(name)) return loadedClasses.get(name);
 		for (var sf : sourceFiles.values()) {
 			for (var clazz : sf.KlassenVektor) {
 				if (clazz.getClassName().equals(name)) return clazz;
 			}
 		}
+		if (input.contains(name)) return null;
 		try {
 			var clazz = classLoader.loadClass(name.toString());
-			if (clazz != null)
-				return ASTFactory.createClass(clazz);
+			ClassOrInterface cif = null;
+			if (clazz != null) {
+				cif = ASTFactory.createClass(clazz);
+				loadedClasses.put(name, cif);
+			}
+			return cif;
 		} catch (ClassNotFoundException ignored) {}
 		return null;
 	}
 
-	public ConstraintSet<Pair> getConstraints(File sourceFile) throws ClassNotFoundException, IOException {
+	public Set<ClassOrInterface> getAvailableClasses(File sourceFile) throws ClassNotFoundException, IOException {
 		Set<ClassOrInterface> allClasses = new HashSet<>();// environment.getAllAvailableClasses();
 		ClassOrInterface objectClass = ASTFactory.createClass(Object.class);
 		var recordClass = ASTFactory.createClass(Record.class);
@@ -166,7 +211,7 @@ public class JavaTXCompiler {
 		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();
+				var cif = loadedClasses.get(clazz.getClassName());
 				allClasses.add(cif);
 				isCached = true;
 			}
@@ -179,7 +224,13 @@ public class JavaTXCompiler {
 
 		allClasses.addAll(sf.KlassenVektor);
 
-		TYPE ty = new TYPE(sf, allClasses);
+		return allClasses;
+	}
+
+	public ConstraintSet<Pair> getConstraints(File sourceFile) throws ClassNotFoundException, IOException {
+		var sf = sourceFiles.get(sourceFile);
+		var allClasses = getAvailableClasses(sourceFile);
+		TYPE ty = new TYPE(new HashSet<>(sf.availableClasses), allClasses);
 		var constraints = ty.getConstraints();
 		return constraints;
 	}
@@ -199,8 +250,9 @@ public class JavaTXCompiler {
 					try {
 						var className = cl.getSuperClass().getName().toString();
 						superclass = ASTFactory.createClass(classLoader.loadClass(className));
-					} catch (ClassNotFoundException ignored) {}
-					// throw new ClassNotFoundException("");
+					} catch (ClassNotFoundException e) {
+						throw new RuntimeException(e);
+					}
 				}
 			}
 
@@ -229,13 +281,18 @@ public class JavaTXCompiler {
 
 	private Set<ClassOrInterface> getAvailableClasses(JavaClassName name) throws ClassNotFoundException {
 		Set<ClassOrInterface> allClasses = new HashSet<>();
-		var clazz = loadJavaTXClass(name);
-		if (clazz == null) {
-			ClassOrInterface importedClass = ASTFactory.createClass(classLoader.loadClass(name.toString()));
-			allClasses.add(importedClass);
-		} else {
-			allClasses.add(clazz);
+		if (input.contains(name)) {
+			for (var sf : sourceFiles.values()) {
+				for (var cif : sf.KlassenVektor) {
+					if (cif.getClassName().equals(name)) {
+						allClasses.add(cif);
+						return allClasses;
+					}
+				}
+			}
 		}
+		ClassOrInterface importedClass = ASTFactory.createClass(classLoader.loadClass(name.toString()));
+		allClasses.add(importedClass);
 		return allClasses;
 	}
 
@@ -362,25 +419,30 @@ public class JavaTXCompiler {
 	}
 
 	public List<ResultSet> typeInference(File file) throws ClassNotFoundException, IOException {
-		var sf = sourceFiles.get(file);
-		Set<ClassOrInterface> allClasses = new HashSet<>();// environment.getAllAvailableClasses();
-		allClasses.addAll(getAvailableClasses(sf));
-		allClasses.addAll(sf.getClasses());
-		var newClasses = CompilationEnvironment.loadDefaultPackageClasses(sf.getPkgName(), file, this).stream().map(ASTFactory::createClass).collect(Collectors.toSet());
-		for (var clazz : newClasses) {
-			// Don't load classes that get recompiled
-			if (sf.getClasses().stream().anyMatch(nf -> nf.getClassName().equals(clazz.getClassName())))
-				continue;
-			if (allClasses.stream().noneMatch(old -> old.getClassName().equals(clazz.getClassName())))
-				allClasses.add(clazz);
+		return typeInference(List.of(file));
+	}
+
+	public List<ResultSet> typeInference(List<File> files) throws ClassNotFoundException, IOException {
+		Set<ClassOrInterface> allClasses = new HashSet<>();
+
+		var ressf = new ArrayList<SourceFile>();
+		var definedClasses = new HashSet<ClassOrInterface>();
+		for (var file : files) {
+			var sf = sourceFiles.get(file);
+			definedClasses.addAll(sf.KlassenVektor);
+			ressf.add(sf);
+			allClasses.addAll(getAvailableClasses(file));
+			allClasses.addAll(sf.availableClasses);
 		}
 
-		final ConstraintSet<Pair> cons = getConstraints(file);
+		TYPE ty = new TYPE(definedClasses, allClasses);
+		var cons = ty.getConstraints();
+
 		Set<Set<UnifyPair>> results = new HashSet<>();
 		PlaceholderRegistry placeholderRegistry = new PlaceholderRegistry();
 
 		var logFolder = new File(System.getProperty("user.dir") + "/logFiles/");
-		if (ConsoleInterface.writeLogFiles && !logFolder.mkdirs()) throw new RuntimeException("Could not creat directoy for log files: " + logFolder);
+		if (ConsoleInterface.writeLogFiles && !logFolder.mkdirs()) throw new RuntimeException("Could not create directory for log files: " + logFolder);
 		Writer logFile = ConsoleInterface.writeLogFiles ? new FileWriter(new File(logFolder, "log_" + sourceFiles.keySet().iterator().next().getName())) : new OutputStreamWriter(new NullOutputStream());
 		Logger logger = new Logger(logFile, "TypeInference");
 
@@ -398,86 +460,175 @@ public class JavaTXCompiler {
 
 		};
 
-		logger.debug("Unify:" + unifyCons.toString());
-		logger.info("Unify:" + unifyCons.toString());
-		unifyCons = unifyCons.map(distributeInnerVars);
-		logger.debug("\nUnify_distributeInnerVars: " + unifyCons.toString());
-		// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
-		logger.debug("FC:\\" + finiteClosure.toString() + "\n");
-		logger.debug(ASTTypePrinter.print(sf));
-		logger.info(ASTTypePrinter.print(sf));
-		// logFile.flush();
-		logger.info("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
-		Set<PlaceholderType> varianceTPHold;
-		Set<PlaceholderType> varianceTPH = new HashSet<>();
-		varianceTPH = varianceInheritanceConstraintSet(unifyCons);
+    logger.debug("Unify:" + unifyCons.toString());
+    logger.info("Unify:" + unifyCons.toString());
+    unifyCons = unifyCons.map(distributeInnerVars);
+    logger.debug("\nUnify_distributeInnerVars: " + unifyCons.toString());
+    // Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
+    logger.debug("FC:\\" + finiteClosure.toString() + "\n");
+	for (var sf : ressf) logger.info(ASTTypePrinter.print(sf));
+    // logFile.flush();
+    List<UnifyPair> andConstraintsSorted = unifyCons.getUndConstraints().stream()
+        .sorted(Comparator.comparing(UnifyPair::getPairOp).thenComparing(UnifyPair::getLhsType, Comparator.comparing(UnifyType::getName)))
+        .collect(Collectors.toList());
+
+    logger.info(andConstraintsSorted);
+
+    Set<PlaceholderType> varianceTPHold;
+    Set<PlaceholderType> varianceTPH = new HashSet<>();
+    varianceTPH = varianceInheritanceConstraintSet(unifyCons);
 
 		/*
 		 * PL 2018-11-07 wird in varianceInheritanceConstraintSet erledigt do { //PL 2018-11-05 Huellenbildung Variance auf alle TPHs der Terme auf der jeweiligen //anderen Seite übertragen varianceTPHold = new HashSet<>(varianceTPH); varianceTPH = varianceInheritanceConstraintSet(unifyCons); unifyCons.map( y -> { if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) { if (((PlaceholderType)y.getLhsType()).getVariance() != 0 &&
 		 * ((PlaceholderType)y.getRhsType()).getVariance() == 0) { ((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType( )).getVariance()); } if (((PlaceholderType)y.getLhsType()).getVariance() == 0 && ((PlaceholderType)y.getRhsType()).getVariance() != 0) { ((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType( )).getVariance()); } } return y; } ); } while (!varianceTPHold.equals(varianceTPH));
 		 */
 
-		// Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
-		// logFile, log);
-		// Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
-		List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints()// .stream().map(x -> {
-		/*
-		 * Set<Set<UnifyPair>> ret = new HashSet<>(); for (Constraint<UnifyPair> y : x) { ret.add(new HashSet<>(y)); } return ret; }).collect(Collectors.toCollection(ArrayList::new))
-		 */;
+    // Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
+    // logFile, log);
+    // Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
+    List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints()// .stream().map(x -> {
+    /*
+     * Set<Set<UnifyPair>> ret = new HashSet<>(); for (Constraint<UnifyPair> y : x) { ret.add(new HashSet<>(y)); } return ret; }).collect(Collectors.toCollection(ArrayList::new))
+     */;
+    if (ConsoleInterface.unifyServerUrl.isPresent()) {
+        UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
+        UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, placeholderRegistry);
+        SocketFuture<UnifyResultPacket> future = SocketClient.execute(
+          UnifyRequestPacket.create(finiteClosure, cons, unifyCons, context.placeholderRegistry())
+        );
+        SocketClient.execute(SetAutoclosePacket.create());
+        return future.get().getResultSet(context);
+    }
+    else if (resultmodel) {
+        /* UnifyResultModel Anfang */
+        UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
+        UnifyResultListenerImpl li = new UnifyResultListenerImpl();
+        urm.addUnifyResultListener(li);
+		UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, placeholderRegistry);
+		TypeUnify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
+        var finalResults = li.getResults().stream().sorted().toList();
+        int i = 0;
+        logger.info("RESULT Final: ");
+        for (var result : finalResults){
+          logger.info("Result: " + i++);
+          logger.info(result.getSortedResults());
+        }
+        logger.info("RES_FINAL: " + li.getResults().toString() + "\n");
+        return li.getResults();
+    }
+    /* UnifyResultModel End */
+    else {
+        // Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(),
+        // oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons,
+        // finiteClosure));
+        UnifyContext context = new UnifyContext(logger, false, new UnifyResultModel(cons, finiteClosure), usedTasks, placeholderRegistry);
+        Set<Set<UnifyPair>> result = TypeUnify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
+        logger.info("RESULT: " + result);
+        results.addAll(result);
 
-		if (unifyServer.isPresent()) {
-			UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
-			UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, placeholderRegistry);
-			SocketClient socketClient = new SocketClient(unifyServer.get());
-			return socketClient.execute(finiteClosure, cons, unifyCons, context);
-		}
-		else if (resultmodel) {
-			/* UnifyResultModel Anfang */
-			UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
-			UnifyResultListenerImpl li = new UnifyResultListenerImpl();
-			urm.addUnifyResultListener(li);
-			UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, placeholderRegistry);
-			TypeUnify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
-			logger.info("RESULT Final: " + li.getResults());
-			logger.info("Constraints for Generated Generics: " + " ???");
-			logFile.write("RES_FINAL: " + li.getResults().toString() + "\n");
-			// logFile.flush();
-			return li.getResults();
-		}
-		/* UnifyResultModel End */
-		else {
-			// Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(),
-			// oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons,
-			// finiteClosure));
-			UnifyContext context = new UnifyContext(logger, false, new UnifyResultModel(cons, finiteClosure), usedTasks, placeholderRegistry);
-			Set<Set<UnifyPair>> result = TypeUnify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
-			logger.info("RESULT: " + result);
-			logFile.write("RES: " + result.toString() + "\n");
-			// logFile.flush();
-			results.addAll(result);
-
-			results = results.stream().map(x -> {
-				Optional<Set<UnifyPair>> res = new RuleSet(placeholderRegistry).subst(x.stream().map(y -> {
-					if (y.getPairOp() == PairOperator.SMALLERDOTWC)
-						y.setPairOp(PairOperator.EQUALSDOT);
-					return y; // alle Paare a <.? b erden durch a =. b ersetzt
-				}).collect(Collectors.toCollection(HashSet::new)));
-				if (res.isPresent()) {// wenn subst ein Erg liefert wurde was veraendert
-					return new TypeUnifyTask(context).applyTypeUnificationRules(res.get(), finiteClosure);
-				} else
-					return x; // wenn nichts veraendert wurde wird x zurueckgegeben
-			}).collect(Collectors.toCollection(HashSet::new));
-			logger.info("RESULT Final: " + results);
-			logger.info("Constraints for Generated Generics: " + " ???");
-			logger.debug("RES_FINAL: " + results.toString() + "\n");
-			// logFile.flush();
-			logger.debug("PLACEHOLDERS: " + placeholderRegistry);
-			// logFile.flush();
+        results = results.stream().map(x -> {
+          Optional<Set<UnifyPair>> res = new RuleSet(placeholderRegistry).subst(x.stream().map(y -> {
+            if (y.getPairOp() == PairOperator.SMALLERDOTWC)
+              y.setPairOp(PairOperator.EQUALSDOT);
+            return y; // alle Paare a <.? b erden durch a =. b ersetzt
+          }).collect(Collectors.toCollection(HashSet::new)));
+          if (res.isPresent()) {// wenn subst ein Erg liefert wurde was veraendert
+            return new TypeUnifyTask(context).applyTypeUnificationRules(res.get(), finiteClosure);
+          } else
+            return x; // wenn nichts veraendert wurde wird x zurueckgegeben
+        }).collect(Collectors.toCollection(HashSet::new));
+        logger.info("RESULT Final: " + results);
+        logger.info("Constraints for Generated Generics: " + " ???");
+        logger.debug("RES_FINAL: " + results.toString() + "\n");
+        // logFile.flush();
+        logger.debug("PLACEHOLDERS: " + placeholderRegistry);
+        // logFile.flush();
 		}
 
 		return results.stream().map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons), placeholderRegistry)))).collect(Collectors.toList());
 	}
 
+	/**
+	 * TEMPORARY - Only for Language Server Usage
+	 */
+	public LanguageServerTransferObject getResultSetAndAbstractSyntax(File file) throws IOException, ClassNotFoundException {
+		var sf = sourceFiles.get(file);
+		if(sf == null){
+			sf = sourceFiles.values().stream().findFirst().get();
+		}
+		Set<ClassOrInterface> allClasses = new HashSet<>();
+		allClasses.addAll(getAvailableClasses(sf));
+		allClasses.addAll(sf.getClasses());
+		var newClasses = CompilationEnvironment.loadDefaultPackageClasses(sf.getPkgName(), file, this).stream().map(ASTFactory::createClass).collect(Collectors.toSet());
+		for (var clazz : newClasses) {
+			// Don't load classes that get recompiled
+			if (sf.getClasses().stream().anyMatch(nf -> nf.getClassName().equals(clazz.getClassName())))
+				continue;
+			if (allClasses.stream().noneMatch(old -> old.getClassName().equals(clazz.getClassName())))
+				allClasses.add(clazz);
+		}
+
+		final ConstraintSet<Pair> cons = getConstraints(file);
+		Set<Set<UnifyPair>> results = new HashSet<>();
+
+		Writer logFile = new OutputStreamWriter(new NullOutputStream());
+		Logger logger = new Logger(logFile, "TypeInferenceAsync");
+		UnifyContext context = new UnifyContext(logger, false, null, usedTasks, defaultClientPlaceholderRegistry);
+		try {
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logger, classLoader, this, context.placeholderRegistry());
+			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons, context.placeholderRegistry());
+			Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
+				UnifyType lhs, rhs;
+				if (((lhs = x.getLhsType()) instanceof PlaceholderType) && ((rhs = x.getRhsType()) instanceof PlaceholderType) && (((PlaceholderType) lhs).isInnerType() || ((PlaceholderType) rhs).isInnerType())) {
+					((PlaceholderType) lhs).setInnerType(true);
+					((PlaceholderType) rhs).setInnerType(true);
+				}
+				return x;
+
+			};
+
+
+			unifyCons = unifyCons.map(distributeInnerVars);
+			Set<PlaceholderType> varianceTPHold;
+			Set<PlaceholderType> varianceTPH = new HashSet<>();
+			varianceTPH = varianceInheritanceConstraintSet(unifyCons);
+
+			List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints();
+
+			if (resultmodel) {
+				/* UnifyResultModel Anfang */
+				UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
+				UnifyResultListenerImpl li = new UnifyResultListenerImpl();
+				urm.addUnifyResultListener(li);
+				TypeUnify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
+				generateBytecode(sf, li.getResults());
+				return new LanguageServerTransferObject(li.getResults(), sf, ASTTypePrinter.print(sf), generatedGenerics);
+			}
+			/* UnifyResultModel End */
+			else {
+				Set<Set<UnifyPair>> result = TypeUnify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
+				results.addAll(result);
+
+				results = results.stream().map(x -> {
+					Optional<Set<UnifyPair>> res = new RuleSet(context.placeholderRegistry()).subst(x.stream().map(y -> {
+						if (y.getPairOp() == PairOperator.SMALLERDOTWC)
+							y.setPairOp(PairOperator.EQUALSDOT);
+						return y; // alle Paare a <.? b erden durch a =. b ersetzt
+					}).collect(Collectors.toCollection(HashSet::new)));
+					if (res.isPresent()) {// wenn subst ein Erg liefert wurde was veraendert
+						return new TypeUnifyTask(context).applyTypeUnificationRules(res.get(), finiteClosure);
+					} else
+						return x; // wenn nichts veraendert wurde wird x zurueckgegeben
+				}).collect(Collectors.toCollection(HashSet::new));
+			}
+		} catch (ClassNotFoundException e) {
+		}
+		generateBytecode(sf, results.stream().map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons), context.placeholderRegistry())))).collect(Collectors.toList()));
+		return new LanguageServerTransferObject(results.stream().map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons), context.placeholderRegistry())))).collect(Collectors.toList()), sf, ASTTypePrinter.print(sf), generatedGenerics);
+	}
+
+
+
 	/**
 	 * Vererbt alle Variancen bei Paaren (a <. theta) oder (Theta <. a) wenn a eine Variance !=0 hat auf alle Typvariablen in Theta.
 	 * 
@@ -535,75 +686,36 @@ 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);
+	private void parse(SourceFileContext tree, File sourceFile) throws IOException, java.lang.ClassNotFoundException {
 		SyntaxTreeGenerator generator = new SyntaxTreeGenerator(this, classRegistry, new GenericsRegistry(null), sourceFile.getName());
+		environment.addClassesToRegistry(classRegistry, tree, sourceFile, this);
 		var classes = new ArrayList<ClassOrInterface>();
 		var sf = new SourceFile("", classes, generator.imports);
 		addSourceFile(sourceFile, sf);
 		generator.convert(classes, tree, environment.packageCrawler);
 		sf.setPackageName(generator.pkgName);
 		sf.imports.addAll(generator.imports);
-		return sf;
-	}
-
-	/**
-	 * When an import tries to import a JavaTX class it first looks it up in the cache and
-	 * 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) {
-		var file = findFileForClass(name);
-		if (file != null) {
-			if (loadedClasses.containsKey(name)) return loadedClasses.get(name).cif();
-			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);
-				addSourceFile(file, sf);
-				generator.convert(classes, tree, environment.packageCrawler);
-				sf.setPackageName(generator.pkgName);
-				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;
-	}
-
-	public File findFileForClass(JavaClassName name) {
-		var packageName = name.getPackageName();
-		var className = name.getClassName().split("\\.")[0];
-		for (var cp : classPath) {
-			var file = new File(cp, packageName.replaceAll("\\.", "/") + "/" + className + ".jav");
-			if (file.exists()) return file;
-		}
-		return null;
 	}
 
 	public void generateBytecode() throws ClassNotFoundException, IOException {
-		for (var file : sourceFiles.keySet()) {
-			var sf = sourceFiles.get(file);
-			if (sf.isGenerated()) continue;
-			var classes = generateBytecode(file);
-			sf.setGenerated();
-			writeClassFile(classes, outputPath == null ? file.getParentFile() : outputPath, outputPath == null);
+		if (inferTogether) {
+			var files = sourceFiles.keySet().stream().toList();
+			var typeinferenceResult = this.typeInference(files);
+			for (var file : files) {
+				var sf = sourceFiles.get(file);
+				if (sf.isGenerated()) continue;
+				var classes = generateBytecode(sf, typeinferenceResult);
+				sf.setGenerated();
+				writeClassFile(classes, outputPath == null ? file.getParentFile() : outputPath, outputPath == null);
+			}
+		} else {
+			for (var file : sourceFiles.keySet()) {
+				var sf = sourceFiles.get(file);
+				if (sf.isGenerated()) continue;
+				var classes = generateBytecode(file);
+				sf.setGenerated();
+				writeClassFile(classes, outputPath == null ? file.getParentFile() : outputPath, outputPath == null);
+			}
 		}
 	}
 
@@ -648,12 +760,12 @@ public class JavaTXCompiler {
 			var codegen = new Codegen(converter.convert(clazz), this, converter);
 			var code = codegen.generate();
 			generatedClasses.put(clazz.getClassName(), code);
-			converter.auxiliaries.forEach((name, source) -> {
-				generatedClasses.put(new JavaClassName(name), source);
-			});
 		}
 		generatedGenerics.put(sf, converter.javaGenerics());
 		converter.generateFunNTypes();
+		auxiliaries.forEach((name, source) -> {
+			generatedClasses.put(new JavaClassName(name), source);
+		});
 		return generatedClasses;
 	}
 
@@ -669,7 +781,7 @@ public class JavaTXCompiler {
 			output = new FileOutputStream(outputFile);
 			output.write(bytecode);
 			output.close();
-			defaultLogger.info(name + ".class file generated");
+			defaultLogger.success(name + ".class file generated");
 		}
 	}
 

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

@@ -10,10 +10,10 @@ public class JavaTXServer {
 
   public JavaTXServer(int port) {
     this.socketServer = new SocketServer(port);
-    isRunning = true;
   }
 
   public void listen() {
+    isRunning = true;
     socketServer.start();
   }
 

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

@@ -1,13 +0,0 @@
-package de.dhbwstuttgart.environment;
-
-public class ByteArrayClassLoader extends ClassLoader implements IByteArrayClassLoader {
-    @Override
-    public Class _defineClass(String name, byte[] code, int i, int length) throws ClassFormatError {
-        return defineClass(name, code, i, length);
-    }
-
-    @Override
-    public Class<?> findClass(String name) throws ClassNotFoundException {
-        return super.findClass(name);
-    }
-}

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

@@ -8,6 +8,7 @@ import java.util.*;
 
 import com.google.common.collect.Lists;
 import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 
@@ -30,7 +31,7 @@ public class CompilationEnvironment {
 	public final PackageCrawler packageCrawler;
 
 	/**
-	 * Imitiert die Environment beim Aufruf des JavaCompilers auf einer Menge von java-Dateien Die Environment enth�lt automatisch die Java Standard Library
+	 * Imitiert die Environment beim Aufruf des JavaCompilers auf einer Menge von java-Dateien Die Environment enthält automatisch die Java Standard Library
 	 * 
 	 * @param sourceFiles die zu kompilierenden Dateien
 	 */
@@ -87,6 +88,8 @@ public class CompilationEnvironment {
 		if (files != null)
 			for (File classFile : files) {
 				String className = classFile.getName().substring(0, classFile.getName().length() - 6);
+				// Don't load class if its defined in the input
+				if (compiler.input.contains(new JavaClassName(className))) continue;
 				if (className.matches("Fun\\d+\\$\\$.*"))
 					continue;
 				var name = packageName;

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

@@ -16,7 +16,7 @@ public class DirectoryClassLoader extends URLClassLoader implements IByteArrayCl
 //    }
 
     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).flatMap(List::stream).collect(Collectors.toList()).toArray(new URL[0]), parent);
     }
 
     private static URL[] generateURLArray(URL url) {

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

@@ -6,18 +6,22 @@ import java.nio.file.Path;
 
 public interface IByteArrayClassLoader {
 
-    Class loadClass(String path) throws ClassNotFoundException;
+    Class<?> loadClass(String path) throws ClassNotFoundException;
 
-    default Class loadClass(byte[] code) {
-        return this._defineClass(null, code, 0, code.length);
+    default Class<?> loadClass(byte[] code) {
+        return this.loadClass(null, code);
     }
 
-    default Class loadClass(Path path) throws IOException {
+    default Class<?> loadClass(String name, byte[] code) {
+        return this._defineClass(name, code, 0, code.length);
+    }
+
+    default Class<?> loadClass(Path path) throws IOException {
         var code = Files.readAllBytes(path);
         return this._defineClass(null, code, 0, code.length);
     }
 
     public Class<?> findClass(String name) throws ClassNotFoundException;
 
-    Class _defineClass(String name, byte[] code, int i, int length) throws ClassFormatError;
+    Class<?> _defineClass(String name, byte[] code, int i, int length) throws ClassFormatError;
 }

src/main/java/de/dhbwstuttgart/languageServerInterface/LanguageServerInterface.java

@@ -0,0 +1,120 @@
+package de.dhbwstuttgart.languageServerInterface;
+
+
+import de.dhbwstuttgart.bytecode.Codegen;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.environment.IByteArrayClassLoader;
+import de.dhbwstuttgart.languageServerInterface.model.LanguageServerTransferObject;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
+import de.dhbwstuttgart.target.generate.ASTToTargetAST;
+import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.target.tree.TargetStructure;
+import org.apache.commons.io.FileUtils;
+
+import java.io.*;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Implementation of an Interface for the Language-Server to get the Resultset and abstract Syntax.
+ */
+public class LanguageServerInterface {
+
+
+    public LanguageServerTransferObject getResultSetAndAbastractSyntax(String path, String resetNamesTo) throws IOException, URISyntaxException, ClassNotFoundException {
+        NameGenerator.resetTo(resetNamesTo);
+        return getResultSetAndAbstractSyntax(path);
+
+    }
+
+    public SourceFile getAst(String path, String resetNamesTo) throws IOException, URISyntaxException, ClassNotFoundException {
+        NameGenerator.resetTo(resetNamesTo);
+        return getAST(path);
+    }
+
+
+    /**
+     * returns the ResultSets, GenericResultSet and the AST
+     * You have to give the input as well as the path because of potential locks when the File is currently opened in an IDE.
+     * Example: file:///c:/test/main.jav -> file:///c:/test/out/main.class
+     *
+     * @param pathAsString the URI of the File. See Example.
+     */
+    public LanguageServerTransferObject getResultSetAndAbstractSyntax(String pathAsString){
+        System.setOut(new PrintStream(OutputStream.nullOutputStream()));
+        try {
+            var uri = new URI(pathAsString);
+            var path = Path.of(uri);
+            var file = path.toFile();
+            Files.createDirectories(path.getParent().resolve("out"));
+            var compiler = new JavaTXCompiler(List.of(file), List.of(path.getParent().toFile()), path.getParent().resolve("out").toFile(), false);
+
+            var parsedSource = compiler.sourceFiles.get(file);
+            var tiResults = compiler.typeInference(file);
+
+            Map<JavaClassName, byte[]> bytecode = compiler.generateBytecode(parsedSource, tiResults);
+            Files.createDirectories(path.getParent().resolve("out"));
+            compiler.writeClassFile(bytecode, path.getParent().resolve("out").toFile(), false);
+
+            return new LanguageServerTransferObject(tiResults, parsedSource, "", compiler.getGeneratedGenerics());
+        } catch (Exception e) {
+            throw new RuntimeException(e.getMessage(), e);
+        }
+    }
+
+    /**
+     * returns the AST without calculating the result
+     * You have to give the input as well as the path because of potential locks when the File is currently opened in an IDE.
+     * Example: file:///c:/test/main.jav -> file:///c:/test/out/main.class
+     *
+     * @param path the URI of the File. See Example.
+     * @throws IOException
+     * @throws ClassNotFoundException
+     * @throws URISyntaxException
+     */
+    public SourceFile getAST(String path) throws IOException, ClassNotFoundException, URISyntaxException {
+
+
+        System.setOut(new PrintStream(OutputStream.nullOutputStream()));
+
+
+        URI uri = new URI(path);
+        ArrayList<String> pathWithoutName = new ArrayList<>(List.of(uri.getPath().split("/")));
+        pathWithoutName.remove(List.of(uri.getPath().split("/")).size() - 1);
+        String stringPathWithoutName = "";
+
+        for (String i : pathWithoutName) {
+            stringPathWithoutName += "/" + i;
+        }
+
+        try {
+            FileUtils.cleanDirectory(new File(stringPathWithoutName + "/out"));
+        } catch (Exception e) {
+
+        }
+        try {
+            (new File(stringPathWithoutName + "/out")).mkdirs();
+        } catch (Exception e) {
+
+        }
+        var test = getAST(uri.getPath().split("/")[uri.getPath().split("/").length - 1], new File(stringPathWithoutName).getPath());
+        System.setOut(System.out);
+        return test;
+    }
+
+    public static SourceFile getAST(String filename, String filePath) throws IOException, ClassNotFoundException {
+        var file = Path.of(filePath, filename).toFile();
+        var compiler = new JavaTXCompiler(List.of(file), List.of(file.getParentFile()), Path.of(filePath + "/out").toFile(), false);
+        return compiler.sourceFiles.get(file);
+    }
+}

src/main/java/de/dhbwstuttgart/languageServerInterface/ParserInterface.java

@@ -0,0 +1,40 @@
+package de.dhbwstuttgart.languageServerInterface;
+
+
+
+import de.dhbwstuttgart.languageServerInterface.model.CustomParserErrorHandler;
+import de.dhbwstuttgart.languageServerInterface.model.ParserError;
+import de.dhbwstuttgart.parser.antlr.Java17Lexer;
+import de.dhbwstuttgart.parser.antlr.Java17Parser;
+import de.dhbwstuttgart.parser.antlr.Java17ParserBaseListener;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+
+import java.util.List;
+
+public class ParserInterface {
+
+    public List<ParserError> getParseErrors(String input){
+
+        CustomParserErrorHandler errorListener = new CustomParserErrorHandler();
+        CharStream charStream = CharStreams.fromString(input);
+
+        Java17Lexer lexer = new Java17Lexer(charStream);
+        CommonTokenStream tokens = new CommonTokenStream(lexer);
+
+        Java17Parser parser = new Java17Parser(tokens);
+        parser.removeErrorListeners();
+        parser.addErrorListener(errorListener);
+
+
+        ParseTree tree = parser.sourceFile();
+        ParseTreeWalker walker = new ParseTreeWalker();
+        Java17ParserBaseListener listener = new Java17ParserBaseListener();
+        walker.walk(listener, tree);
+
+        return errorListener.getErrorMessages();
+    }
+}

src/main/java/de/dhbwstuttgart/languageServerInterface/model/CustomParserErrorHandler.java

@@ -0,0 +1,47 @@
+package de.dhbwstuttgart.languageServerInterface.model;
+
+
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.atn.ATNConfigSet;
+import org.antlr.v4.runtime.dfa.DFA;
+
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.List;
+
+public class CustomParserErrorHandler implements ANTLRErrorListener {
+    private final List<ParserError> errorMessages = new ArrayList<>();
+
+    @Override
+    public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) {
+        int endCharPosition = charPositionInLine;
+        if (offendingSymbol instanceof Token) {
+            Token offendingToken = (Token) offendingSymbol;
+            endCharPosition = charPositionInLine + offendingToken.getText().length();
+        }
+
+        ParserError parserError = new ParserError(line, charPositionInLine, endCharPosition, msg);
+        errorMessages.add(parserError);
+
+    }
+
+    @Override
+    public void reportAmbiguity(Parser parser, DFA dfa, int i, int i1, boolean b, BitSet bitSet, ATNConfigSet atnConfigSet) {
+
+    }
+
+    @Override
+    public void reportAttemptingFullContext(Parser parser, DFA dfa, int i, int i1, BitSet bitSet, ATNConfigSet atnConfigSet) {
+
+    }
+
+    @Override
+    public void reportContextSensitivity(Parser parser, DFA dfa, int i, int i1, int i2, ATNConfigSet atnConfigSet) {
+
+    }
+
+    public List<ParserError> getErrorMessages() {
+        return errorMessages;
+    }
+}

src/main/java/de/dhbwstuttgart/languageServerInterface/model/LanguageServerTransferObject.java

@@ -0,0 +1,31 @@
+package de.dhbwstuttgart.languageServerInterface.model;
+
+
+
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LanguageServerTransferObject {
+    List<ResultSet> resultSets;
+    SourceFile Ast;
+    String printedAst;
+    Map<SourceFile, List<GenericsResult>> generatedGenerics = new HashMap<>();
+
+
+    public LanguageServerTransferObject(List<ResultSet> resultSets, SourceFile Ast, String printedAst, Map<SourceFile, List<GenericsResult>> generatedGenerics) {
+        this.resultSets = resultSets;
+        this.Ast = Ast;
+        this.printedAst = printedAst;
+        this.generatedGenerics = generatedGenerics;
+    }
+
+    public List<ResultSet> getResultSets() {return resultSets;}
+    public SourceFile getAst() {return Ast;}
+    public String getPrintedAst() {return printedAst;}
+    public Map<SourceFile, List<GenericsResult>> getGeneratedGenerics() {return generatedGenerics;}
+}

src/main/java/de/dhbwstuttgart/languageServerInterface/model/ParserError.java

@@ -0,0 +1,48 @@
+package de.dhbwstuttgart.languageServerInterface.model;
+
+public class ParserError {
+
+    private int line;
+    private int charPositionInLine;
+    private int endCharPosition;
+    String msg;
+
+    public ParserError(int line, int charPositionInLine, int endCharPosition, String msg) {
+        this.line = line;
+        this.charPositionInLine = charPositionInLine;
+        this. endCharPosition = endCharPosition;
+        this.msg = msg;
+    }
+
+    public int getEndCharPosition() {
+        return endCharPosition;
+    }
+
+    public void setEndCharPosition(int endCharPosition) {
+        this.endCharPosition = endCharPosition;
+    }
+
+    public void setCharPositionInLine(int charPositionInLine) {
+        this.charPositionInLine = charPositionInLine;
+    }
+
+    public void setLine(int line) {
+        this.line = line;
+    }
+
+    public void setMsg(String msg) {
+        this.msg = msg;
+    }
+
+    public int getCharPositionInLine() {
+        return charPositionInLine;
+    }
+
+    public int getLine() {
+        return line;
+    }
+
+    public String getMsg() {
+        return msg;
+    }
+}

src/main/java/de/dhbwstuttgart/languageServerInterface/model/ResultSetListener.java

@@ -0,0 +1,20 @@
+package de.dhbwstuttgart.languageServerInterface.model;
+
+
+import com.google.common.reflect.TypeResolver;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultEvent;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
+
+public class ResultSetListener implements UnifyResultListener {
+
+    TypeResolver typeResolver;
+
+    public ResultSetListener(TypeResolver typeResolver){
+        this.typeResolver = typeResolver;
+    }
+
+    @Override
+    public void onNewTypeResultFound(UnifyResultEvent evt) {
+
+    }
+}

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

@@ -151,7 +151,7 @@ public class StatementGenerator {
                 } else {
                 	type = methodparameters?
                 			TypePlaceholder.fresh(fp.getStart(), 1, false) 
-                			: TypePlaceholder.fresh(fp.getStart());
+                			: TypePlaceholder.fresh(fp.getStart(), 1, false);
                 }
                 ret.add(new FormalParameter(paramName, type, fp.getStart()));
                 localVars.put(paramName, type); 
@@ -700,7 +700,7 @@ public class StatementGenerator {
         case ConditionalassignexpressionContext condassign:
             return convert(condassign);
         default:
-            throw new NotImplementedException();
+            throw new NotImplementedException(expression.getClass().toString());
         }
     }
 
@@ -1066,7 +1066,7 @@ public class StatementGenerator {
             List<Pattern> parameterList = new ArrayList<>();
             for (IdentifierContext identifier : lambdaParams.identifier()) {
                 Token offset = identifier.getStart();
-                parameterList.add(new FormalParameter(identifier.getText(), TypePlaceholder.fresh(offset), offset));
+                parameterList.add(new FormalParameter(identifier.getText(), TypePlaceholder.fresh(offset, 1, false), offset));
             }
             params = new ParameterList(parameterList, lambdaParams.getStart());
         } else if (lambdaParams.formalParameterList() != null) {
@@ -1076,7 +1076,7 @@ public class StatementGenerator {
             List<Pattern> parameterList = new ArrayList<>();
             for (LambdaLVTIParameterContext param : lambdaParams.lambdaLVTIList().lambdaLVTIParameter()) {
                 Token offset = param.getStart();
-                parameterList.add(new FormalParameter(param.identifier().getText(), TypePlaceholder.fresh(offset), offset));
+                parameterList.add(new FormalParameter(param.identifier().getText(), TypePlaceholder.fresh(offset, 1, false), offset));
             }
             params = new ParameterList(parameterList, lambdaParams.getStart());
         } else {
@@ -1100,9 +1100,9 @@ public class StatementGenerator {
             block = lambdaGenerator.convert(expression.lambdaBody().block(), true);
         }
         List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
-        funNParams.add(TypePlaceholder.fresh(expression.getStart()));// ret-Type
+        funNParams.add(TypePlaceholder.fresh(expression.getStart(), -1, false));// ret-Type
         params.getFormalparalist().forEach(formalParameter -> // Für jeden Parameter einen TPH anfügen:
-        funNParams.add(TypePlaceholder.fresh(expression.getStart())));
+        	funNParams.add(TypePlaceholder.fresh(expression.getStart(), 1, false)));
         RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart());
         // RefType lambdaType = new
         // RefType(reg.getName("Fun"+params.getFormalparalist().size()),

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

@@ -111,7 +111,7 @@ public class SyntaxTreeGenerator {
     this.allmodifiers.put(Modifier.toString(Modifier.INTERFACE), Modifier.INTERFACE);
     this.allmodifiers.put("sealed", 4096);
     this.allmodifiers.put("non-sealed", 8192);
-    this.allmodifiers.put("default", 16384);
+    this.allmodifiers.put("default", 0); // Doesn't exist
     this.allmodifiers.put("strictfp", 32768);
 
     this.compiler = compiler;

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

@@ -64,6 +64,8 @@ public class TypeGenerator {
             switch (typeContext.primitiveType().getText()) {
             case "boolean":
                 return new RefType(ASTFactory.createClass(Boolean.class).getClassName(), typeContext.getStart());
+            case "char":
+                return new RefType(ASTFactory.createClass(Character.class).getClassName(), typeContext.getStart());
             case "int":
                 return new RefType(ASTFactory.createClass(Integer.class).getClassName(), typeContext.getStart());
             case "double":
@@ -71,7 +73,7 @@ public class TypeGenerator {
             case "float":
                 return new RefType(ASTFactory.createClass(Float.class).getClassName(), typeContext.getStart());
             default:
-                throw new NotImplementedException();
+                throw new NotImplementedException(typeContext.primitiveType().getText());
             }
         } else if (!typeContext.LBRACK().isEmpty()) { // ArrayType über eckige Klammer prüfen
             // JavaTXParser.logger.info(unannTypeContext.getText());
@@ -168,7 +170,7 @@ public class TypeGenerator {
             if (generics.contains(name)) {
                 return new GenericRefType(name, offset);
             } else {
-                Pattern p = Pattern.compile("Fun(\\d+)[$][$]");
+                Pattern p = Pattern.compile("Fun(Void|VoidImpl|Wrapper)?(\\d+)[$][$]"); // TODO Regex shenanigans
                 Matcher m = p.matcher(name);
                 if (m.matches()) {// es ist FunN$$-Type
                     return new RefType(new JavaClassName(name), convert(typeArguments, reg, generics), offset);

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 (clazz != null) {
+				if (compiler.input.contains(className)) {
 					ret.put(name, compiler.classRegistry.getNumberOfGenerics(name));
 				} else {
 					Class<?> cl = compiler.getClassLoader().loadClass(name);

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

@@ -41,7 +41,7 @@ public class JavaClassName {
 	}
 
 	/**
-	 * Gibt von einem Klassennamen nur den Namen der Klasse zur�ck
+	 * Gibt von einem Klassennamen nur den Namen der Klasse zurück
 	 * Beispiel:
 	 * java.lang.Object wird zu: Object
 	 */

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

@@ -5,9 +5,9 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
 import java.util.*;
 
 /**
- * Speichert die Klassen f�r einen bestimmten Projektscope
+ * Speichert die Klassen für einen bestimmten Projektscope
  */
-public class JavaClassRegistry {
+public class JavaClassRegistry{
     final Map<JavaClassName, Integer> existingClasses = new HashMap<>();
 
     public JavaClassRegistry(Map<String, Integer> initialNames) {
@@ -22,6 +22,10 @@ public class JavaClassRegistry {
         }
     }
 
+    public Set<JavaClassName> getAllClassNames(){
+        return existingClasses.keySet();
+    }
+
     public void addName(String className, int numberOfGenerics) {
         existingClasses.put(new JavaClassName(className), numberOfGenerics);
     }
@@ -60,6 +64,6 @@ public class JavaClassRegistry {
     }
 
     public int getNumberOfGenerics(String name) {
-        return existingClasses.get(new JavaClassName(name));
+        return existingClasses.getOrDefault(new JavaClassName(name), 0);
     }
 }

src/main/java/de/dhbwstuttgart/server/ServerTaskLogger.java

@@ -0,0 +1,41 @@
+package de.dhbwstuttgart.server;
+
+import de.dhbwstuttgart.util.Logger;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import org.java_websocket.WebSocket;
+
+public class ServerTaskLogger extends Logger {
+
+  private final WebSocket webSocket;
+  private final SocketServer socketServer;
+  private final LogLevel customLogLevel;
+
+  public ServerTaskLogger(WebSocket webSocket, SocketServer socketServer, LogLevel customLogLevel) {
+    this.webSocket = webSocket;
+    this.socketServer = socketServer;
+    this.customLogLevel = customLogLevel;
+  }
+
+  @Override
+  public boolean isLogLevelActive(LogLevel logLevel) {
+    return logLevel.isHigherOrEqualTo(customLogLevel);
+  }
+
+  @Override
+  protected void print(String s, LogLevel logLevel) {
+    String coloredPrefix = this.getPrefix(logLevel);
+    if (logLevel.isHigherOrEqualTo(LogLevel.ERROR)) {
+      socketServer.sendError(webSocket, coloredPrefix + s, false);
+    }
+    else {
+      socketServer.sendMessage(webSocket, coloredPrefix + s);
+    }
+  }
+
+  @Override
+  protected void write(String s) {
+    // under no circumstances write anything to a file
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/SocketClient.java

@@ -1,6 +1,8 @@
 package de.dhbwstuttgart.server;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
+import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.server.packet.IClientToServerPacket;
 import de.dhbwstuttgart.server.packet.IPacket;
 import de.dhbwstuttgart.server.packet.IServerToClientPacket;
 import de.dhbwstuttgart.server.packet.PacketContainer;
@@ -17,6 +19,7 @@ import java.net.URI;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -32,39 +35,31 @@ public class SocketClient extends WebSocketClient {
 
   public static Logger logger = new Logger("SocketClient");
 
-  // use a latch to wait until the connection is closed by the remote host
-  private final CountDownLatch closeLatch = new CountDownLatch(1);
-  // temporarily: The received unify result
-  // TODO: replace with uuid and future system, such that responses can be mapped by a uuid to fulfill a Future
-  private UnifyResultPacket unifyResultPacket;
+  /**
+   * The singleton object
+   */
+  private static SocketClient socketClient = null;
 
-  public SocketClient(String url) {
-    super(URI.create(url), Map.of(
-      "packetProtocolVersion", SocketServer.packetProtocolVersion
-    ));
-    // make sure, the url is in a valid format
+  /**
+   * List of futures that are still waiting to be fulfilled
+   */
+  private final Map<String, SocketFuture<?>> responseFutures = new HashMap<>();
+
+  private SocketClient(String url) {
+    super(
+      URI.create(url), // target url
+      //SocketServer.perMessageDeflateDraft, // enable compression
+      Map.of( // headers
+        "packetProtocolVersion", SocketServer.packetProtocolVersion
+      )
+    );
+
+    // make sure the url is in a valid format
     final String regex = "^wss?://(\\w+(\\.\\w+)?)*:(\\d+)$";
     final Matcher matcher = Pattern.compile(regex).matcher(url);
     if (!matcher.find()) {
       throw new RuntimeException("Provided string \"" + url + "\" is not a valid server URL! Use pattern ws(s?)://<host.name>:<port>");
     }
-  }
-
-  public SocketClient(String host, int port, boolean secure) {
-    super(URI.create(String.format("%s://%s:%d/", secure ? "wss" : "ws", host, port)));
-  }
-
-  /**
-   * The main method for connecting, requesting and waiting for the server to unify.
-   * This is synchronized to prevent multiple webSockets connections at the moment, but it is not called from any
-   * thread except the main thread right now and is not necessary at all, probably. Maybe remove it later
-   */
-  synchronized public List<ResultSet> execute(
-    FiniteClosure finiteClosure,
-    ConstraintSet<Pair> constraintSet,
-    ConstraintSet<UnifyPair> unifyConstraintSet,
-    UnifyContext context
-  ) throws JsonProcessingException {
 
     try {
       // wait for the connection to be set up
@@ -73,62 +68,108 @@ public class SocketClient extends WebSocketClient {
       if (this.getReadyState() != ReadyState.OPEN) {
         throw new RuntimeException("WebSocket Client could not connect to remote host at " + this.uri);
       }
-
-      // send the unify task request
-      UnifyRequestPacket packet = new UnifyRequestPacket(finiteClosure, constraintSet, unifyConstraintSet, context.placeholderRegistry());
-      String json = PacketContainer.serialize(packet);
-      this.send(json);
-
-      // block the thread, until the connection is closed by the remote host (usually after sending the results)
-      this.waitUntilClosed();
-      // wait for the connection to fully close
-      this.closeBlocking();
     } catch (InterruptedException exception) {
-      System.err.println("Server connection interrupted: " + exception);
-      this.notifyAll();
-      throw new RuntimeException("Aborted server connection", exception);
-    }
-    catch (Exception exception) {
-      throw new RuntimeException("Exception occurred in server connection: ", exception);
+      throw new RuntimeException(exception);
     }
 
-    // detect error cases, in which no error was thrown, but also no result was sent back from the server
-    if (this.unifyResultPacket == null) {
-      throw new RuntimeException("Did not receive server response but closed connection already");
-    }
+    // add a shutdown hook to close the connection when the process ends or is stopped by a SIGINT signal
+    Runtime.getRuntime().addShutdownHook(new Thread(this::close));
+  }
 
-    return unifyResultPacket.getResultSet(context);
+  private SocketClient(String host, int port, boolean secure) throws InterruptedException {
+    this(String.format("%s://%s:%d/", secure ? "wss" : "ws", host, port));
   }
 
   /**
-   *  Specific client-side implementations to handle incoming packets
+   * Singleton access method, creates one if none is available
+   *
+   * @return The one and only socketClient
+   */
+  private static SocketClient initializeClient() {
+    if (socketClient == null) {
+      socketClient = new SocketClient(ConsoleInterface.unifyServerUrl.get());
+    }
+    return socketClient;
+  }
+
+  /**
+   * Send a packet to the server (connection will be created, if none is found) and return a future
+   * for the response packet
+   */
+  synchronized public static <T extends IServerToClientPacket> SocketFuture<T> execute(IClientToServerPacket<T> packet) {
+    SocketClient client = initializeClient();
+
+    /*
+     * Create a future that will be associated with the packet and eventually completed
+     */
+    SocketFuture<T> future = packet.getFuture();
+    if (!future.isDone()) {
+      client.responseFutures.put(future.futureId, future);
+    }
+
+    /*
+     * Establish connection, if not already done.
+     * Serialize the packet and send it to the server.
+     * Return the future to be handled by the caller.
+     */
+    try {
+      String json = PacketContainer.serialize(packet);
+      client.send(json);
+    } catch (Exception exception) {
+      logger.exception(exception);
+      throw new RuntimeException("Exception occurred in server connection: ", exception);
+    }
+
+    return future;
+  }
+
+  /**
+   * Shortcut for waiting and retrieving the response immediately
+   *
+   * @param packet The packet to send
+   * @param <T>    The type of response packet to await
+   * @return The response packet, once it is received
+   */
+  public static <T extends IServerToClientPacket> T executeAndGet(IClientToServerPacket<T> packet) {
+    return SocketClient.execute(packet).get();
+  }
+
+  /**
+   * Specific client-side implementations to handle incoming packets
    */
   protected void handleReceivedPacket(IPacket packet) {
-    if (packet instanceof IServerToClientPacket serverToClientPacket) {
-
-      try {
-        serverToClientPacket.onHandle(this.getConnection(), this);
-      }
-      catch (Exception exception) {
-        this.closeLatch.countDown();
-        this.close();
-        throw exception;
-      }
-
+    if (!(packet instanceof IServerToClientPacket serverToClientPacket)) {
+      System.err.println("Received package of invalid type + " + packet.getClass().getName());
+      this.close();
       return;
     }
 
-    System.err.println("Received package of invalid type + " + packet.getClass().getName());
-    this.close();
+    serverToClientPacket.onHandle(this.getConnection(), this);
   }
 
-  public void setUnifyResultSets(UnifyResultPacket unifyResultPacket) {
-    this.unifyResultPacket = unifyResultPacket;
+  /**
+   * Complete a registered future, so it can be handled by whoever executed the creator task
+   *
+   * @param id      The associated id for this future
+   * @param trigger The object triggering the completion
+   */
+  public void completeResponseFuture(String id, IServerToClientPacket trigger) {
+    SocketFuture<?> future = this.responseFutures.remove(id);
+    if (future == null) return;
+    if (!future.accept(trigger)) {
+      throw new RuntimeException("Packet " + trigger.getClass().getName() + " tried to complete future, but was not allowed to");
+    }
+  }
+
+  public static void closeIfOpen() {
+    if (socketClient != null && socketClient.isOpen()) {
+      socketClient.close();
+    }
   }
 
   @Override
   public void onOpen(ServerHandshake handshakedata) {
-    logger.info("Connected to server with status " + handshakedata.getHttpStatus());
+    logger.success("Connected to server with status " + handshakedata.getHttpStatus());
   }
 
   @Override
@@ -146,16 +187,16 @@ public class SocketClient extends WebSocketClient {
         (reason.isEmpty() ? "" : "and reason " + reason + " ") +
         "(closed by remote: " + remote + ")"
     );
-    this.closeLatch.countDown();
+
+    if (!this.responseFutures.isEmpty()) {
+      throw new RuntimeException("Server closed before all required tasks were answered");
+    }
   }
 
   @Override
   public void onError(Exception e) {
-    logger.error("Error: " + e.getMessage());
-    e.printStackTrace();
+    logger.exception(e);
+    throw new RuntimeException(e);
   }
 
-  public void waitUntilClosed() throws InterruptedException {
-    closeLatch.await();
-  }
 }

src/main/java/de/dhbwstuttgart/server/SocketFuture.java

@@ -0,0 +1,48 @@
+package de.dhbwstuttgart.server;
+
+import de.dhbwstuttgart.server.packet.IServerToClientPacket;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class SocketFuture<T extends IServerToClientPacket> extends CompletableFuture<T> {
+
+  public final String futureId = UUID.randomUUID().toString();
+
+  public final List<Class<T>> allowedTriggers;
+
+  public SocketFuture(List<Class<T>> allowedTriggers) {
+    this.allowedTriggers = allowedTriggers;
+  }
+
+  public boolean accept(IServerToClientPacket trigger) {
+    if (this.allowedTriggers.contains(trigger.getClass())) {
+      this.complete((T)trigger);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public T get() {
+    try {
+      return super.get();
+    }
+    catch (InterruptedException | ExecutionException exception) {
+      throw new RuntimeException(exception);
+    }
+  }
+
+  /**
+   * Special case where the future is immediately fulfilled without a response package similar to
+   * <code>CompletableFuture.completedFuture()</code> but without a value
+   */
+  public static <R extends IServerToClientPacket> SocketFuture<R> completedFuture() {
+    SocketFuture<R> dummyFuture = new SocketFuture<>(new ArrayList<>(0));
+    dummyFuture.complete(null);
+    return dummyFuture;
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/SocketServer.java

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.server;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
-import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.server.packet.ErrorPacket;
 import de.dhbwstuttgart.server.packet.IClientToServerPacket;
 import de.dhbwstuttgart.server.packet.IPacket;
@@ -9,69 +8,98 @@ import de.dhbwstuttgart.server.packet.MessagePacket;
 import de.dhbwstuttgart.server.packet.PacketContainer;
 import de.dhbwstuttgart.util.Logger;
 import java.net.InetSocketAddress;
-import java.util.Objects;
+import java.util.Collections;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import org.java_websocket.WebSocket;
+import org.java_websocket.drafts.Draft;
+import org.java_websocket.drafts.Draft_6455;
+import org.java_websocket.extensions.permessage_deflate.PerMessageDeflateExtension;
 import org.java_websocket.handshake.ClientHandshake;
 import org.java_websocket.server.WebSocketServer;
 
 public class SocketServer extends WebSocketServer {
 
   public static Logger logger = new Logger("SocketServer");
+  public static final int maxTasksPerSession = 100;
+  private static boolean serverRunning = false;
 
   /**
    * Increase this every time a breaking change to the server communication is done.
-   * This will prevent errors when server version and client version do not match.
+   * This will prevent errors when the server version and client version do not match.
    */
   public static final String packetProtocolVersion = "1";
 
+  // create an executor for tasks that will always keep at least one task around
+  private final ThreadPoolExecutor taskExecutor = new ThreadPoolExecutor(1, Integer.MAX_VALUE,60L, TimeUnit.SECONDS, new SynchronousQueue<>());
+  // create an executor for scheduling timeouts
+  private final ScheduledExecutorService timeoutExecutor = Executors.newSingleThreadScheduledExecutor();
+
   public SocketServer(int port) {
     super(new InetSocketAddress(port));
+    this.setConnectionLostTimeout(30);
+
+    serverRunning = true;
+    // add a shutdown hook to close all connections when the process ends or is stopped by a SIGINT signal
+    Runtime.getRuntime().addShutdownHook(new Thread(this::onShutdown));
+  }
+
+  public static boolean isServerRunning() {
+    return serverRunning;
+  }
+
+  private void onShutdown() {
+    serverRunning = false;
+    try {
+      for (var webSocket : this.getConnections()) {
+        this.sendError(webSocket, "Sorry, i am shutting down. You are now on your own, good Luck!", true);
+        webSocket.close();
+      }
+      this.stop();
+      taskExecutor.shutdown();
+      timeoutExecutor.shutdown();
+    } catch (InterruptedException exception) {
+      // we are shutting down anyway
+    }
   }
 
   @Override
   public void onOpen(WebSocket webSocket, ClientHandshake clientHandshake) {
     String ppv = clientHandshake.getFieldValue("packetProtocolVersion");
     if (!ppv.equals(packetProtocolVersion)) {
-      try {
-        ErrorPacket errorPacket = ErrorPacket.create(
-          "Mismatch in packet protocol version! Client (you): " + ppv + " and Server (me): " + packetProtocolVersion,
-          true
-        );
-        webSocket.send(PacketContainer.serialize(errorPacket));
-      }
-      catch (JsonProcessingException exception) {
-        System.err.println("Failed to serialize json: " + exception);
-      }
+      this.sendError(webSocket,
+        "Mismatch in packet protocol version! Client (you): \"" + ppv + "\" and Server (me): \"" + packetProtocolVersion + "\"",
+        true
+      );
       webSocket.close(1);
       return;
     }
 
-
-    SocketData socketData = new SocketData(UUID.randomUUID().toString());
-    webSocket.setAttachment(socketData);
+    SocketData socketData = new SocketData(webSocket);
     logger.info("New connection: " + socketData.id + " (with ppv " + ppv + ")");
 
     try {
       sendMessage(webSocket, "Welcome to the server!");
 
       // wait 10 seconds for the client to send a task and close the connection if nothing has been received until then
-      try (ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor()) {
-        Runnable task = () -> {
-          if (webSocket.<SocketData>getAttachment().unhandledTasks.get() == 0 || !webSocket.isOpen()) {
+      final int secondsUntilTimeout = 10;
+      timeoutExecutor.schedule(() -> {
+          if (webSocket.<SocketData>getAttachment().totalTasks.get() > 0 || !webSocket.isOpen()) {
             return;
           }
-          sendMessage(webSocket, "No task received after 10 seconds. Closing connection...");
+          sendMessage(webSocket, "No task received after " + secondsUntilTimeout + " seconds. Closing connection...");
           webSocket.close();
-        };
-        executor.schedule(task, 10, TimeUnit.SECONDS);
-        executor.shutdown();
-      }
+        },
+        secondsUntilTimeout,
+        TimeUnit.SECONDS
+      );
 
       // and finally, when your program wants to exit
     } catch (Exception e) {
@@ -101,20 +129,22 @@ public class SocketServer extends WebSocketServer {
       this.onPacketReceived(webSocket, reconstructedPacket);
     } catch (JsonProcessingException e) {
       logger.exception(e);
-      this.log("Error on processing incoming package: " + e.getMessage(), webSocket);
+      this.log(webSocket, "Error on processing incoming package: " + e.getMessage());
     }
   }
 
   @Override
   public void onError(WebSocket webSocket, Exception e) {
+    if (webSocket != null) {
+      log(webSocket, e.getMessage());
+      webSocket.close();
+    }
     logger.exception(e);
-    log(e.getMessage(), webSocket);
-    webSocket.close();
   }
 
   @Override
   public void onStart() {
-    logger.info("Websocket server started on port " + this.getPort());
+    logger.success("Websocket server started on port " + this.getPort());
   }
 
   /**
@@ -122,8 +152,7 @@ public class SocketServer extends WebSocketServer {
    */
   public void sendMessage(WebSocket webSocket, String text) {
     try {
-      MessagePacket message = new MessagePacket();
-      message.message = text;
+      MessagePacket message = MessagePacket.create(text);
       webSocket.send(PacketContainer.serialize(message));
     } catch (Exception e) {
       System.err.println("Failed to send message: " + text);
@@ -134,33 +163,31 @@ public class SocketServer extends WebSocketServer {
   /**
    * A shorthand method for sending error messages to the client
    */
-  public void sendError(WebSocket webSocket, String text) {
+  public void sendError(WebSocket webSocket, String text, boolean isFatal) {
     try {
-      ErrorPacket error = new ErrorPacket();
-      error.error = text;
+      ErrorPacket error = ErrorPacket.create(text, isFatal);
       webSocket.send(PacketContainer.serialize(error));
     } catch (Exception e) {
       logger.exception(e);
-      log("Failed to send error: " + text, webSocket);
+      log(webSocket, "Failed to send error: " + text);
     }
   }
 
   /**
-   *  The server-side implementation on how to handle certain packets when received
+   * The server-side implementation on how to handle certain packets when received
    */
   private void onPacketReceived(WebSocket webSocket, IPacket packet) throws JsonProcessingException {
     SocketData socketData = webSocket.getAttachment();
 
-    // limit the amount of tasks per connection
-    final int maxTasks = 100;
-    if (socketData.totalTasks.get() >= maxTasks) {
-      sendError(webSocket, "Exceeded the maximum amount of " + maxTasks + " tasks per session");
+    // limit the number of tasks per connection
+    if (socketData.totalTasks.get() >= maxTasksPerSession) {
+      sendError(webSocket, "Exceeded the maximum amount of " + maxTasksPerSession + " tasks per session", true);
       webSocket.close();
       return;
     }
 
-    // only allow packets, that are meant to be handled by the server
-    if (!(packet instanceof IClientToServerPacket clientToServerPacket)) {
+    // only allow packets that are meant to be handled by the server
+    if (!(packet instanceof IClientToServerPacket<?> clientToServerPacket)) {
       sendMessage(webSocket, "The package of type " + packet.getClass().getName() + " is not handled by the server!");
       return;
     }
@@ -169,22 +196,24 @@ public class SocketServer extends WebSocketServer {
     socketData.unhandledTasks.incrementAndGet();
     socketData.totalTasks.incrementAndGet();
 
-    // add the packet to the queue, so it can be started by the worker
+    // add the packet to the queue so it can be started by the worker
     CompletableFuture.runAsync(() -> {
       clientToServerPacket.onHandle(webSocket, this);
-
-      // if the websocket has 0 unhandled Tasks, close the connection
       int remainingUnhandledTasks = socketData.unhandledTasks.decrementAndGet();
-      if (remainingUnhandledTasks <= 0) {
-        sendMessage(webSocket, "All requested tasks finished! Closing connection...");
-        webSocket.close();
+
+      if (socketData.closeIfNoTasksLeft) {
+        // if the websocket has 0 unhandled Tasks, close the connection
+        if (remainingUnhandledTasks <= 0) {
+          sendMessage(webSocket, "All requested tasks finished! Closing connection...");
+          webSocket.close();
+        }
       }
-    });
+    }, taskExecutor);
   }
 
-  public void log(String msg, WebSocket webSocket) {
-    SocketData socketData = webSocket == null ? new SocketData("???") : webSocket.getAttachment();
-    logger.info("["+socketData.id+"] " + msg);
+  public void log(WebSocket webSocket, String msg) {
+    String socketId = (webSocket == null) ? "???" : webSocket.<SocketData>getAttachment().id;
+    logger.info("[" + socketId + "] " + msg);
   }
 
   /**
@@ -196,10 +225,11 @@ public class SocketServer extends WebSocketServer {
     public final String id;
     public final AtomicInteger unhandledTasks = new AtomicInteger(0);
     public final AtomicInteger totalTasks = new AtomicInteger(0);
+    public boolean closeIfNoTasksLeft = false;
 
-    public SocketData(String id) {
-      this.id = id;
+    public SocketData(WebSocket webSocket) {
+      this.id = UUID.randomUUID().toString();
+      webSocket.setAttachment(this);
     }
   }
-
 }

src/main/java/de/dhbwstuttgart/server/packet/DebugPacket.java

@@ -2,6 +2,7 @@ package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.ISerialNode;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialList;
@@ -10,7 +11,7 @@ import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialUUID;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialValue;
 import org.java_websocket.WebSocket;
 
-public class DebugPacket implements IClientToServerPacket, IServerToClientPacket {
+public class DebugPacket implements IClientToServerPacket.Void, IServerToClientPacket {
 
   public SerialUUID a1;
   public SerialUUID a2;
@@ -22,9 +23,13 @@ public class DebugPacket implements IClientToServerPacket, IServerToClientPacket
   public SerialValue<?> d2;
 
   @JsonIgnore
-  public void onHandle(WebSocket webSocket, SocketClient socketServer) {}
+  public void onHandle(WebSocket webSocket, SocketClient socketClient) {}
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketServer socketServer) {}
 
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
+  }
 }

src/main/java/de/dhbwstuttgart/server/packet/ErrorPacket.java

@@ -2,16 +2,17 @@ package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import org.java_websocket.WebSocket;
 
 /**
  * A packet to send simple error messages between the client and the server
  */
-public class ErrorPacket implements IClientToServerPacket, IServerToClientPacket {
+public class ErrorPacket implements IServerToClientPacket {
 
   /**
-   * The error endpoint for messages from the server, that should be logged out outputted
+   * The error endpoint for messages from the server that should be logged out as errors and possibly abort the process
    */
   public String error;
   public boolean isFatal;
@@ -27,15 +28,9 @@ public class ErrorPacket implements IClientToServerPacket, IServerToClientPacket
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketClient socketClient) {
-    System.err.println("[socket] " + "ErrorPacket: " + this.error);
+    SocketClient.logger.exception(new RuntimeException(this.error));
     if (this.isFatal) {
-      throw new RuntimeException("Received fatal error from server: " + this.error);
+      socketClient.close(1, "Received fatal error from server");
     }
   }
-
-  @JsonIgnore
-  public void onHandle(WebSocket webSocket, SocketServer socketServer) {
-    socketServer.log("ErrorPacket: " + this.error, webSocket);
-  }
-
 }

src/main/java/de/dhbwstuttgart/server/packet/IClientToServerPacket.java

@@ -1,12 +1,26 @@
 package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import org.java_websocket.WebSocket;
 
-public interface IClientToServerPacket extends IPacket {
+/**
+ * A packet that will be sent to the server. Use <code>Void</code> Sub-Interface for packets without response
+ *
+ * @param <T>   The response packet that will fulfill the future.
+ */
+public interface IClientToServerPacket<T extends IServerToClientPacket> extends IPacket {
 
   @JsonIgnore
   void onHandle(WebSocket webSocket, SocketServer socketServer);
 
+  @JsonIgnore
+  SocketFuture<T> getFuture();
+
+  /**
+   * Special case, where the packet will remain unanswered by the server
+   */
+  interface Void extends IClientToServerPacket<IServerToClientPacket> {}
 }
+

src/main/java/de/dhbwstuttgart/server/packet/InvalidPacket.java

@@ -2,13 +2,14 @@ package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import org.java_websocket.WebSocket;
 
 /**
- * A fallback packet that is generated, if the received json could not be mapped to an existing package
+ * A fallback packet that is generated if the received JSON could not be mapped to an existing package
  */
-public class InvalidPacket implements IClientToServerPacket, IServerToClientPacket {
+public class InvalidPacket implements IClientToServerPacket.Void, IServerToClientPacket {
 
   /**
    * If available, the error that caused this package to appear
@@ -18,12 +19,17 @@ public class InvalidPacket implements IClientToServerPacket, IServerToClientPack
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketClient socketClient) {
-    System.err.println("[socket] " + "InvalidPacket: " + this.error);
+    SocketClient.logger.error("InvalidPacket: " + this.error);
   }
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketServer socketServer) {
-    socketServer.log("InvalidPacket: " + this.error, webSocket);
+    socketServer.log(webSocket, "InvalidPacket: " + this.error);
+  }
+
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
   }
 
 }

src/main/java/de/dhbwstuttgart/server/packet/MessagePacket.java

@@ -2,16 +2,17 @@ package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import org.java_websocket.WebSocket;
 
 /**
  * A packet to send simple informational messages between the client and the server
  */
-public class MessagePacket implements IClientToServerPacket, IServerToClientPacket {
+public class MessagePacket implements IClientToServerPacket.Void, IServerToClientPacket {
 
   /**
-   * The informational message from the server, that should be logged out outputted
+   * The informational message from the server that should be logged out outputted
    */
   public String message;
 
@@ -24,13 +25,16 @@ public class MessagePacket implements IClientToServerPacket, IServerToClientPack
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketClient socketClient) {
-    System.err.println("[socket] " + this.message);
-
+    SocketClient.logger.info("SocketMessage: " + this.message);
   }
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketServer socketServer) {
-    socketServer.log(this.message, webSocket);
+    socketServer.log(webSocket, this.message);
   }
 
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
+  }
 }

src/main/java/de/dhbwstuttgart/server/packet/PacketContainer.java

@@ -25,13 +25,14 @@ public class PacketContainer {
   public UnifyRequestPacket unifyRequestPacket = null;
   public UnifyResultPacket unifyResultPacket = null;
   public DebugPacket debugPacket = null;
+  public SetAutoclosePacket setAutoclosePacket = null;
 
 
   /**
    * Generate the JSON string for the given packet
    *
    * @param packet The packet to serialize
-   * @return The json representation of the packet
+   * @return The JSON representation of the packet
    */
   public static String serialize(IPacket packet) throws JsonProcessingException {
     objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
@@ -47,7 +48,11 @@ public class PacketContainer {
       container.unifyResultPacket = (UnifyResultPacket) packet;
     else if (packet instanceof DebugPacket)
       container.debugPacket = (DebugPacket) packet;
+    else if (packet instanceof SetAutoclosePacket)
+      container.setAutoclosePacket = (SetAutoclosePacket) packet;
     // Add new packets here and in the deserialize method
+    else
+      throw new RuntimeException("Cannot map packet to any known packet class");
 
     return objectMapper.writeValueAsString(container);
   }
@@ -76,6 +81,8 @@ public class PacketContainer {
         return container.unifyResultPacket;
       if (container.debugPacket != null)
         return container.debugPacket;
+      if (container.setAutoclosePacket != null)
+        return container.setAutoclosePacket;
       // Add new packets here and in the serialize method
 
       throw new RuntimeException("Cannot map received json to any known packet class");

src/main/java/de/dhbwstuttgart/server/packet/SetAutoclosePacket.java

@@ -0,0 +1,32 @@
+package de.dhbwstuttgart.server.packet;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.SocketServer;
+import org.java_websocket.WebSocket;
+
+/**
+ * Normally, a connection stays open until either the client or the server process ends.
+ * Send this packet to inform the server that the connection can be closed once all tasks are done
+ */
+public class SetAutoclosePacket implements IClientToServerPacket.Void {
+
+  public int dummyProperty = 1;
+
+  @JsonIgnore
+  public static SetAutoclosePacket create() {
+    return new SetAutoclosePacket();
+  }
+
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketServer socketServer) {
+    webSocket.<SocketServer.SocketData>getAttachment().closeIfNoTasksLeft = true;
+    socketServer.log(webSocket, "Marked connection as autoclose");
+  }
+
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/UnifyRequestPacket.java

@@ -1,6 +1,9 @@
 package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.server.ServerTaskLogger;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialList;
@@ -20,18 +23,16 @@ import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
 import de.dhbwstuttgart.util.Logger;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.Writer;
 import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.List;
 import java.util.concurrent.ForkJoinPool;
 import org.java_websocket.WebSocket;
 
 /**
  * A packet to send all required data for the unification algorithm to the server and request the unification
  */
-public class UnifyRequestPacket implements IClientToServerPacket {
+public class UnifyRequestPacket implements IClientToServerPacket<UnifyResultPacket> {
 
   public SerialMap finiteClosure;
   public SerialMap constraintSet;
@@ -39,30 +40,33 @@ public class UnifyRequestPacket implements IClientToServerPacket {
   public SerialMap serialKeyStorage;
   public SerialValue<?> placeholders;
   public SerialList<SerialMap> factoryplaceholders;
+  public String futureId;
+  public int logLevel;
 
   @JsonIgnore
   private KeyStorage keyStorage = new KeyStorage();
   @JsonIgnore
   private boolean keyStorageLoaded = false;
 
-  public UnifyRequestPacket() {}
-
-  public UnifyRequestPacket(
+  public static UnifyRequestPacket create(
     FiniteClosure finiteClosure,
     ConstraintSet<Pair> constraintSet,
     ConstraintSet<UnifyPair> unifyConstraintSet,
     PlaceholderRegistry placeholderRegistry
   ) {
-    // store contraint and finite closure
-    this.finiteClosure = finiteClosure.toSerial(keyStorage);
-    this.constraintSet = constraintSet.toSerial(keyStorage);
-    this.unifyConstraintSet = unifyConstraintSet.toSerial(keyStorage);
+    UnifyRequestPacket packet = new UnifyRequestPacket();
+    // store constraint and finite closure
+    packet.finiteClosure = finiteClosure.toSerial(packet.keyStorage);
+    packet.constraintSet = constraintSet.toSerial(packet.keyStorage);
+    packet.unifyConstraintSet = unifyConstraintSet.toSerial(packet.keyStorage);
     // store placeholder registry
-    var serialRegistry = placeholderRegistry.toSerial(keyStorage);
-    this.placeholders = serialRegistry.getValue("ph");
-    this.factoryplaceholders = serialRegistry.getList("factoryPh").assertListOfMaps();
+    var serialRegistry = placeholderRegistry.toSerial(packet.keyStorage);
+    packet.placeholders = serialRegistry.getValue("ph");
+    packet.factoryplaceholders = serialRegistry.getList("factoryPh").assertListOfMaps();
     // store referenced objects separately
-    this.serialKeyStorage = keyStorage.toSerial(keyStorage);
+    packet.serialKeyStorage = packet.keyStorage.toSerial(packet.keyStorage);
+    packet.logLevel = ConsoleInterface.logLevel.getValue();
+    return packet;
   }
 
 
@@ -95,15 +99,22 @@ public class UnifyRequestPacket implements IClientToServerPacket {
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketServer socketServer) {
     socketServer.sendMessage(webSocket, "You requested a unify! Please wait until I calculated everything...");
-    SocketServer.logger.info("Client " + webSocket.<SocketServer.SocketData>getAttachment().id + " requested a unification. Starting now...");
+    socketServer.log(webSocket, "Client requested a unification. Starting now...");
 
     try {
       var placeholderRegistry = new PlaceholderRegistry();
       ArrayList<String> existingPlaceholders = (ArrayList) this.placeholders.getOf(ArrayList.class);
       existingPlaceholders.forEach(placeholderRegistry::addPlaceholder);
 
-      var unifyContext = new UnifyContext(Logger.NULL_LOGGER, true,
-        new UnifyResultModel(new ConstraintSet<>(), new FiniteClosure(new HashSet<>(), Logger.NULL_LOGGER, placeholderRegistry)),
+      Logger logger = new ServerTaskLogger(
+        webSocket,
+        socketServer,
+        Logger.LogLevel.fromValue(
+          Math.max(this.logLevel, Logger.LogLevel.INFO.getValue())
+        )
+      );
+      var unifyContext = new UnifyContext(logger, true,
+        new UnifyResultModel(new ConstraintSet<>(), new FiniteClosure(new HashSet<>(), logger, placeholderRegistry)),
         new UnifyTaskModel(), ForkJoinPool.commonPool(), placeholderRegistry
       );
 
@@ -130,17 +141,24 @@ public class UnifyRequestPacket implements IClientToServerPacket {
 
       var resultSets = resultListener.getResults();
 
-      SocketServer.logger.info("Finished unification for client " + webSocket.<SocketServer.SocketData>getAttachment().id);
+      socketServer.log(webSocket, "Finished unification");
       socketServer.sendMessage(webSocket, "Unification finished. Found " + resultSets.size() + " result sets");
 
       if (webSocket.isOpen()) {
-        UnifyResultPacket resultPacket = UnifyResultPacket.create(resultSets);
+        UnifyResultPacket resultPacket = UnifyResultPacket.create(resultSets, futureId);
         webSocket.send(PacketContainer.serialize(resultPacket));
       }
     } catch (Exception e) {
       SocketServer.logger.exception(e);
-      socketServer.log(e.getMessage(), webSocket);
+      socketServer.log(webSocket, e.getMessage());
     }
   }
 
+  @JsonIgnore
+  public SocketFuture<UnifyResultPacket> getFuture() {
+    var future = new SocketFuture<>(List.of(UnifyResultPacket.class));
+    futureId = future.futureId;
+    return future;
+  }
+
 }

src/main/java/de/dhbwstuttgart/server/packet/UnifyResultPacket.java

@@ -18,12 +18,14 @@ public class UnifyResultPacket implements IServerToClientPacket {
 
   public SerialList<ISerialNode> results;
   public SerialMap keyStorage;
+  public String futureId;
 
-  public static UnifyResultPacket create(List<ResultSet> resultSets) {
+  public static UnifyResultPacket create(List<ResultSet> resultSets, String futureId) {
     UnifyResultPacket serialized = new UnifyResultPacket();
     KeyStorage keyStorage = new KeyStorage();
     serialized.results = SerialList.fromMapped(resultSets, resultSet -> resultSet.toSerial(keyStorage));
     serialized.keyStorage = keyStorage.toSerial(keyStorage);
+    serialized.futureId = futureId;
     return serialized;
   }
 
@@ -35,8 +37,8 @@ public class UnifyResultPacket implements IServerToClientPacket {
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketClient socketClient) {
-    SocketClient.logger.info("[socket] Received unify result");
-    socketClient.setUnifyResultSets(this);
+    SocketClient.logger.info("Received unify result");
+    socketClient.completeResponseFuture(futureId, this);
   }
 
 

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/serialized/SerialMap.java

@@ -3,7 +3,7 @@ package de.dhbwstuttgart.server.packet.dataContainers.serialized;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import java.util.HashMap;
 import java.util.Map;
-import javax.annotation.Nullable;
+import org.jspecify.annotations.Nullable;
 
 public class SerialMap extends HashMap<String, ISerialNode> implements ISerialNode {
 

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

@@ -6,10 +6,12 @@ import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.target.tree.TargetGeneric;
 import org.antlr.v4.runtime.Token;
 
 import java.lang.reflect.Modifier;
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * Stellt jede Art von Klasse dar. Auch abstrakte Klassen und Interfaces
@@ -31,6 +33,7 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope {
   private List<RefType> implementedInterfaces;
   private List<RefType> permittedSubtypes;
   private List<Constructor> constructors;
+  private Set<GenericTypeVar> userDefinedGenerics;
 
   public ClassOrInterface(int modifiers, JavaClassName name, List<Field> fielddecl, Optional<Constructor> fieldInitializations, Optional<Method> staticInitializer, List<Method> methods, List<Constructor> constructors, GenericDeclarationList genericClassParameters, RefType superClass, Boolean isInterface, Boolean isFunctionalInterface, List<RefType> implementedInterfaces, List<RefType> permittedSubtypes, Token offset, String fileName) {
     super(offset);
@@ -199,4 +202,22 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope {
   public int hashCode() {
     return Objects.hash(name);
   }
+
+  public Set<GenericTypeVar> getUserDefinedGenerics() {
+    if (this.userDefinedGenerics != null) return this.userDefinedGenerics;
+
+    var genericsIter = getGenerics().iterator();
+    if (genericsIter.hasNext()) {
+      // Add empty set of generics to cache so that it doesn't try to calculate it later
+      this.userDefinedGenerics = new HashSet<>();
+      while (genericsIter.hasNext()) {
+        var next = genericsIter.next();
+        userDefinedGenerics.add(next);
+      }
+    } else {
+      this.userDefinedGenerics = new HashSet<>();
+    }
+
+    return this.userDefinedGenerics;
+  }
 }

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

@@ -5,8 +5,10 @@ import java.util.*;
 
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.target.generate.ASTToTargetAST;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
 //import sun.security.x509.X509CertInfo;
 
 public class SourceFile extends SyntaxTreeNode {
@@ -18,6 +20,7 @@ public class SourceFile extends SyntaxTreeNode {
   private boolean isGenerated;
 
   public List<ClassOrInterface> availableClasses = new ArrayList<>();
+  public List<ASTToTargetAST.Generics> generics = new ArrayList<>();
 
   /**
    * Die SourceFile repräsntiert eine zu einem Syntaxbaum eingelesene Java-Datei.
@@ -40,6 +43,10 @@ public class SourceFile extends SyntaxTreeNode {
     this.imports = new HashSet<>(sf.imports);
   }
 
+  public void addResultSet(ResultSet rs) {
+
+  }
+
   public void setPackageName(String packageName) {
     this.pkgName = packageName;
   }

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

@@ -8,6 +8,7 @@ import java.lang.reflect.Constructor;
 import java.lang.reflect.Type;
 import java.util.*;
 
+import com.google.common.collect.Lists;
 import de.dhbwstuttgart.bytecode.JavaTXSignatureAttribute;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
@@ -153,15 +154,13 @@ public class ASTFactory {
 		int modifier = jreClass.getModifiers();
 		boolean isInterface = jreClass.isInterface();
 		List<Annotation> aLA;
-		boolean isFunctionalInterface = 
-				(aLA = Arrays.asList(jreClass.getAnnotations())).size() > 0 && 
-				aLA.get(0) instanceof FunctionalInterface ? 
-						true : 
-						false; 
+		boolean isFunctionalInterface =
+                !(aLA = Arrays.asList(jreClass.getAnnotations())).isEmpty() &&
+                        aLA.get(0) instanceof FunctionalInterface;
 		// see: https://stackoverflow.com/questions/9934774/getting-generic-parameter-from-supertype-class
 		ParameterizedType parameterSuperClass = null;
 		Type tempSuperClass = jreClass.getGenericSuperclass();
-		if (tempSuperClass != null && tempSuperClass instanceof ParameterizedType)
+		if (tempSuperClass instanceof ParameterizedType)
 			parameterSuperClass = (ParameterizedType) tempSuperClass;
 		java.lang.Class superjreClass = jreClass.getSuperclass();
 		RefType superClass;
@@ -184,8 +183,7 @@ public class ASTFactory {
 			}
 		}
 
-		GenericDeclarationList genericDeclarationList = createGenerics(jreClass.getTypeParameters(), jreClass, null, classSignature);
-
+		GenericDeclarationList genericDeclarationList = createGenerics(jreClass.getTypeParameters(), jreClass, null, null);
 		Token offset = new NullToken(); // Braucht keinen Offset, da diese Klasse nicht aus einem Quellcode geparst wurde
 
 		var cinf = new ClassOrInterface(modifier, name, felder, Optional.empty() /* eingefuegt PL 2018-11-24 */, Optional.empty(), methoden, konstruktoren, genericDeclarationList, superClass, isInterface, isFunctionalInterface, implementedInterfaces, permittedSubtypes, offset, null);

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

@@ -16,6 +16,10 @@ public class NameGenerator {
     public static void reset() {
     	strNextName = "A";
     }
+
+    public static void resetTo(String name) {
+        strNextName = name;
+    }
     
     /**
      * Berechnet einen neuen, eindeutigen Namen f�r eine neue                          

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

@@ -27,9 +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<TypePlaceholder> signature;
+    public int modifiers;
     
-    public MethodCall(RefTypeOrTPHOrWildcardOrGeneric retType, Receiver receiver, String methodName, ArgumentList argumentList, 
+    public MethodCall(RefTypeOrTPHOrWildcardOrGeneric retType, Receiver receiver, String methodName, ArgumentList argumentList,
     		          RefTypeOrTPHOrWildcardOrGeneric receiverType, ArrayList<TypePlaceholder> signature, Token offset){
 		super(retType,offset);
 		this.arglist = argumentList;

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

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.target.generate;
 
 import de.dhbwstuttgart.bytecode.FunNGenerator;
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
 import de.dhbwstuttgart.environment.IByteArrayClassLoader;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.NullToken;
@@ -12,12 +11,14 @@ import de.dhbwstuttgart.syntaxtree.Record;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.target.Target;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.OutputGenerator;
 import de.dhbwstuttgart.target.tree.*;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
 import de.dhbwstuttgart.typeinference.result.*;
 
+import java.lang.annotation.Target;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -32,9 +33,9 @@ public class ASTToTargetAST {
 
     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;
-    public List<Generics> currentMethodOverloads;
+    public List<Generics> all;
+    //public Generics generics;
+    //public List<Generics> currentMethodOverloads;
 
     final Map<ClassOrInterface, Set<GenericTypeVar>> userDefinedGenerics = new HashMap<>();
     final Map<Method, Set<SignaturePair>> tphsInMethods = new HashMap<>();
@@ -54,24 +55,30 @@ public class ASTToTargetAST {
         return all.stream().map(generics -> new GenericsResult(generics.javaGenerics)).toList();
     }
 
-    public TargetExpression convert(Pattern pattern) {
-        var converter = new StatementToTargetExpression(this);
+    public TargetExpression convert(Pattern pattern, IGenerics generics) {
+        var converter = new StatementToTargetExpression(this, generics);
         pattern.accept(converter);
         return converter.result;
     }
 
     public record Generics(JavaGenerics javaGenerics, TxGenerics txGenerics) {
-    }
+        public Generics(JavaTXCompiler compiler, ResultSet set) {
+            this(new JavaGenerics(compiler, set), new TxGenerics(compiler, set));
+        }
 
+        public static Generics nullGenerics() {
+            return new Generics(null, new ResultSet(Set.of()));
+        }
+    }
 
     public IByteArrayClassLoader classLoader;
     protected SourceFile sourceFile;
 
-    public ASTToTargetAST(List<ResultSet> resultSets) {
-        this(null, resultSets);
+    public ASTToTargetAST(List<ResultSet> resultSets, IByteArrayClassLoader classLoader) {
+        this(null, resultSets, classLoader);
     }
-    public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets) {
-        this(compiler, resultSets, null, new ByteArrayClassLoader());
+    public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets, IByteArrayClassLoader classLoader) {
+        this(compiler, resultSets, null, classLoader);
     }
 
     public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets, SourceFile sourceFile, IByteArrayClassLoader classLoader) {
@@ -81,9 +88,8 @@ public class ASTToTargetAST {
 
         all = new ArrayList<>();
         for (var set : resultSets) {
-            all.add(new Generics(new JavaGenerics(this, set), new TxGenerics(this, set)));
+            all.add(new Generics(compiler, set));
         }
-        this.generics = all.get(0);
     }
 
     public void addSignaturePair(TypePlaceholder signature, RefTypeOrTPHOrWildcardOrGeneric parameter) {
@@ -92,27 +98,32 @@ public class ASTToTargetAST {
         tphsInMethods.put(currentMethod, set);
     }
 
-    Optional<Method> findMethod(ClassOrInterface owner, String name, List<TargetType> argumentList) {
+    public static Optional<Method> findMethod(ClassOrInterface owner, String name, List<TargetType> argumentList, JavaTXCompiler compiler) {
+        return findMethod(owner, name, argumentList, Generics.nullGenerics().javaGenerics(), compiler);
+    }
+
+    public static Optional<Method> findMethod(ClassOrInterface owner, String name, List<TargetType> argumentList, IGenerics generics, JavaTXCompiler compiler) {
         Optional<Method> method = Optional.empty();
         while (method.isEmpty()) {
-            method = owner.getMethods().stream().filter(m -> m.name.equals(name) && parameterEquals(m.getParameterList(), argumentList)).findFirst();
+            method = owner.getMethods().stream().filter(m -> m.name.equals(name) &&
+                    parameterEquals(m.getParameterList().getFormalparalist().stream().map(p -> generics.getTargetType(p.getType())).toList(), 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();
+    Optional<Constructor> findConstructor(ClassOrInterface owner, List<TargetType> argumentList, IGenerics generics) {
+        return owner.getConstructors().stream().filter(c ->
+                parameterEquals(c.getParameterList().getFormalparalist().stream().map(p -> generics.getTargetType(p.getType())).toList(), argumentList)).findFirst();
     }
 
-    boolean parameterEquals(ParameterList parameterList, List<TargetType> arguments) {
-        var pars = parameterList.getFormalparalist();
+    static boolean parameterEquals(List<TargetType> pars, List<TargetType> arguments) {
         if (pars.size() != arguments.size())
             return false;
 
         for (var i = 0; i < pars.size(); i++) {
-            var type1 = convert(pars.get(i).getType(), generics.javaGenerics);
+            var type1 = pars.get(i);
             var type2 = arguments.get(i);
             if (type1 instanceof TargetGenericType)
                 return true;
@@ -125,19 +136,19 @@ public class ASTToTargetAST {
         return true;
     }
 
-    Set<TargetGeneric> convert(Set<GenerateGenerics.Pair> result, GenerateGenerics generics) {
+    Set<TargetGeneric> convert(Set<GenerateGenerics.Pair> result, IGenerics generics) {
         return result.stream().map(p -> {
             if (p instanceof GenerateGenerics.PairLT pair) {
-                return new TargetGeneric(pair.left.resolve().getName(), convert(pair.right.resolve(), generics));
+                return new TargetGeneric(pair.left.resolve().getName(), convert(pair.right.resolve(), generics, compiler));
             } else if (p instanceof GenerateGenerics.PairEQ pair) {
-                return new TargetGeneric(pair.left.resolve().getName(), convert(pair.right, generics));
+                return new TargetGeneric(pair.left.resolve().getName(), convert(pair.right, generics, compiler));
             } else {
                 throw new IllegalArgumentException();
             }
         }).collect(Collectors.toSet());
     }
 
-    public List<TargetGeneric> convert(GenericTypeVar typeVar, GenerateGenerics generics) {
+    public List<TargetGeneric> convert(GenericTypeVar typeVar, IGenerics generics) {
         var ret = new ArrayList<TargetGeneric>();
         for (var bound : typeVar.getBounds()) {
             ret.add(new TargetGeneric(typeVar.getName(), generics.getTargetType(bound)));
@@ -146,6 +157,7 @@ public class ASTToTargetAST {
     }
 
     // This finds a common sealed interface type to group together methods that use different records
+    // This function should do matching or unification
     private List<ClassOrInterface> commonSuperInterfaceTypes(TargetType a, TargetType b) {
         if (a instanceof TargetGenericType && b instanceof TargetGenericType) return List.of(ASTFactory.createObjectClass());
         if (a instanceof TargetRefType ta && b instanceof TargetGenericType)
@@ -183,44 +195,28 @@ public class ASTToTargetAST {
         return List.of();
     }
 
-    // TODO This is ugly and probably doesn't work right
-    private boolean patternStrictlyEquals(TargetComplexPattern a, TargetComplexPattern b) {
-        if (!a.name().equals(b.name())) return false;
-        if (a.subPatterns().size() != b.subPatterns().size()) return false;
-        for (var i = 0; i < a.subPatterns().size(); i++) {
-            var p1 = a.subPatterns().get(i);
-            var p2 = b.subPatterns().get(i);
-            if (p1 instanceof TargetComplexPattern pc1 && p2 instanceof TargetComplexPattern pc2 &&
-                patternStrictlyEquals(pc1, pc2)) return false;
-            if (p1 instanceof TargetTypePattern pt1 && p2 instanceof TargetTypePattern pt2) {
-                if (pt1.type() instanceof TargetGenericType && pt2.type() instanceof TargetGenericType) continue;
-            }
-            if (!p1.type().equals(p2.type()) && commonSuperInterfaceTypes(p1.type(), p2.type()).isEmpty()) return false;
-        }
-        return true;
-    }
-
-    private boolean canCombine(TargetMethod m1, TargetMethod m2) {
-        if (!m1.name().equals(m2.name())) return false;
-        var s1 = m1.signature();
-        var s2 = m2.signature();
-        if (s1.parameters().size() != s2.parameters().size()) return false;
-        if (s1.parameters().isEmpty()) return false;
-        for (var i = 0; i < s1.parameters().size(); i++) {
-            var p1 = s1.parameters().get(i).pattern();
-            var p2 = s2.parameters().get(i).pattern();
+    private boolean canCombine(Signature m1, Signature m2) {
+        var pl1 = m1.java.parameters();
+        var pl2 = m2.java.parameters();
+        if (pl1.size() != pl2.size()) return false;
+        if (pl1.isEmpty()) return false;
+        for (var i = 0; i < pl1.size(); i++) {
+            var p1 = pl1.get(i).pattern();
+            var p2 = pl2.get(i).pattern();
+            // TPH <> RefType sind nicht unterscheidbar
             if (p1.type() instanceof TargetGenericType || p2.type() instanceof TargetGenericType) continue;
+            // Pattern(X) <> Pattern(Y) ist nicht unterscheidbar
             if (p1 instanceof TargetComplexPattern pc1 && p2 instanceof TargetComplexPattern pc2 &&
-                patternStrictlyEquals(pc1, pc2)) return false;
-            if (!p1.equals(p2) && commonSuperInterfaceTypes(p1.type(), p2.type()).isEmpty()) return false;
+                pc1.type().equals(pc2.type())) continue;
+            if (!p1.equals(p2)) return false;
         }
         return true;
     }
 
-    private record Combination(TargetMethod a, TargetMethod b) {
+    private record Combination(MethodWithTphs a, MethodWithTphs b) {
         @Override
         public boolean equals(Object o) {
-            if (!(o instanceof Combination(TargetMethod a1, TargetMethod b1))) return false;
+            if (!(o instanceof Combination(MethodWithTphs a1, MethodWithTphs b1))) return false;
             return this.a.equals(a1) && this.b.equals(b1) ||
                 this.a.equals(b1) && this.b.equals(a1);
         }
@@ -231,10 +227,10 @@ public class ASTToTargetAST {
         }
     }
 
-    public List<List<TargetMethod>> groupOverloads(ClassOrInterface input, List<Method> methods) {
-        var mapOfTargetMethods = new HashMap<Generics, TargetMethod[]>();
-        for (var generics : all) {
-            mapOfTargetMethods.put(generics, new TargetMethod[methods.size()]);
+    private List<List<MethodWithTphs>> groupOverloads(ClassOrInterface input, List<Method> methods) {
+        var mapOfTargetMethods = new HashMap<Generics, MethodWithTphs[]>();
+        for (var gen : all) {
+            mapOfTargetMethods.put(gen, new MethodWithTphs[methods.size()]);
         }
 
         for (var i = 0; i < methods.size(); i++) {
@@ -243,14 +239,14 @@ public class ASTToTargetAST {
             var methodsWithTphs = convert(input, method);
             for (var m : methodsWithTphs) {
                 var resultMethods = mapOfTargetMethods.get(m.generics);
-                resultMethods[i] = m.method;
+                resultMethods[i] = new MethodWithTphs(m.method, m.generics, m.signature);
             }
         }
-        /*System.out.println("============== INPUT ==============");
+        System.out.println("============== INPUT ==============");
         for (var m : mapOfTargetMethods.values()) {
-            for (var v : m) System.out.println(v.name() + " " + v.getSignature());
+            for (var v : m) if (v != null) System.out.println(v.signature.java.returnType() + " " + v.method.name + " " + v.signature.java().parameters());
             System.out.println();
-        }*/
+        }
 
         var allCombinations = new HashSet<Set<Combination>>();
         // Combine methods based on their signature and position in the result set
@@ -268,8 +264,8 @@ public class ASTToTargetAST {
 
                     var combinations = new HashSet<Combination>();
 
-                    if (canCombine(m1, m2)) {
-                        //System.out.println("     Combining " + m1.getSignature() + " and " + m2.getSignature());
+                    if (canCombine(m1.signature, m2.signature)) {
+                        //System.out.println("     Combining " + m1.signature.java.getSignature() + " and " + m2.signature.java.getSignature());
                         combinations.add(new Combination(m1, m2));
                         for (var j = 0; j < methods.size(); j++) {
                             if (j == i) continue;
@@ -278,10 +274,10 @@ public class ASTToTargetAST {
                             var m4 = resMeth1[j];
                             if (m4 == null) continue;
                             combinations.add(new Combination(m4, m3));
-                            //System.out.println("Also Combining " + m4.getSignature() + " and " + m3.getSignature());
+                            //System.out.println("Also Combining " + m4.signature.java.getSignature() + " and " + m3.signature.java.getSignature());
                         }
                     } else {
-                        //System.out.println(" Not Combining " + m1.getSignature() + " and " + m2.getSignature());
+                        //System.out.println(" Not Combining " + m1.signature.java.getSignature() + " and " + m2.signature.java.getSignature());
                     }
                     if (!combinations.isEmpty()) allCombinations.add(combinations);
                 }
@@ -291,14 +287,14 @@ public class ASTToTargetAST {
         if (allCombinations.isEmpty()) allCombinations.add(new HashSet<>());
 
         // Combine back into output format
-        var r0 = new HashSet<Set<TargetMethod>>();
+        var r0 = new HashSet<Set<MethodWithTphs>>();
         for (var combinations : allCombinations) {
-            var r1 = new HashSet<Set<TargetMethod>>();
+            var r1 = new HashSet<Set<MethodWithTphs>>();
             // This is used to weed out duplicates
-            var uniqued = new HashSet<TargetMethod>();
+            var uniqued = new HashSet<MethodWithTphs>();
             // We go over all methods in the result
             for (var g : all) for (var i = 0; i < methods.size(); i++) {
-                var r2 = new HashSet<TargetMethod>();
+                var r2 = new HashSet<MethodWithTphs>();
                 var m = mapOfTargetMethods.get(g)[i];
                 if (m == null) continue;
                 if (!uniqued.contains(m)) {
@@ -338,15 +334,16 @@ public class ASTToTargetAST {
 
         var result = r0.stream().map(l -> l.stream().toList()).toList();
 
-        Target.logger.info("============== OUTPUT ==============");
-        for (var l : result) {
-            for (var m : l) Target.logger.info(m.name() + " " + m.getSignature());
-            Target.logger.info("");
-        }
+        //System.out.println("============== OUTPUT ==============");
+        //for (var l : result) {
+        //    for (var m : l) System.out.println(m.method.name + " " + m.signature.java.getSignature());
+        //    System.out.println();
+        //}
         return result;
     }
 
     public TargetStructure convert(ClassOrInterface input) {
+        var generics = all.getFirst();
         Set<TargetGeneric> javaGenerics = new HashSet<>();
         Set<TargetGeneric> txGenerics = new HashSet<>();
 
@@ -359,7 +356,7 @@ public class ASTToTargetAST {
                 var next = genericsIter.next();
                 userDefinedGenerics.add(next);
                 // TODO Support multiple bounds
-                javaGenerics.add(new TargetGeneric(next.getName(), convert(next.getBounds().get(0))));
+                javaGenerics.add(new TargetGeneric(next.getName(), convert(next.getBounds().getFirst(), generics.javaGenerics, compiler)));
             }
         } else {
             this.userDefinedGenerics.put(input, new HashSet<>());
@@ -370,31 +367,44 @@ public class ASTToTargetAST {
 
         TargetBlock fieldInitializer = null;
         if (input.getfieldInitializations().isPresent())
-            fieldInitializer = convert(input.getfieldInitializations().get().block);
+            fieldInitializer = convert(input.getfieldInitializations().get().block, generics.javaGenerics);
         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 fields = input.getFieldDecl().stream().map(this::convert).toList();
+        var superInterfaces = input.getSuperInterfaces().stream().map(clazz -> convert(clazz, generics.javaGenerics, compiler)).toList();
+        var constructors = input.getConstructors().stream().map(constructor -> this.convert(input, constructor, finalFieldInitializer, generics)).flatMap(List::stream).toList();
+        var fields = input.getFieldDecl().stream().map(f -> convert(f, generics.javaGenerics)).toList();
         var methods = groupOverloads(input, input.getMethods()).stream().map(m -> generatePatternOverloads(input, m)).flatMap(List::stream)
                 .collect(Collectors.toSet()).stream().toList(); // Unique generated methods
 
         TargetMethod staticConstructor = null;
-        if (input.getStaticInitializer().isPresent())
-            staticConstructor = this.convert(input, input.getStaticInitializer().get()).stream().findFirst().orElseThrow().method;
+        if (input.getStaticInitializer().isPresent()) {
+            var init = this.convert(input, input.getStaticInitializer().get()).stream().findFirst().orElseThrow();
+            staticConstructor = this.convert(init, init.generics.javaGenerics);
+        }
 
         if (input instanceof Record)
             return new TargetRecord(input.getModifiers(), input.getClassName(), javaGenerics, txGenerics, superInterfaces, constructors, staticConstructor, fields, methods);
         else if (input.isInterface())
             return new TargetInterface(input.getModifiers(), input.getClassName(), javaGenerics, txGenerics, methods, superInterfaces, staticConstructor);
-        else return new TargetClass(input.getModifiers(), input.getClassName(), convert(input.getSuperClass(), generics.javaGenerics), javaGenerics, txGenerics, superInterfaces, constructors, staticConstructor, fields, methods);
+        else return new TargetClass(input.getModifiers(), input.getClassName(), convert(input.getSuperClass(), generics.javaGenerics, compiler), javaGenerics, txGenerics, superInterfaces, constructors, staticConstructor, fields, methods);
     }
 
-    public List<MethodParameter> convert(ParameterList input, GenerateGenerics generics) {
+    public List<MethodParameter> convert(ParameterList input) {
         var res = new ArrayList<MethodParameter>();
         for (var i = 0; i < input.getFormalparalist().size(); i++) {
             var param = input.getFormalparalist().get(i);
-            var pattern = (TargetPattern) convert(param);
+            var pattern = (TargetPattern) convert(param, Generics.nullGenerics().javaGenerics);
+            if (pattern instanceof TargetComplexPattern) pattern = pattern.withName("__var" + i);
+            res.add(new MethodParameter(pattern));
+        }
+        return res;
+    }
+
+    public List<MethodParameter> convert(ParameterList input, IGenerics generics) {
+        var res = new ArrayList<MethodParameter>();
+        for (var i = 0; i < input.getFormalparalist().size(); i++) {
+            var param = input.getFormalparalist().get(i);
+            var pattern = (TargetPattern) convert(param, generics);
             if (pattern instanceof TargetComplexPattern) pattern = pattern.withName("__var" + i);
             res.add(new MethodParameter(pattern));
         }
@@ -405,7 +415,7 @@ 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(ClassOrInterface clazz, IGenerics 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()) {
@@ -423,7 +433,7 @@ public class ASTToTargetAST {
         return convertedGenerics;
     }
 
-    private List<TargetConstructor> convert(ClassOrInterface currentClass, Constructor input, TargetBlock fieldInitializer) {
+    private List<TargetConstructor> convert(ClassOrInterface currentClass, Constructor input, TargetBlock fieldInitializer, Generics generics) {
         generics = all.get(0);
         List<TargetConstructor> result = new ArrayList<>();
         Set<List<MethodParameter>> parameterSet = new HashSet<>();
@@ -431,15 +441,15 @@ public class ASTToTargetAST {
 
         for (var s : all) {
             generics = s;
-            var javaGenerics = this.generics.javaGenerics.generics(currentClass, input);
-            var txGenerics = this.generics.txGenerics.generics(currentClass, input);
-            List<MethodParameter> params = convert(input.getParameterList(), this.generics.javaGenerics);
+            var javaGenerics = generics.javaGenerics.generics(currentClass, input);
+            var txGenerics = generics.txGenerics.generics(currentClass, input);
+            List<MethodParameter> params = convert(input.getParameterList(), generics.javaGenerics);
             if (parameterSet.stream().noneMatch(p -> p.equals(params))) {
-                List<MethodParameter> txParams = convert(input.getParameterList(), this.generics.txGenerics);
+                List<MethodParameter> txParams = convert(input.getParameterList(), generics.txGenerics);
                 var javaMethodGenerics = collectMethodGenerics(currentClass, generics.javaGenerics(), javaGenerics, input);
                 var txMethodGenerics = collectMethodGenerics(currentClass, generics.txGenerics(), txGenerics, input);
 
-                result.add(new TargetConstructor(input.modifier, javaMethodGenerics, txMethodGenerics, params, txParams, convert(input.block), fieldInitializer));
+                result.add(new TargetConstructor(input.modifier, javaMethodGenerics, txMethodGenerics, params, txParams, convert(input.block, generics.javaGenerics), fieldInitializer));
                 parameterSet.add(params);
             }
         }
@@ -447,10 +457,13 @@ public class ASTToTargetAST {
         return result;
     }
 
+    private static int counter = 0;
     private String encodeName(String name, TargetMethod.Signature params) {
         var res = new StringBuilder();
         res.append(name);
         res.append('$');
+        res.append(counter++);
+        res.append('$');
         for (var param : params.parameters()) {
             encodeName(param.pattern(), res);
         }
@@ -526,12 +539,14 @@ public class ASTToTargetAST {
                 var j = 0;
                 for (var param : m.signature().parameters()) {
                     if (j >= patternsRec.size()) return true;
-                    if (!patternsRec.get(j).type().equals(param.pattern().type())) return false;
+                    if (!patternsRec.get(j).equals(param.pattern())) return false;
                     j++;
                 }
                 return true;
             }).toList();
 
+            //System.out.println(offset + " -> " + lastPattern);
+            //candidates.forEach(m -> System.out.println(m.getSignature()));
             var caseBody = generatePatternOverloadsRec(offset + 1, expr, params, patternsRec, candidates, classType);
             var body = new TargetBlock(List.of(caseBody));
             var case_ = new TargetSwitch.Case(List.of(lastPattern), body);
@@ -542,19 +557,14 @@ public class ASTToTargetAST {
         return new TargetSwitch(switchExpr, cases, null, true);
     }
 
-    private List<TargetMethod> generatePatternOverloads(ClassOrInterface clazz, List<TargetMethod> overloadedMethods) {
-        if (overloadedMethods.size() <= 1) return overloadedMethods;
+    private List<TargetMethod> generatePatternOverloads(ClassOrInterface clazz, List<MethodWithTphs> overloadedMethods) {
+        if (overloadedMethods.isEmpty()) return List.of();
         // Check if we have a pattern as a parameter
-        var firstMethod = overloadedMethods.getFirst();
-        var secondMethod = overloadedMethods.get(1);
-        if (firstMethod.signature().parameters().stream().noneMatch(mp -> mp.pattern() instanceof TargetComplexPattern)) return overloadedMethods;
-        // Rename existing methods
-
-        var res = new ArrayList<TargetMethod>();
-        for (var method : overloadedMethods) {
-            var name = encodeName(method.name(), method.signature());
-            res.add(new TargetMethod(method.access(), name, method.block(), method.signature(), method.txSignature()));
-        }
+        var firstMethod = convert(overloadedMethods.getFirst(), overloadedMethods.getFirst().generics.javaGenerics);
+        if (overloadedMethods.size() == 1) return List.of(firstMethod);
+        var secondMethod = convert(overloadedMethods.get(1), overloadedMethods.get(1).generics.javaGenerics);
+        if (firstMethod.signature().parameters().stream().noneMatch(mp -> mp.pattern() instanceof TargetComplexPattern))
+            return overloadedMethods.stream().map(m -> convert(m, m.generics.javaGenerics)).toList();
 
         var signatureParams = new ArrayList<MethodParameter>();
         for (var i = 0; i < firstMethod.signature().parameters().size(); i++) {
@@ -563,7 +573,7 @@ public class ASTToTargetAST {
             var t2 = secondMethod.signature().parameters().get(i).pattern().type();
             var commonSubTypes = new HashSet<>(commonSuperInterfaceTypes(t1, t2));
             for (var m : overloadedMethods.subList(2, overloadedMethods.size())) {
-                var t3 = m.signature().parameters().get(i).pattern().type();
+                var t3 = m.signature().java.parameters().get(i).pattern().type();
                 commonSubTypes.retainAll(commonSuperInterfaceTypes(t1, t3));
             }
             if (commonSubTypes.size() > 1) throw new DebugException("Invalid overload");
@@ -578,9 +588,28 @@ public class ASTToTargetAST {
             signatureParams.add(new MethodParameter(new TargetRefType(superType.getClassName().toString()), name));
         }
 
+        // Rename existing methods
+
+        var res = new ArrayList<TargetMethod>();
+        for (var method : overloadedMethods) {
+            var name = encodeName(method.method.name, method.signature.java);
+
+            var generics = new OverlayGenerics(method.generics.javaGenerics, this);
+            var m = overloadedMethods.getFirst();
+            var params = m.method.getParameterList().getFormalparalist();
+            for (var i = 0; i < params.size(); i++) {
+                var param = params.get(i);
+                if (param.getType() instanceof TypePlaceholder tph) {
+                    generics.addOverlay(tph, signatureParams.get(i).pattern().type());
+                }
+            }
+            var tMethod = convert(method, generics);
+            res.add(new TargetMethod(tMethod.access(), name, tMethod.block(), tMethod.signature(), tMethod.txSignature()));
+        }
+
         var commonSubTypes = new HashSet<>(commonSuperInterfaceTypes(firstMethod.signature().returnType(), secondMethod.signature().returnType()));
         for (var m : overloadedMethods.subList(2, overloadedMethods.size())) {
-            commonSubTypes.retainAll(commonSuperInterfaceTypes(firstMethod.signature().returnType(), m.signature().returnType()));
+            commonSubTypes.retainAll(commonSuperInterfaceTypes(firstMethod.signature().returnType(), m.signature().java.returnType()));
         }
         var returnType = commonSubTypes.isEmpty() ? TargetType.Object : new TargetRefType(commonSubTypes.iterator().next().getClassName().toString());
 
@@ -601,7 +630,7 @@ public class ASTToTargetAST {
     }
 
     private Expression makeRecordSwitch(RefTypeOrTPHOrWildcardOrGeneric returnType, ParameterList params, List<Method> overloadedMethods) {
-        var param = params.getFormalparalist().get(0);
+        var param = params.getFormalparalist().getFirst();
         assert param instanceof RecordPattern; // TODO
 
         var cases = new ArrayList<SwitchBlock>();
@@ -621,7 +650,7 @@ public class ASTToTargetAST {
         return swtch;
     }
 
-    private Optional<Method> findSuperMethodToOverride(ClassOrInterface currentClass, String name, List<MethodParameter> params) {
+    private Optional<Method> findSuperMethodToOverride(ClassOrInterface currentClass, String name, List<MethodParameter> params, IGenerics generics) {
         var superClass = compiler.getClass(currentClass.getSuperClass().getName());
         var methodStream = superClass.getMethods().stream();
         for (var superInterface : currentClass.getSuperInterfaces()) {
@@ -634,131 +663,114 @@ public class ASTToTargetAST {
             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());
+                var b = convert(sParams.getFormalparalist().get(i).getType(), generics, compiler);
                 if (!Objects.equals(a, b)) return false;
             }
             return true;
         }).findFirst();
     }
 
-    record MethodWithTphs(TargetMethod method, Generics generics, List<SignaturePairTarget> args) {
+    record MethodWithTphs(Method method, Generics generics, Signature signature) {
         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
             if (!(o instanceof MethodWithTphs that)) return false;
-            return Objects.equals(method, that.method) && Objects.equals(args, that.args);
+            return Objects.equals(method, that.method) && Objects.equals(signature, that.signature);
         }
 
         @Override
         public int hashCode() {
-            return Objects.hash(method, args);
+            return Objects.hash(method, signature);
         }
     }
 
+    private TargetMethod convert(MethodWithTphs mtph, IGenerics generics) {
+        return new TargetMethod(mtph.method.modifier, mtph.method.name, convert(mtph.method.block, generics), mtph.signature.java(), mtph.signature.tx());
+    }
+
     record Signature(TargetMethod.Signature java, TargetMethod.Signature tx, Generics generics) {}
 
     private List<MethodWithTphs> convert(ClassOrInterface currentClass, Method method) {
-        generics = all.getFirst();
         List<MethodWithTphs> result = new ArrayList<>();
         this.currentMethod = method;
 
         List<Signature> signatures = new ArrayList<>();
-        HashMap<TargetMethod.Signature, List<Generics>> collectedGenerics = new HashMap<>();
-
-        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);
-            var superMethod = findSuperMethodToOverride(currentClass, method.getName(), params);
+        for (var generics : all) {
+            var javaGenerics = generics.javaGenerics.generics(currentClass, method);
+            var txGenerics = generics.txGenerics.generics(currentClass, method);
+            List<MethodParameter> params = convert(method.getParameterList(), generics.javaGenerics);
+            var returnType = convert(method.getReturnType(), generics.javaGenerics, compiler);
+            var superMethod = findSuperMethodToOverride(currentClass, method.getName(), params, generics.javaGenerics);
             if (superMethod.isPresent()) {
                 // If we find a super method to override, use its parameters and return types
-                var newReturnType = convert(superMethod.get().getReturnType(), this.generics.javaGenerics);
+                var newReturnType = convert(superMethod.get().getReturnType(), generics.javaGenerics, compiler);
                 if (newReturnType instanceof TargetPrimitiveType && TargetType.toPrimitive(returnType).equals(newReturnType)) {
                     returnType = newReturnType;
-                    params = convert(superMethod.get().getParameterList(), method.getParameterList(), this.generics.javaGenerics);
+                    params = convert(superMethod.get().getParameterList(), method.getParameterList(), generics.javaGenerics);
                 }
             }
 
-            List<MethodParameter> txParams = convert(method.getParameterList(), this.generics.txGenerics);
+            List<MethodParameter> txParams = convert(method.getParameterList(), 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));
+            System.out.println(javaSignature.getDescriptor());
+            var txSignature = new TargetMethod.Signature(txMethodGenerics, txParams, convert(method.getReturnType(), generics.txGenerics, compiler));
 
             signatures.add(new Signature(javaSignature, txSignature, generics));
-            var listOfGenerics = collectedGenerics.getOrDefault(javaSignature, new ArrayList<>());
-            listOfGenerics.add(generics);
-            collectedGenerics.put(javaSignature, listOfGenerics);
         }
 
         for (var signature : signatures) {
-            generics = signature.generics;
-            currentMethodOverloads = collectedGenerics.get(signature.java);
-
-            var newMethod = new TargetMethod(method.modifier, method.name, convert(method.block), signature.java, signature.tx);
-            var concreteParams = tphsInMethods.getOrDefault(method, new HashSet<>()).stream().map(sig -> new SignaturePairTarget(convert(sig.signature), convert(sig.parameter))).toList();
-
-            result.add(new MethodWithTphs(newMethod, generics, concreteParams));
+            result.add(new MethodWithTphs(method, signature.generics, signature));
         }
 
         return result;
     }
 
-    private List<MethodParameter> convert(ParameterList superList, ParameterList paraList, JavaGenerics generics) {
+    private List<MethodParameter> convert(ParameterList superList, ParameterList paraList, IGenerics generics) {
         var list = new ArrayList<MethodParameter>();
         for (var i = 0; i < paraList.getFormalparalist().size(); i++) {
             var param = paraList.getParameterAt(i);
-            var pattern = (TargetPattern) convert(param);
+            var pattern = (TargetPattern) convert(param, generics);
             if (pattern instanceof TargetComplexPattern) pattern = pattern.withName("__var" + i);
-            list.add(new MethodParameter(pattern).withType(convert(superList.getParameterAt(i).getType(), generics)));
+            list.add(new MethodParameter(pattern).withType(convert(superList.getParameterAt(i).getType(), generics, compiler)));
         }
         return list;
     }
 
-    protected TargetSwitch.Case convert(SwitchBlock block) {
-        return new TargetSwitch.Case(block.getLabels().stream().map(this::convert).toList(), convert((Block) block), block.isExpression);
+    protected TargetSwitch.Case convert(SwitchBlock block, IGenerics generics) {
+        return new TargetSwitch.Case(block.getLabels().stream().map(s -> convert(s, generics)).toList(), convert((Block) block, generics), block.isExpression);
     }
 
-    protected TargetBlock convert(Block block) {
+    protected TargetBlock convert(Block block, IGenerics generics) {
         if (block == null) return null;
-        return new TargetBlock(block.statements.stream().map(this::convert).toList());
+        return new TargetBlock(block.statements.stream().map(s -> convert(s, generics)).toList());
     }
 
-    protected TargetBlock convertWrapInBlock(Expression expression) {
-        var res = convert(expression);
+    protected TargetBlock convertWrapInBlock(Expression expression, IGenerics generics) {
+        var res = convert(expression, generics);
         if (!(res instanceof TargetBlock))
             return new TargetBlock(List.of(res));
         return (TargetBlock) res;
     }
 
-    protected TargetExpression convert(Expression expr) {
-        var converter = new StatementToTargetExpression(this);
+    protected TargetExpression convert(Expression expr, IGenerics generics) {
+        var converter = new StatementToTargetExpression(this, generics);
         expr.accept(converter);
         return converter.result;
     }
 
-    private TargetField convert(Field input) {
-        return new TargetField(input.modifier, convert(input.getType(), generics.javaGenerics), input.getName());
-    }
-
-    private final Map<String, FunNGenerator.GenericParameters> usedFunN = new HashMap<>();
-    private final Set<Integer> usedFunNSuperTypes = new HashSet<>();
-
-    public Map<String, byte[]> auxiliaries = new HashMap<>();
-
-    public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input) {
-        return convert(input, generics.javaGenerics);
+    private TargetField convert(Field input, IGenerics generics) {
+        return new TargetField(input.modifier, convert(input.getType(), generics, compiler), input.getName());
     }
 
     private static void collectArguments(TargetSpecializedType tspec, List<TargetType> newParams) {
         for (var i = 0; i < tspec.params().size(); i++) {
             var param = tspec.params().get(i);
             if (param instanceof TargetSpecializedType fn) {
-                collectArguments(tspec, newParams);
+                collectArguments(fn, newParams);
             } else {
                 newParams.add(param);
             }
@@ -782,7 +794,15 @@ public class ASTToTargetAST {
         return TargetFunNType.fromParams(params, filteredParams, gep.getReturnType() != null ? 1 : 0);
     }
 
+    private FunNGenerator.GenericParameters convertToParameters(TargetFunNType input) {
+        return null;
+    }
+
     private boolean isSubtype(TargetType test, TargetType other) {
+        if (other.equals(TargetType.Object)) return true;
+        if (test instanceof TargetFunNType tfun && other instanceof TargetFunNType ofun)
+            return isSubtype(new FunNGenerator.GenericParameters(tfun), new FunNGenerator.GenericParameters(ofun));
+
         var testClass = compiler.getClass(new JavaClassName(test.name()));
         var otherClass = compiler.getClass(new JavaClassName(other.name()));
         if (testClass == null) return false;
@@ -810,28 +830,30 @@ public class ASTToTargetAST {
     }
 
     public void generateFunNTypes() {
-        for (var entry : usedFunN.entrySet()) {
+        for (var entry : compiler.usedFunN.entrySet()) {
             var gep = entry.getValue();
-            var superInterfaces = usedFunN.values().stream()
+            var superInterfaces = compiler.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);
+            compiler.auxiliaries.put(entry.getKey(), code);
         }
     }
 
-    protected TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, GenerateGenerics generics) {
+    // FIXME This method shouldn't be used
+    @Deprecated
+    public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input) {
+        return convert(input, all.getFirst().javaGenerics, compiler);
+    }
+
+    public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, IGenerics generics) {
+        return convert(input, generics, compiler);
+    }
+
+    static public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, IGenerics generics, JavaTXCompiler compiler) {
         return input.acceptTV(new TypeVisitor<>() {
             @Override
             public TargetType visit(RefType refType) {
@@ -843,31 +865,31 @@ public class ASTToTargetAST {
                 }
 
                 var params = refType.getParaList().stream().map(type -> {
-                    return convert(type, generics);
+                    return convert(type, generics, compiler);
                 }).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), returnType);
-                    if (!usedFunNSuperTypes.contains(params.size())) {
-                        usedFunNSuperTypes.add(params.size());
+                    if (!compiler.usedFunNSuperTypes.contains(params.size())) {
+                        compiler.usedFunNSuperTypes.add(params.size());
                         var code = FunNGenerator.generateSuperBytecode(params.size() - 1, returnType != null ? 1 : 0);
                         var superClassName = FunNGenerator.getSuperClassName(params.size() - 1, returnType != null ? 1 : 0);
                         try {
-                            classLoader.findClass(superClassName);
+                            compiler.classLoader.findClass(superClassName);
                         } catch (ClassNotFoundException e) {
                             try {
-                                classLoader.loadClass(code);
+                                compiler.classLoader.loadClass(superClassName, code);
                             } catch (LinkageError ignored) {}
                         }
-                        auxiliaries.put(superClassName, code);
+                        compiler.auxiliaries.put(superClassName, code);
                     }
                     FunNGenerator.GenericParameters gep = null;
-                    if (!usedFunN.containsKey(className)) {
+                    if (!compiler.usedFunN.containsKey(className)) {
                         gep = new FunNGenerator.GenericParameters(params, returnType != null ? 1 : 0);
-                        usedFunN.put(className, gep);
+                        compiler.usedFunN.put(className, gep);
                     } else {
-                        gep = usedFunN.get(className);
+                        gep = compiler.usedFunN.get(className);
                     }
                     return flattenFunNType(params, gep);
                 }
@@ -876,7 +898,7 @@ public class ASTToTargetAST {
 
             @Override
             public TargetType visit(SuperWildcardType superWildcardType) {
-                return new TargetSuperWildcard(convert(superWildcardType.getInnerType(), generics));
+                return new TargetSuperWildcard(convert(superWildcardType.getInnerType(), generics, compiler));
             }
 
             @Override
@@ -886,7 +908,7 @@ public class ASTToTargetAST {
 
             @Override
             public TargetType visit(ExtendsWildcardType extendsWildcardType) {
-                return new TargetExtendsWildcard(convert(extendsWildcardType.getInnerType(), generics));
+                return new TargetExtendsWildcard(convert(extendsWildcardType.getInnerType(), generics, compiler));
             }
 
             @Override

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

@@ -18,9 +18,9 @@ import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public abstract class GenerateGenerics {
+public abstract class GenerateGenerics implements IGenerics {
 
-    private final ASTToTargetAST astToTargetAST;
+    private final JavaTXCompiler compiler;
 
     public class TPH {
         private final TypePlaceholder wrap;
@@ -136,8 +136,8 @@ public abstract class GenerateGenerics {
     Map<TPH, RefTypeOrTPHOrWildcardOrGeneric> concreteTypes = new HashMap<>();
     Map<TypePlaceholder, TypePlaceholder> equality = new HashMap<>();
 
-    GenerateGenerics(ASTToTargetAST astToTargetAST, ResultSet constraints) {
-        this.astToTargetAST = astToTargetAST;
+    GenerateGenerics(JavaTXCompiler compiler, ResultSet constraints) {
+        this.compiler = compiler;
         for (var constraint : constraints.results) {
             if (constraint instanceof PairTPHsmallerTPH p) {
                 Target.logger.info(p.left + " " + p.left.getVariance());
@@ -153,22 +153,12 @@ public abstract class GenerateGenerics {
         Target.logger.info("Simplified constraints: " + simplifiedConstraints);
     }
 
-    /*public record GenericsState(Map<TPH, RefTypeOrTPHOrWildcardOrGeneric> concreteTypes, Map<TypePlaceholder, TypePlaceholder> equality) {}
+    public record GenericsState(Map<TPH, RefTypeOrTPHOrWildcardOrGeneric> concreteTypes, Map<TypePlaceholder, TypePlaceholder> equality) {}
 
     public GenericsState store() {
         return new GenericsState(new HashMap<>(concreteTypes), new HashMap<>(equality));
     }
 
-    public void restore(GenericsState state) {
-        this.concreteTypes = state.concreteTypes;
-        this.equality = state.equality;
-    }
-
-    public void addOverlay(TypePlaceholder from, RefTypeOrTPHOrWildcardOrGeneric to) {
-        if (to instanceof TypePlaceholder t) equality.put(from, t);
-        else if (to instanceof RefType t) concreteTypes.put(new TPH(from), t);
-    }*/
-
     Set<TPH> findTypeVariables(ParameterList params) {
         var res = new HashSet<TPH>();
         for (var param : params.getFormalparalist()) {
@@ -283,7 +273,7 @@ public abstract class GenerateGenerics {
             Set<TPH> typeVariablesOfClass,
             Set<Pair> result
     ) {
-        var userDefinedGenericsOfClass = astToTargetAST.userDefinedGenerics.get(owner);
+        var userDefinedGenericsOfClass = owner.getUserDefinedGenerics();
 
         // Type variables with bounds that are also type variables of the method
         for (var typeVariable : new HashSet<>(typeVariables)) {
@@ -331,7 +321,7 @@ public abstract class GenerateGenerics {
 
                     if (methodCall.receiver instanceof ExpressionReceiver expressionReceiver) {
                         if (expressionReceiver.expr instanceof This) {
-                            var optMethod = astToTargetAST.findMethod(owner, methodCall.name, methodCall.signatureArguments().stream().map(astToTargetAST::convert).toList());
+                            var optMethod = ASTToTargetAST.findMethod(owner, methodCall.name, methodCall.signatureArguments().stream().map(x -> getTargetType(x)).toList(), GenerateGenerics.this, compiler);
                             if (optMethod.isEmpty()) return;
                             var method2 = optMethod.get();
                             Target.logger.info("In: " + method.getName() + " Method: " + method2.getName());
@@ -541,8 +531,6 @@ public abstract class GenerateGenerics {
             });
     }
 
-    abstract void generics(ClassOrInterface owner, Method method, Set<Pair> result, Set<TPH> javaTypeVariablesOfClass);
-
     Set<Pair> family(ClassOrInterface owner, Method method) {
         Set<Pair> result = new HashSet<>();
         if (familyOfMethods.containsKey(method))
@@ -566,7 +554,8 @@ public abstract class GenerateGenerics {
         return result;
     }
 
-    Set<Pair> generics(ClassOrInterface owner, Method method) {
+    @Override
+    public Set<Pair> generics(ClassOrInterface owner, Method method) {
         if (computedGenericsOfMethods.containsKey(method)) {
             var cached = computedGenericsOfMethods.get(method);
             Target.logger.info("Cached " + method.getName() + ": " + cached);
@@ -654,8 +643,10 @@ public abstract class GenerateGenerics {
     }
 
     abstract void generics(ClassOrInterface classOrInterface, Set<Pair> result, Set<TPH> referenced);
+    abstract void generics(ClassOrInterface owner, Method method, Set<Pair> result, Set<TPH> referenced);
 
-    Set<Pair> generics(ClassOrInterface classOrInterface) {
+    @Override
+    public Set<Pair> generics(ClassOrInterface classOrInterface) {
         if (computedGenericsOfClasses.containsKey(classOrInterface))
             return computedGenericsOfClasses.get(classOrInterface);
 
@@ -766,7 +757,7 @@ public abstract class GenerateGenerics {
         }
 
         for (var pair : elementsToAddToEquality) {
-            Target.logger.info(pair);
+            //System.out.println(pair);
             addToEquality(pair.left, pair.right, referenced);
         }
     }
@@ -919,7 +910,7 @@ public abstract class GenerateGenerics {
                     }
                 }
                 if (infima.size() > 1) {
-                    Target.logger.info(infima);
+                    //System.out.println(infima);
                     for (var pair : infima) {
                         var returnTypes = findTypeVariables(method.getReturnType());
                         var chain = findConnectionToReturnType(returnTypes, input, new HashSet<>(), pair.left);
@@ -990,7 +981,13 @@ public abstract class GenerateGenerics {
         } while (foundInfima);
     }
 
-    RefTypeOrTPHOrWildcardOrGeneric getType(RefTypeOrTPHOrWildcardOrGeneric type) {
+    @Override
+    public TypePlaceholder getEqualType(TypePlaceholder tph) {
+        return this.equality.getOrDefault(tph, tph);
+    }
+
+    @Override
+    public RefTypeOrTPHOrWildcardOrGeneric getType(RefTypeOrTPHOrWildcardOrGeneric type) {
         if (type instanceof TypePlaceholder tph) {
             if (equality.containsKey(tph)) {
                 return getType(equality.get(tph));
@@ -1000,15 +997,16 @@ public abstract class GenerateGenerics {
         return type;
     }
 
-    TargetType getTargetType(RefTypeOrTPHOrWildcardOrGeneric in) {
+    @Override
+    public TargetType getTargetType(RefTypeOrTPHOrWildcardOrGeneric in) {
         if (in instanceof TypePlaceholder tph) {
             if (equality.containsKey(tph)) {
                 return getTargetType(equality.get(tph));
             }
             var type = concreteTypes.get(new TPH(tph));
             if (type == null) return new TargetGenericType(tph.getName());
-            return astToTargetAST.convert(type, this);
+            return ASTToTargetAST.convert(type, this, compiler);
         }
-        return astToTargetAST.convert(in, this);
+        return ASTToTargetAST.convert(in, this, compiler);
     }
 }

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

@@ -9,21 +9,20 @@ import de.dhbwstuttgart.target.tree.type.TargetType;
 import java.util.*;
 
 public class GenericsResult {
-    private final GenerateGenerics generics;
+    private final IGenerics generics;
 
-    GenericsResult(GenerateGenerics generics) {
+    GenericsResult(IGenerics generics) {
         this.generics = generics;
     }
 
     public GenericsResultSet get(ClassOrInterface clazz) {
-        var generics = this.generics.computedGenericsOfClasses.get(clazz);
-        return new GenericsResultSet(generics, this.generics.equality);
+        var generics = this.generics.generics(clazz);
+        return new GenericsResultSet(generics, this.generics);
     }
 
-    // TODO Compute generics if not present?
-    public GenericsResultSet get(Method method) {
-        var generics = this.generics.computedGenericsOfMethods.get(method);
-        return new GenericsResultSet(generics, this.generics.equality);
+    public GenericsResultSet get(ClassOrInterface clazz, Method method) {
+        var generics = this.generics.generics(clazz, method);
+        return new GenericsResultSet(generics, this.generics);
     }
 
     public BoundsList getBounds(RefTypeOrTPHOrWildcardOrGeneric type, ClassOrInterface clazz) {
@@ -34,7 +33,7 @@ public class GenericsResult {
         var resolvedType = resolve(type);
         type = resolvedType;
         if (type instanceof TypePlaceholder) {
-            var methodGenerics = get(method);
+            var methodGenerics = get(clazz, method);
             var classGenerics = get(clazz);
             List<Bound> result = new ArrayList<>();
 
@@ -69,8 +68,4 @@ public class GenericsResult {
             return this.generics.getType(tph);
         return type;
     }
-
-    public TargetType resolveTarget(RefTypeOrTPHOrWildcardOrGeneric type) {
-        return this.generics.getTargetType(type);
-    }
 }

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

@@ -4,17 +4,18 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
 import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
 import de.dhbwstuttgart.typeinference.result.ResultPair;
+import org.antlr.v4.codegen.model.decl.ContextRuleListIndexedGetterDecl;
 
 import java.util.*;
 
 public class GenericsResultSet extends AbstractSet<GenerateGenerics.Pair> {
 
     final Set<GenerateGenerics.Pair> backing;
-    final Map<TypePlaceholder, TypePlaceholder> equality;
+    final IGenerics generics;
 
-    public GenericsResultSet(Set<GenerateGenerics.Pair> backing, Map<TypePlaceholder, TypePlaceholder> equality) {
+    public GenericsResultSet(Set<GenerateGenerics.Pair> backing, IGenerics generics) {
         this.backing = backing == null ? new HashSet<>() : new HashSet<>(backing);
-        this.equality = equality;
+        this.generics = generics;
     }
 
     @Override
@@ -28,7 +29,7 @@ public class GenericsResultSet extends AbstractSet<GenerateGenerics.Pair> {
     }
 
     public Optional<ResultPair<?, ?>> getResultPairFor(TypePlaceholder tph) {
-        var tph2 = equality.getOrDefault(tph, tph);
+        var tph2 = generics.getEqualType(tph);
         return this.stream().filter(pair -> {
             return pair.left.resolve().equals(tph2);
         }).findFirst().map(pair -> {

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

@@ -0,0 +1,22 @@
+package de.dhbwstuttgart.target.generate;
+
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.target.tree.type.TargetType;
+
+import java.util.Set;
+
+public interface IGenerics {
+
+    Set<GenerateGenerics.Pair> generics(ClassOrInterface classOrInterface);
+
+    Set<GenerateGenerics.Pair> generics(ClassOrInterface owner, Method method);
+
+    RefTypeOrTPHOrWildcardOrGeneric getType(RefTypeOrTPHOrWildcardOrGeneric type);
+
+    TypePlaceholder getEqualType(TypePlaceholder tph);
+
+    TargetType getTargetType(RefTypeOrTPHOrWildcardOrGeneric in);
+}

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

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.target.generate;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
@@ -7,8 +8,8 @@ import de.dhbwstuttgart.typeinference.result.ResultSet;
 import java.util.Set;
 
 final class JavaGenerics extends GenerateGenerics {
-    JavaGenerics(ASTToTargetAST astToTargetAST, ResultSet constraints) {
-        super(astToTargetAST, constraints);
+    JavaGenerics(JavaTXCompiler compiler, ResultSet constraints) {
+        super(compiler, constraints);
     }
 
     @Override

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

@@ -0,0 +1,60 @@
+package de.dhbwstuttgart.target.generate;
+
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.target.tree.type.TargetGenericType;
+import de.dhbwstuttgart.target.tree.type.TargetType;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class OverlayGenerics implements IGenerics {
+    private final IGenerics wrapped;
+    private final ASTToTargetAST converter;
+    private final Map<TypePlaceholder, TargetType> overlay;
+
+    public OverlayGenerics(IGenerics wrapped, ASTToTargetAST converter) {
+        this.wrapped = wrapped;
+        this.converter = converter;
+        this.overlay = new HashMap<>();
+    }
+
+    public void addOverlay(TypePlaceholder tph, TargetType type) {
+        this.overlay.put(tph, type);
+    }
+
+    @Override
+    public Set<GenerateGenerics.Pair> generics(ClassOrInterface classOrInterface) {
+        return wrapped.generics(classOrInterface);
+    }
+
+    @Override
+    public Set<GenerateGenerics.Pair> generics(ClassOrInterface owner, Method method) {
+        return wrapped.generics(owner, method);
+    }
+
+    @Override
+    public RefTypeOrTPHOrWildcardOrGeneric getType(RefTypeOrTPHOrWildcardOrGeneric type) {
+        return wrapped.getType(type);
+    }
+
+    @Override
+    public TypePlaceholder getEqualType(TypePlaceholder tph) {
+        return wrapped.getEqualType(tph);
+    }
+
+    @Override
+    public TargetType getTargetType(RefTypeOrTPHOrWildcardOrGeneric in) {
+        if (in instanceof TypePlaceholder tph) {
+            var overlay = this.overlay.get(tph);
+            if (overlay != null) return overlay;
+            var type = getType(tph);
+            if (type == null) return new TargetGenericType(tph.getName());
+            return wrapped.getTargetType(type);
+        }
+        return ASTToTargetAST.convert(in, this, converter.compiler);
+    }
+}

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

@@ -8,24 +8,26 @@ import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.target.Target;
 import de.dhbwstuttgart.target.tree.MethodParameter;
 import de.dhbwstuttgart.target.tree.TargetMethod;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
 
 import java.lang.reflect.Modifier;
+import java.sql.Array;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
 public class StatementToTargetExpression implements ASTVisitor {
 
-    public StatementToTargetExpression(ASTToTargetAST converter) {
+    public StatementToTargetExpression(ASTToTargetAST converter, IGenerics generics) {
         this.converter = converter;
+        this.generics = generics;
     }
 
     public TargetExpression result;
+    private final IGenerics generics;
     private final ASTToTargetAST converter;
 
     @Override
@@ -33,105 +35,125 @@ public class StatementToTargetExpression implements ASTVisitor {
         throw new NotImplementedException();
     }
 
+    private class LambdaCaptureFinder extends TracingStatementVisitor {
+
+        // TODO The same mechanism is implemented in Codegen, maybe use it from there?
+        final Stack<Set<String>> localVariables = new Stack<>();
+        private final List<MethodParameter> parameters;
+        private final List<MethodParameter> captures;
+
+        LambdaCaptureFinder(List<MethodParameter> parameters, List<MethodParameter> captures) {
+            localVariables.push(new HashSet<>());
+            this.parameters = parameters;
+            this.captures = captures;
+        }
+
+        boolean hasLocalVar(String name) {
+            for (var localVariables : this.localVariables) {
+                if (localVariables.contains(name))
+                    return true;
+            }
+            return false;
+        }
+
+        @Override
+        public void visit(Block block) {
+            localVariables.push(new HashSet<>());
+            super.visit(block);
+            localVariables.pop();
+        }
+
+        @Override
+        public void visit(LocalVar localVar) {
+            super.visit(localVar);
+            var capture = new MethodParameter(new TargetTypePattern(converter.convert(localVar.getType(), generics), localVar.name));
+            if (!hasLocalVar(localVar.name) && !parameters.contains(capture) && !captures.contains(capture))
+                captures.add(capture);
+        }
+
+        @Override
+        public void visit(LocalVarDecl varDecl) {
+            var localVariables = this.localVariables.peek();
+            localVariables.add(varDecl.getName());
+        }
+
+        @Override
+        public void visit(LambdaExpression lambda) {
+            var newCaptures = new ArrayList<MethodParameter>();
+            var captureFinder = new LambdaCaptureFinder(createParameters(lambda), newCaptures);
+            lambda.methodBody.accept(captureFinder);
+            newCaptures.removeAll(parameters);
+            captures.addAll(newCaptures);
+        }
+    }
+
+    private List<MethodParameter> createParameters(LambdaExpression lambda) {
+        return StreamSupport.stream(lambda.params.spliterator(), false)
+            .map(p -> (FormalParameter) p)
+            .map(p -> new MethodParameter(new TargetTypePattern(converter.convert(p.getType(), generics), p.getName())))
+            .toList();
+    }
+
     @Override
     public void visit(LambdaExpression lambdaExpression) {
-        var parameters = StreamSupport.stream(lambdaExpression.params.spliterator(), false)
-                .map(p -> (FormalParameter) p)
-                .map(p -> new MethodParameter(new TargetTypePattern(converter.convert(p.getType()), p.getName())))
-                .toList();
-
+        var parameters = createParameters(lambdaExpression);
         List<MethodParameter> captures = new ArrayList<>();
-        lambdaExpression.methodBody.accept(new TracingStatementVisitor() {
-            // TODO The same mechanism is implemented in Codegen, maybe use it from there?
-            final Stack<Set<String>> localVariables = new Stack<>();
-            {
-                localVariables.push(new HashSet<>());
-            }
+        var visitor = new LambdaCaptureFinder(parameters, captures);
+        lambdaExpression.methodBody.accept(visitor);
 
-            boolean hasLocalVar(String name) {
-                for (var localVariables : this.localVariables) {
-                    if (localVariables.contains(name))
-                        return true;
-                }
-                return false;
-            }
-
-            @Override
-            public void visit(Block block) {
-                localVariables.push(new HashSet<>());
-                super.visit(block);
-                localVariables.pop();
-            }
-
-            @Override
-            public void visit(LocalVar localVar) {
-                super.visit(localVar);
-                var capture = new MethodParameter(new TargetTypePattern(converter.convert(localVar.getType()), localVar.name));
-                if (!hasLocalVar(localVar.name) && !parameters.contains(capture) && !captures.contains(capture))
-                    captures.add(capture);
-            }
-
-            @Override
-            public void visit(LocalVarDecl varDecl) {
-                var localVariables = this.localVariables.peek();
-                localVariables.add(varDecl.getName());
-            }
-
-            @Override
-            public void visit(LambdaExpression lambda) {
-            } // Don't look at lambda expressions
-        });
-
-        TargetMethod.Signature signature = new TargetMethod.Signature(Set.of(), parameters, converter.convert(lambdaExpression.getReturnType()));;
-        var tpe = converter.convert(lambdaExpression.getType());
-        result = new TargetLambdaExpression(tpe, captures, signature, converter.convert(lambdaExpression.methodBody));
+        TargetMethod.Signature signature = new TargetMethod.Signature(Set.of(), parameters, converter.convert(lambdaExpression.getReturnType(), generics));;
+        var tpe = converter.convert(lambdaExpression.getType(), generics);
+        result = new TargetLambdaExpression(tpe, captures, signature, converter.convert(lambdaExpression.methodBody, this.generics));
     }
 
     @Override
     public void visit(Assign assign) {
         TargetExpression left;
         if (assign.lefSide instanceof AssignToLocal) {
-            left = converter.convert(((AssignToLocal) assign.lefSide).localVar);
+            left = converter.convert(((AssignToLocal) assign.lefSide).localVar, this.generics);
         } else {
-            left = converter.convert(((AssignToField) assign.lefSide).field);
+            left = converter.convert(((AssignToField) assign.lefSide).field, this.generics);
         }
 
-        result = new TargetAssign(converter.convert(assign.getType()), left, converter.convert(assign.rightSide));
+        result = new TargetAssign(converter.convert(assign.getType(), generics), left, converter.convert(assign.rightSide, this.generics));
     }
 
     @Override
     public void visit(BinaryExpr binary) {
         result = switch (binary.operation) {
-        case ADD -> new TargetBinaryOp.Add(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
-        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 OR -> new TargetBinaryOp.BOr(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));
-        case LESSEQUAL -> new TargetBinaryOp.LessOrEqual(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
-        case BIGGEREQUAL -> new TargetBinaryOp.GreaterOrEqual(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
-        case EQUAL -> new TargetBinaryOp.Equal(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
-        case NOTEQUAL -> new TargetBinaryOp.NotEqual(converter.convert(binary.getType()), converter.convert(binary.lexpr), converter.convert(binary.rexpr));
+        case ADD -> new TargetBinaryOp.Add(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case SUB -> new TargetBinaryOp.Sub(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case MUL -> new TargetBinaryOp.Mul(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case MOD -> new TargetBinaryOp.Rem(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case AND -> new TargetBinaryOp.BAnd(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case OR -> new TargetBinaryOp.BOr(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case XOR -> new TargetBinaryOp.XOr(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case DIV -> new TargetBinaryOp.Div(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case LESSTHAN -> new TargetBinaryOp.Less(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case BIGGERTHAN -> new TargetBinaryOp.Greater(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case LESSEQUAL -> new TargetBinaryOp.LessOrEqual(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case BIGGEREQUAL -> new TargetBinaryOp.GreaterOrEqual(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case EQUAL -> new TargetBinaryOp.Equal(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
+        case NOTEQUAL -> new TargetBinaryOp.NotEqual(converter.convert(binary.getType(), generics), converter.convert(binary.lexpr, this.generics), converter.convert(binary.rexpr, this.generics));
         };
     }
 
     @Override
     public void visit(BoolExpression bool) {
-        Target.logger.info("BoolExpression");
+        result = switch(bool.operation) {
+        case OR -> new TargetBinaryOp.Or(converter.convert(bool.getType(), generics), converter.convert(bool.lexpr, generics), converter.convert(bool.rexpr, generics));
+        case AND -> new TargetBinaryOp.And(converter.convert(bool.getType(), generics), converter.convert(bool.lexpr, generics), converter.convert(bool.rexpr, generics));
+        };
     }
 
     @Override
     public void visit(Block block) {
-        result = converter.convert(block);
+        result = converter.convert(block, generics);
     }
 
     @Override
     public void visit(CastExpr castExpr) {
-        result = new TargetCast(converter.convert(castExpr.getType()), converter.convert(castExpr.expr));
+        result = new TargetCast(converter.convert(castExpr.getType(), generics), converter.convert(castExpr.expr, generics));
     }
 
     @Override
@@ -142,46 +164,46 @@ public class StatementToTargetExpression implements ASTVisitor {
     @Override
     public void visit(FieldVar fieldVar) {
         var isStatic = false;
-        var type = converter.convert(fieldVar.receiver.getType());
+        var type = converter.convert(fieldVar.receiver.getType(), generics);
         var clazz = converter.compiler.getClass(new JavaClassName(type.name()));
         var field = clazz.getField(fieldVar.fieldVarName).orElseThrow();
-        result = new TargetFieldVar(converter.convert(fieldVar.getType()), type, Modifier.isStatic(field.modifier), converter.convert(fieldVar.receiver), fieldVar.fieldVarName);
+        result = new TargetFieldVar(converter.convert(fieldVar.getType(), generics), type, Modifier.isStatic(field.modifier), converter.convert(fieldVar.receiver, this.generics), fieldVar.fieldVarName);
     }
 
     @Override
     public void visit(ForStmt forStmt) {
         result = new TargetFor(
-                forStmt.initializer.stream().map(converter::convert).toList(),
-                forStmt.condition != null ? converter.convert(forStmt.condition) : null,
-                forStmt.loopExpr.stream().map(converter::convert).toList(),
-                converter.convertWrapInBlock(forStmt.block)
+                forStmt.initializer.stream().map(c -> converter.convert(c, generics)).toList(),
+                forStmt.condition != null ? converter.convert(forStmt.condition, generics) : null,
+                forStmt.loopExpr.stream().map(e -> converter.convert(e, generics)).toList(),
+                converter.convertWrapInBlock(forStmt.block, generics)
         );
     }
 
     @Override
     public void visit(ForEachStmt forEachStmt) {
-        result = new TargetForEach(converter.convert(forEachStmt.statement), converter.convert(forEachStmt.expression), converter.convertWrapInBlock(forEachStmt.block));
+        result = new TargetForEach(converter.convert(forEachStmt.statement, generics), converter.convert(forEachStmt.expression, generics), converter.convertWrapInBlock(forEachStmt.block, generics));
     }
 
     @Override
     public void visit(IfStmt ifStmt) {
-        result = new TargetIf(converter.convert(ifStmt.expr), converter.convertWrapInBlock(ifStmt.then_block), ifStmt.else_block != null ? converter.convertWrapInBlock(ifStmt.else_block) : null);
+        result = new TargetIf(converter.convert(ifStmt.expr, generics), converter.convertWrapInBlock(ifStmt.then_block, generics), ifStmt.else_block != null ? converter.convertWrapInBlock(ifStmt.else_block, generics) : null);
     }
 
     @Override
     public void visit(InstanceOf instanceOf) {
-        result = new TargetInstanceOf(converter.convert(instanceOf.getExpression()), converter.convert(instanceOf.getPattern()));
+        result = new TargetInstanceOf(converter.convert(instanceOf.getExpression(), generics), converter.convert(instanceOf.getPattern(), this.generics));
     }
 
     @Override
     public void visit(LocalVar localVar) {
-        result = new TargetLocalVar(converter.convert(localVar.getType()), localVar.name);
+        result = new TargetLocalVar(converter.convert(localVar.getType(), generics), localVar.name);
     }
 
     @Override
     public void visit(LocalVarDecl localVarDecl) {
         // TODO No value, is this correct?
-        result = new TargetVarDecl(converter.convert(localVarDecl.getType()), localVarDecl.getName(), null);
+        result = new TargetVarDecl(converter.convert(localVarDecl.getType(), generics), localVarDecl.getName(), null);
     }
 
     static boolean convertsTo(TargetType from, TargetType to) {
@@ -190,25 +212,29 @@ public class StatementToTargetExpression implements ASTVisitor {
         return to.equals(from);
     }
 
-    Optional<Method> findMethod(JavaClassName className, String name, List<TargetType> args) {
-        return converter.findMethod(converter.compiler.getClass(className), name, args);
+    Optional<Method> findMethod(JavaClassName className, String name, List<TargetType> args, IGenerics generics, JavaTXCompiler compiler) {
+        return ASTToTargetAST.findMethod(converter.compiler.getClass(className), name, args, generics, compiler);
+    }
+
+    Optional<Method> findMethod(JavaClassName className, String name, List<TargetType> args, JavaTXCompiler compiler) {
+        return ASTToTargetAST.findMethod(converter.compiler.getClass(className), name, args, compiler);
     }
 
     @Override
     public void visit(MethodCall methodCall) {
-        var receiverType = converter.convert(methodCall.receiver.getType());
+        var receiverType = converter.convert(methodCall.receiver.getType(), generics);
         var isFunNType = receiverType instanceof TargetFunNType;
 
-        var returnType = isFunNType ? TargetType.Object : converter.convert(methodCall.signature.get(methodCall.signature.size() - 1));
-        var receiverName = new JavaClassName(converter.convert(methodCall.receiver.getType()).name());
-        var argList = methodCall.signature.stream().map(converter::convert).toList();
+        var returnType = isFunNType ? TargetType.Object : converter.convert(methodCall.signature.getLast(), generics);
+        var receiverName = new JavaClassName(converter.convert(methodCall.receiver.getType(), generics).name());
+        var argList = methodCall.signature.stream().map(sig -> converter.convert(sig, generics)).toList();
         argList = argList.subList(0, argList.size() - 1);
 
         Method foundMethod = null;
         var isStatic = false;
         var isInterface = true;
         var isPrivate = false;
-        var signature = methodCall.signatureArguments().stream().map(converter::convert).toList();
+        var signature = methodCall.signatureArguments().stream().map(sig -> converter.convert(sig, generics)).toList();
 
         // Add used TPHs to containing method
         for (var i = 0; i < methodCall.signatureArguments().size(); i++) {
@@ -218,33 +244,38 @@ public class StatementToTargetExpression implements ASTVisitor {
         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(receiverClass, methodCall.name, signature);
+            var thisMethod = ASTToTargetAST.findMethod(receiverClass, methodCall.name, signature, generics, converter.compiler);
             ClassOrInterface finalReceiverClass = receiverClass;
-            foundMethod = thisMethod.orElseGet(() -> findMethod(finalReceiverClass.getSuperClass().getName(), methodCall.name, signature).orElseThrow());
+            foundMethod = thisMethod.orElseGet(() -> findMethod(finalReceiverClass.getSuperClass().getName(), methodCall.name, signature, generics, converter.compiler).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();
+            foundMethod = findMethod(receiverName, methodCall.name, signature, converter.compiler).orElseThrow();
         }
 
         if (!isFunNType) {
-            returnType = converter.convert(foundMethod.getReturnType());
-            argList = foundMethod.getParameterList().getFormalparalist().stream().map(e -> converter.convert(e.getType())).toList();
+            returnType = converter.convert(foundMethod.getReturnType(), generics);
+            argList = foundMethod.getParameterList().getFormalparalist().stream().map(e -> converter.convert(e.getType(), generics)).toList();
             isStatic = Modifier.isStatic(foundMethod.modifier);
             isPrivate = Modifier.isPrivate(foundMethod.modifier);
             isInterface = receiverClass.isInterface();
         }
 
-        Target.logger.info(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, isPrivate);
+        //System.out.println(argList);
+        result = new TargetMethodCall(
+            converter.convert(methodCall.getType(), generics), returnType, argList,
+            converter.convert(methodCall.receiver, generics),
+            methodCall.getArgumentList().getArguments().stream().map(arg -> converter.convert(arg, generics)).toList(),
+            receiverType, methodCall.name, isStatic, isInterface, isPrivate
+        );
     }
 
     @Override
     public void visit(NewClass newClass) {
         var receiverName = new JavaClassName(newClass.name);
-        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());
+        var ctor = converter.findConstructor(converter.compiler.getClass(receiverName), newClass.signatureArguments().stream().map(arg -> converter.convert(arg, generics)).toList(), generics);
+        var signature = ctor.orElseThrow().getParameterList().getFormalparalist().stream().map(e -> converter.convert(e.getType(), generics)).toList();
+        result = new TargetNew(new TargetRefType(newClass.name), signature, newClass.getArgumentList().getArguments().stream().map(arg -> converter.convert(arg, generics)).toList());
     }
 
     @Override
@@ -255,7 +286,7 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(Return aReturn) {
-        result = new TargetReturn(converter.convert(aReturn.retexpr));
+        result = new TargetReturn(converter.convert(aReturn.retexpr, generics));
     }
 
     @Override
@@ -275,53 +306,53 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(StaticClassName staticClassName) {
-        result = new TargetClassName(converter.convert(staticClassName.getType()));
+        result = new TargetClassName(converter.convert(staticClassName.getType(), generics));
     }
 
     @Override
     public void visit(Super aSuper) {
-        result = new TargetSuper(converter.convert(aSuper.getType()));
+        result = new TargetSuper(converter.convert(aSuper.getType(), generics));
     }
 
     @Override
     public void visit(This aThis) {
-        result = new TargetThis(converter.convert(aThis.getType()));
+        result = new TargetThis(converter.convert(aThis.getType(), generics));
     }
 
     @Override
     public void visit(WhileStmt whileStmt) {
-        result = new TargetWhile(converter.convert(whileStmt.expr), converter.convert(whileStmt.loopBlock));
+        result = new TargetWhile(converter.convert(whileStmt.expr, generics), converter.convert(whileStmt.loopBlock, generics));
     }
 
     @Override
     public void visit(DoStmt whileStmt) {
-        result = new TargetDo(converter.convert(whileStmt.expr), converter.convert(whileStmt.loopBlock));
+        result = new TargetDo(converter.convert(whileStmt.expr, generics), converter.convert(whileStmt.loopBlock, generics));
     }
 
     // TODO These two might not be necessary
     @Override
     public void visit(AssignToField assignLeftSide) {
-        result = converter.convert(assignLeftSide.field);
+        result = converter.convert(assignLeftSide.field, generics);
     }
 
     @Override
     public void visit(AssignToLocal assignLeftSide) {
-        result = converter.convert(assignLeftSide.localVar);
+        result = converter.convert(assignLeftSide.localVar, generics);
     }
 
     @Override
     public void visit(SuperCall superCall) {
-        var aSuper = converter.convert(superCall.receiver.getType());
-        var type = converter.convert(superCall.getType());
-        var receiverName = new JavaClassName(converter.convert(superCall.receiver.getType()).name());
+        var aSuper = converter.convert(superCall.receiver.getType(), generics);
+        var type = converter.convert(superCall.getType(), generics);
+        var receiverName = new JavaClassName(converter.convert(superCall.receiver.getType(), generics).name());
         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();
+        var signature = superCall.signatureArguments().stream().map(arg -> converter.convert(arg, generics)).toList();
+        var method = converter.findConstructor(clazz, signature, generics);
+        var params = superCall.getArgumentList().getArguments().stream().map(arg -> converter.convert(arg, generics)).toList();
 
         List<TargetType> argList;
         if (method.isPresent()) {
-            argList = method.get().getParameterList().getFormalparalist().stream().map(e -> converter.convert(e.getType())).toList();
+            argList = method.get().getParameterList().getFormalparalist().stream().map(e -> converter.convert(e.getType(), generics)).toList();
         } else {
             argList = params.stream().map(TargetExpression::type).toList();
         }
@@ -331,28 +362,28 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(ThisCall thisCall) {
-        var aThis = converter.convert(thisCall.receiver.getType());
-        var type = converter.convert(thisCall.getType());
-        var parameters = thisCall.arglist.getArguments().stream().map(par -> converter.convert(par.getType())).toList();
+        var aThis = converter.convert(thisCall.receiver.getType(), generics);
+        var type = converter.convert(thisCall.getType(), generics);
+        var parameters = thisCall.arglist.getArguments().stream().map(par -> converter.convert(par.getType(), generics)).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(arg -> converter.convert(arg, generics)).toList(), aThis, thisCall.name, false, false, false);
     }
 
     @Override
     public void visit(ExpressionReceiver expressionReceiver) {
-        result = converter.convert(expressionReceiver.expr);
+        result = converter.convert(expressionReceiver.expr, generics);
     }
 
     @Override
     public void visit(UnaryExpr unaryExpr) {
         result = switch (unaryExpr.operation) {
-        case NOT -> new TargetUnaryOp.Not(converter.convert(unaryExpr.getType()), converter.convert(unaryExpr.expr));
-        case MINUS -> new TargetUnaryOp.Negate(converter.convert(unaryExpr.getType()), converter.convert(unaryExpr.expr));
-        case PREINCREMENT -> new TargetUnaryOp.PreIncrement(converter.convert(unaryExpr.getType()), converter.convert(unaryExpr.expr));
-        case PREDECREMENT -> new TargetUnaryOp.PreDecrement(converter.convert(unaryExpr.getType()), converter.convert(unaryExpr.expr));
-        case POSTINCREMENT -> new TargetUnaryOp.PostIncrement(converter.convert(unaryExpr.getType()), converter.convert(unaryExpr.expr));
-        case PLUS -> new TargetUnaryOp.Add(converter.convert(unaryExpr.getType()), converter.convert(unaryExpr.expr));
-        case POSTDECREMENT -> new TargetUnaryOp.PostDecrement(converter.convert(unaryExpr.getType()), converter.convert(unaryExpr.expr));
+        case NOT -> new TargetUnaryOp.Not(converter.convert(unaryExpr.getType(), generics), converter.convert(unaryExpr.expr, generics));
+        case MINUS -> new TargetUnaryOp.Negate(converter.convert(unaryExpr.getType(), generics), converter.convert(unaryExpr.expr, generics));
+        case PREINCREMENT -> new TargetUnaryOp.PreIncrement(converter.convert(unaryExpr.getType(), generics), converter.convert(unaryExpr.expr, generics));
+        case PREDECREMENT -> new TargetUnaryOp.PreDecrement(converter.convert(unaryExpr.getType(), generics), converter.convert(unaryExpr.expr, generics));
+        case POSTINCREMENT -> new TargetUnaryOp.PostIncrement(converter.convert(unaryExpr.getType(), generics), converter.convert(unaryExpr.expr, generics));
+        case PLUS -> new TargetUnaryOp.Add(converter.convert(unaryExpr.getType(), generics), converter.convert(unaryExpr.expr, generics));
+        case POSTDECREMENT -> new TargetUnaryOp.PostDecrement(converter.convert(unaryExpr.getType(), generics), converter.convert(unaryExpr.expr, generics));
         };
     }
 
@@ -380,12 +411,12 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(Throw aThrow) {
-        result = new TargetThrow(converter.convert(aThrow.expr));
+        result = new TargetThrow(converter.convert(aThrow.expr, generics));
     }
 
     @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));
+        result = new TargetTernary(converter.convert(ternary.getType(), generics), converter.convert(ternary.cond, generics), converter.convert(ternary.iftrue, generics), converter.convert(ternary.iffalse, generics));
     }
 
     record TypeVariants(RefTypeOrTPHOrWildcardOrGeneric in, List<RefTypeOrTPHOrWildcardOrGeneric> types) {}
@@ -449,10 +480,8 @@ public class StatementToTargetExpression implements ASTVisitor {
                     var product = cartesianProduct(extractAllPatterns(label.getPattern()));
 
                     for (var l : product) {
-                        var oldGenerics = converter.generics;
-
                         // Set the generics to matching result set
-                        for (var generics : converter.currentMethodOverloads) {
+                        /*for (var generics : converter.currentMethodOverloads) {
                             var java = generics.javaGenerics();
                             var equals = true;
                             for (var pair : l) {
@@ -461,17 +490,15 @@ public class StatementToTargetExpression implements ASTVisitor {
                                 }
                             }
                             if (equals) {
-                                converter.generics = generics;
                                 break;
                             }
-                        }
+                        }*/
 
-                        overloads.add(converter.convert(case_));
-                        converter.generics = oldGenerics;
+                        overloads.add(converter.convert(case_, generics));
                     }
                 }
             } else {
-                overloads.add(converter.convert(case_));
+                overloads.add(converter.convert(case_, generics));
             }
 
             return overloads;
@@ -480,10 +507,10 @@ public class StatementToTargetExpression implements ASTVisitor {
         TargetSwitch.Case default_ = null;
         for (var block : switchStmt.getBlocks()) {
             if (block.isDefault()) {
-                default_ = new TargetSwitch.Case(converter.convert((Block) block), block.isExpression);
+                default_ = new TargetSwitch.Case(converter.convert((Block) block, generics), block.isExpression);
             }
         }
-        result = new TargetSwitch(converter.convert(switchStmt.getSwitch()), cases, default_ , converter.convert(switchStmt.getType()), !switchStmt.getStatement());
+        result = new TargetSwitch(converter.convert(switchStmt.getSwitch(), generics), cases, default_ , converter.convert(switchStmt.getType(), generics), !switchStmt.getStatement());
     }
 
     @Override
@@ -491,12 +518,12 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(SwitchLabel switchLabel) {
-        result = converter.convert(switchLabel.getPattern());
+        result = converter.convert(switchLabel.getPattern(), this.generics);
     }
 
     @Override
     public void visit(Yield aYield) {
-        result = new TargetYield(converter.convert(aYield.retexpr));
+        result = new TargetYield(converter.convert(aYield.retexpr, generics));
     }
 
     @Override
@@ -566,30 +593,30 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(FormalParameter aPattern) {
-        result = new TargetTypePattern(converter.convert(aPattern.getType()), aPattern.getName());
+        result = new TargetTypePattern(converter.convert(aPattern.getType(), generics), aPattern.getName());
     }
 
     @Override
     public void visit(LiteralPattern literalPattern) {
-        result = new TargetExpressionPattern(converter.convert(literalPattern.value));
+        result = new TargetExpressionPattern(converter.convert(literalPattern.value, generics));
     }
 
     @Override
     public void visit(ExpressionPattern aPattern) {
-        result = converter.convert(aPattern.getExpression());
+        result = converter.convert(aPattern.getExpression(), generics);
     }
 
     @Override
     public void visit(RecordPattern aRecordPattern) {
         result = new TargetComplexPattern(
-            converter.convert(aRecordPattern.getType()),
+            converter.convert(aRecordPattern.getType(), generics),
             aRecordPattern.getName(),
-            aRecordPattern.getSubPattern().stream().map(x -> (TargetPattern) converter.convert(x)).toList()
+            aRecordPattern.getSubPattern().stream().map(x -> (TargetPattern) converter.convert(x, generics)).toList()
         );
     }
 
     @Override
     public void visit(GuardedPattern aGuardedPattern) {
-        result = new TargetGuard((TargetPattern) converter.convert(aGuardedPattern.getNestedPattern()), converter.convert(aGuardedPattern.getCondition()));
+        result = new TargetGuard((TargetPattern) converter.convert(aGuardedPattern.getNestedPattern(), generics), converter.convert(aGuardedPattern.getCondition(), generics));
     }
 }

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

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.target.generate;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
@@ -7,8 +8,8 @@ import de.dhbwstuttgart.typeinference.result.ResultSet;
 import java.util.Set;
 
 final class TxGenerics extends GenerateGenerics {
-    TxGenerics(ASTToTargetAST astToTargetAST, ResultSet constraints) {
-        super(astToTargetAST, constraints);
+    TxGenerics(JavaTXCompiler compiler, ResultSet constraints) {
+        super(compiler, constraints);
     }
 
     @Override

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

@@ -15,4 +15,9 @@ public record MethodParameter(TargetPattern pattern) {
     public MethodParameter withName(String name) {
         return new MethodParameter(pattern.withName(name));
     }
+
+    @Override
+    public String toString() {
+        return pattern.toString();
+    }
 }

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

@@ -36,30 +36,30 @@ public record TargetMethod(int access, String name, TargetBlock block, Signature
     public static String getDescriptor(TargetType returnType, TargetType... parameters) {
         String ret = "(";
         for (var parameterType : parameters) {
-            ret += parameterType.toSignature();
+            ret += parameterType.toDescriptor();
         }
         ret += ")";
         if (returnType == null) ret += "V";
-        else ret += returnType.toSignature();
+        else ret += returnType.toDescriptor();
         return ret;
     }
 
     public static String getSignature(Set<TargetGeneric> generics, List<MethodParameter> parameters, TargetType returnType) {
         String ret = "";
-        if (generics.size() > 0) {
+        if (!generics.isEmpty()) {
             ret += "<";
             for (var generic : generics) {
-                ret += generic.name() + ":" + generic.bound().toDescriptor();
+                ret += generic.name() + ":" + generic.bound().toSignature();
             }
             ret += ">";
         }
         ret += "(";
         for (var param : parameters) {
-            ret += param.pattern().type().toDescriptor();
+            ret += param.pattern().type().toSignature();
         }
         ret += ")";
         if (returnType == null) ret += "V";
-        else ret += returnType.toDescriptor();
+        else ret += returnType.toSignature();
         return ret;
     }
 

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

@@ -14,4 +14,9 @@ public record TargetComplexPattern(TargetType type, String name, List<TargetPatt
     public TargetComplexPattern withName(String name) {
         return new TargetComplexPattern(type, name, subPatterns);
     }
+
+    @Override
+    public String toString() {
+        return type + "(" + String.join(", ", subPatterns.stream().map(Object::toString).toList()) + ") " + name;
+    }
 }

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

@@ -8,42 +8,42 @@ public sealed interface TargetLiteral extends TargetExpression {
     record BooleanLiteral(Boolean value) implements TargetLiteral {
         @Override
         public TargetType type() {
-            return TargetType.Boolean;
+            return TargetType.boolean_;
         }
     }
 
     record CharLiteral(Character value) implements TargetLiteral {
         @Override
         public TargetType type() {
-            return TargetType.Char;
+            return TargetType.char_;
         }
     }
 
     record IntLiteral(Integer value) implements TargetLiteral {
         @Override
         public TargetType type() {
-            return TargetType.Integer;
+            return TargetType.int_;
         }
     }
 
     record LongLiteral(Long value) implements TargetLiteral {
         @Override
         public TargetType type() {
-            return TargetType.Long;
+            return TargetType.long_;
         }
     }
 
     record FloatLiteral(Float value) implements TargetLiteral {
         @Override
         public TargetType type() {
-            return TargetType.Float;
+            return TargetType.float_;
         }
     }
 
     record DoubleLiteral(Double value) implements TargetLiteral {
         @Override
         public TargetType type() {
-            return TargetType.Double;
+            return TargetType.double_;
         }
     }
 

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

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

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

@@ -3,12 +3,12 @@ package de.dhbwstuttgart.target.tree.type;
 public record TargetExtendsWildcard(TargetType innerType) implements TargetType {
     @Override
     public String toSignature() {
-        return innerType.toSignature();
+        return "+" + innerType.toSignature();
     }
 
     @Override
     public String toDescriptor() {
-        return "+" + innerType.toDescriptor();
+        return innerType.toDescriptor();
     }
 
     @Override
@@ -20,5 +20,10 @@ public record TargetExtendsWildcard(TargetType innerType) implements TargetType
     public String name() {
         return innerType.name();
     }
+
+    @Override
+    public String toString() {
+        return "? extends " + innerType;
+    }
 }
 

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

@@ -36,6 +36,7 @@ public record TargetFunNType(String name, List<TargetType> funNParams, List<Targ
 
     @Override
     public String toSignature() {
-        return "L" + getInternalName() + ";";
+        var args = FunNGenerator.getArguments(funNParams);
+        return "LFun" + args.size() + "$$" + TargetSpecializedType.signatureParameters(funNParams) + ";";
     }
 }

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

@@ -2,12 +2,12 @@ package de.dhbwstuttgart.target.tree.type;
 
 public record TargetGenericType(String name) implements TargetType {
     @Override
-    public String toSignature() {
+    public String toDescriptor() {
         return "Ljava/lang/Object;"; // TODO Use bounds for this?
     }
 
     @Override
-    public String toDescriptor() {
+    public String toSignature() {
         return "T" + getInternalName() + ";";
     }
 
@@ -15,4 +15,9 @@ public record TargetGenericType(String name) implements TargetType {
     public String getInternalName() {
         return name;
     }
+
+    @Override
+    public String toString() {
+        return "'" + name;
+    }
 }

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

@@ -12,11 +12,6 @@ public record TargetRefType(String name, List<TargetType> params) implements Tar
         return this.name.replaceAll("\\.", "/");
     }
 
-    @Override
-    public String toSignature() {
-        return "L" + getInternalName() + ";";
-    }
-
     // Type erasure means we need to override hashCode and equals to only consider the name
     @Override
     public int hashCode() {
@@ -30,4 +25,10 @@ public record TargetRefType(String name, List<TargetType> params) implements Tar
         }
         return false;
     }
+
+    @Override
+    public String toString() {
+        if (params.isEmpty()) return name;
+        else return name + "<" + java.lang.String.join(", ", params.stream().map(java.lang.Object::toString).toList()) + ">";
+    }
 }

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

@@ -6,16 +6,27 @@ public sealed interface TargetSpecializedType extends TargetType permits TargetF
     List<TargetType> params();
 
     @Override
-    default String toDescriptor() {
+    default String toSignature() {
         String ret = "L" + getInternalName();
-        if (params().size() > 0) {
-            ret += "<";
-            for (var param : params()) {
-                ret += param.toDescriptor();
-            }
-            ret += ">";
-        }
+        ret += signatureParameters(params());
         ret += ";";
         return ret;
     }
+
+    static String signatureParameters(List<TargetType> params) {
+        var ret = "";
+        if (!params.isEmpty()) {
+            ret += "<";
+            for (var param : params) {
+                ret += param.toSignature();
+            }
+            ret += ">";
+        }
+        return ret;
+    }
+
+    @Override
+    default String toDescriptor() {
+        return "L" + getInternalName() + ";";
+    }
 }

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

@@ -3,12 +3,12 @@ package de.dhbwstuttgart.target.tree.type;
 public record TargetSuperWildcard(TargetType innerType) implements TargetType {
     @Override
     public String toSignature() {
-        return innerType.toSignature();
+        return "-" + innerType.toSignature();
     }
 
     @Override
     public String toDescriptor() {
-        return "-" + innerType.toDescriptor();
+        return innerType.toDescriptor();
     }
 
     @Override
@@ -20,6 +20,11 @@ public record TargetSuperWildcard(TargetType innerType) implements TargetType {
     public String name() {
         return innerType.name();
     }
+
+    @Override
+    public String toString() {
+        return "? super " + innerType;
+    }
 }
 
 

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

@@ -55,7 +55,7 @@ class TypeInsertPlacerClass extends AbstractASTWalker{
     @Override
     public void visit(Method method) {
         this.method = method;
-        constraints = generatedGenerics.get(method);
+        constraints = generatedGenerics.get(cl, method);
 		classConstraints = generatedGenerics.get(cl);
         if(method.getReturnType() instanceof TypePlaceholder)
             inserts.add(TypeInsertFactory.createInsertPoints(

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

@@ -19,11 +19,11 @@ public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;
     private RefTypeOrTPHOrWildcardOrGeneric retType;
     List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
-    private final Boolean isInherited;
-    private final Boolean isOverridden;
+    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, boolean isOverridden){
         super(scope);
         this.receiver = receiver;
         this.retType = retType;
@@ -73,11 +73,11 @@ public class MethodAssumption extends Assumption{
         return TYPEStmt.getReceiverType(receiver, resolver);
     }
     
-    public Boolean isInherited() {
+    public boolean isInherited() {
     	return isInherited;
     }
     
-    public Boolean isOverridden() {
+    public boolean isOverridden() {
     	return isOverridden;
     }
 }

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

@@ -9,84 +9,97 @@ import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialUUID;
 import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
-import java.util.ArrayList;
 import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-import javax.annotation.Nullable;
 
-public class Constraint<A extends IConstraintElement> extends HashSet<A> implements ISerializableData {
-  private static final long serialVersionUID = 1L;
-  private Boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
-  private Boolean isImplemented = false;
+public class Constraint<A extends IConstraintElement> extends HashSet<A> implements Comparable<Constraint<A>>, ISerializableData {
+	private static final long serialVersionUID = 1L;
+	private boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
+	private boolean isImplemented = false;
+	
+	/*
+	 * wird verwendet um bei der Codegenerierung die richtige Methoden - Signatur
+	 * auszuwaehlen 
+	 */
+	/*private*/ Set<A> methodSignatureConstraint = new HashSet<>();
+	
+	private Constraint<A> extendConstraint = null;
+	
+	public Constraint() {
+		super();
+	}
 
-  /*
-   * wird verwendet um bei der Codegenerierung die richtige Methoden - Signatur
-   * auszuwaehlen
-   */
-  /*private*/ Set<A> methodSignatureConstraint = new HashSet<>();
-
-  private Constraint<A> extendConstraint = null;
-
-  public Constraint() {
-    super();
+  public Constraint(int initialCapacity) {
+    super(initialCapacity);
   }
 
-  public Constraint(Boolean isInherited, Boolean isImplemented) {
-    this.isInherited = isInherited;
-    this.isImplemented = isImplemented;
+	public Constraint(boolean isInherited, boolean isImplemented) {
+		this.isInherited = isInherited;
+		this.isImplemented = isImplemented;
+	}
+	
+	public Constraint(boolean isInherited, boolean isImplemented, Constraint<A> extendConstraint, Set<A> methodSignatureConstraint) {
+		this.isInherited = isInherited;
+		this.isImplemented = isImplemented;
+		this.extendConstraint = extendConstraint;
+		this.methodSignatureConstraint = methodSignatureConstraint;
+	}
+	
+	public void setIsInherited(boolean isInherited) {
+		this.isInherited = isInherited;
+	}
+	
+	public boolean isInherited() {
+		return isInherited;
+	}
+	
+	public boolean isImplemented() {
+		return isImplemented;
+	}
+	
+	public Constraint<A> getExtendConstraint() {
+		return extendConstraint;
+	}
+	
+	public void setExtendConstraint(Constraint<A> c) {
+		extendConstraint = c;
+	}
+	
+	public Set<A> getmethodSignatureConstraint() {
+		return methodSignatureConstraint;
+	}
+	
+	public void setmethodSignatureConstraint(Set<A> c) {
+		methodSignatureConstraint = c;
+	}
+
+  public <B extends IConstraintElement> Constraint<B> createdMapped(Function<A,B> mapper) {
+    Constraint<B> result = new Constraint<>(this.size());
+    for (A element : this) {
+      result.add(mapper.apply(element));
+    }
+    return result;
   }
 
-  public Constraint(Boolean isInherited, Boolean isImplemented, Constraint<A> extendConstraint, Set<A> methodSignatureConstraint) {
-    this.isInherited = isInherited;
-    this.isImplemented = isImplemented;
-    this.extendConstraint = extendConstraint;
-    this.methodSignatureConstraint = methodSignatureConstraint;
-  }
-
-  public void setIsInherited(Boolean isInherited) {
-    this.isInherited = isInherited;
-  }
-
-  public Boolean isInherited() {
-    return isInherited;
-  }
-
-  public Boolean isImplemented() {
-    return isImplemented;
-  }
-
-  public Constraint<A> getExtendConstraint() {
-    return extendConstraint;
-  }
-
-  public void setExtendConstraint(Constraint<A> c) {
-    extendConstraint = c;
-  }
-
-  public Set<A> getmethodSignatureConstraint() {
-    return methodSignatureConstraint;
-  }
-
-  public void setmethodSignatureConstraint(Set<A> c) {
-    methodSignatureConstraint = c;
-  }
-
-  public String toString() {
+	public String toString() {
     return super.toString() + "\nisInherited = " + isInherited
       + " isOveridden = " + isImplemented
       + " msc[" + methodSignatureConstraint.size() + "] = " + methodSignatureConstraint
       //" + extendsContraint: "  + (extendConstraint != null ? extendConstraint.toStringBase() : "null" )
       + "\n";
-  }
+	}
+	
+	public String toStringBase() {
+		return super.toString();
+	}
 
-  public String toStringBase() {
-    return super.toString();
+
+  @Override
+  public int compareTo(Constraint<A> o) {
+    return this.toString().compareTo(o.toString());
   }
 
   private String serialUUID = null;
@@ -155,5 +168,4 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
 
     return keyStorage.getUnserialized(uuid, Constraint.class);
   }
-
 }

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

@@ -21,7 +21,7 @@ public class Pair implements Serializable, IConstraintElement, ISerializableData
   private SourceLoc location;
 
   private PairOperator eOperator = PairOperator.SMALLER;
-  private Boolean noUnification = false;
+  private boolean noUnification = false;
 
 
   private Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2) {
@@ -43,7 +43,7 @@ public class Pair implements Serializable, IConstraintElement, ISerializableData
     this.location = location;
   }
 
-  public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp, Boolean noUnification) {
+  public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp, boolean noUnification) {
     // Konstruktor
     this(TA1, TA2);
     this.eOperator = eOp;
@@ -161,7 +161,7 @@ public class Pair implements Serializable, IConstraintElement, ISerializableData
     String op = data.getValue("op").getOf(String.class);
     SerialMap ta1 = data.getMap("ta1");
     SerialMap ta2 = data.getMap("ta2");
-    Boolean noUnification = data.getValue("noUnification").getOf(Integer.class) == 1;
+    boolean noUnification = data.getValue("noUnification").getOf(Integer.class) == 1;
     SerialMap location = data.getMapOrNull("location");
 
     var pair = new Pair(

src/main/java/de/dhbwstuttgart/typeinference/result/ResultPair.java

@@ -11,7 +11,7 @@ import de.dhbwstuttgart.typeinference.unify.UnifyContext;
  * Paare, welche das Unifikationsergebnis darstellen
  */
 public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric,B extends RefTypeOrTPHOrWildcardOrGeneric>
-implements ISerializableData {
+  implements Comparable<ResultPair<A,B>>, ISerializableData {
     private final A left;
     private final B right;
 
@@ -65,6 +65,16 @@ implements ISerializableData {
 		return true;
 	}
 
+	@Override
+	public int compareTo(ResultPair<A, B> o) {
+		if (o == null) {
+			return 1; // this is greater than null
+		}
+
+		return o.left.toString().compareTo(this.left.toString());
+	}
+
+
 
 	@Override
 	public SerialMap toSerial(KeyStorage keyStorage) {

src/main/java/de/dhbwstuttgart/typeinference/result/ResultSet.java

@@ -5,11 +5,13 @@ import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
 import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialList;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTaskHelper;
 import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import de.dhbwstuttgart.util.Logger;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
@@ -22,28 +24,32 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import java.util.stream.Collectors;
 
 @SuppressWarnings("rawtypes")
-public class ResultSet implements ISerializableData {
+public class ResultSet implements Comparable<ResultSet>, ISerializableData {
 
   public final Set<ResultPair> results;
   public Set<ResultPair<TypePlaceholder, TypePlaceholder>> genIns;
 
-  public ResultSet(Set<ResultPair> set) {
-    this.results = set;
-    this.genIns = new HashSet<>();
-    results.forEach(x -> {
-      if (x instanceof PairTPHsmallerTPH) {
-        this.genIns.add(x);
-      }
-    });
-  }
+    public ResultSet(Set<ResultPair> set){
+        this.results = set;
+        this.genIns = TypeUnifyTaskHelper.getPresizedHashSet(results.size());
+        results.forEach(x -> {
+          if (x instanceof PairTPHsmallerTPH) {
+            this.genIns.add(x);
+          }
+        });
+    }
 
-  public boolean contains(ResultPair toCheck) {
-    return this.results.contains(toCheck);
-  }
+    public List<ResultPair> getSortedResults() {
+      return results.stream().sorted().toList();
+    }
 
-  public void remove(ResultPair toCheck) {
-    results.remove(toCheck);
-  }
+    public boolean contains(ResultPair toCheck) {
+    	return this.results.contains(toCheck);
+    }
+    
+    public void remove(ResultPair toCheck) {
+    	results.remove(toCheck);
+    }
 
   public ResolvedType resolveType(RefTypeOrTPHOrWildcardOrGeneric type) {
     if (type instanceof TypePlaceholder)
@@ -86,9 +92,24 @@ public class ResultSet implements ISerializableData {
     }
   }
 
+	@Override
+	public int hashCode() {
+		return results.hashCode();
+	}
+
   @Override
-  public int hashCode() {
-    return results.hashCode();
+  public int compareTo(ResultSet o) {
+    List<ResultPair> thisSorted = this.getSortedResults();
+    List<ResultPair> otherSorted = o.getSortedResults();
+    int sizeCompare = Integer.compare(thisSorted.size(), otherSorted.size());
+    if (sizeCompare != 0) return sizeCompare;
+
+    for (int i = 0; i < thisSorted.size(); i++) {
+      int cmp = thisSorted.get(i).compareTo(otherSorted.get(i));
+      if (cmp != 0) return cmp;
+    }
+
+    return 0;
   }
 
   @Override

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

@@ -1,6 +1,7 @@
 package de.dhbwstuttgart.typeinference.typeAlgo;
 
 import de.dhbwstuttgart.exceptions.DebugException;
+import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SourceLoc;
 import de.dhbwstuttgart.parser.antlr.Java17Parser;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
@@ -9,33 +10,36 @@ import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.target.tree.type.TargetRefType;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTaskHelper;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import de.dhbwstuttgart.util.BiRelation;
 import org.antlr.v4.runtime.Token;
 
+import java.lang.reflect.Modifier;
 import java.util.*;
 
 public class TYPE {
 
-    private final SourceFile sf;
     private final Set<ClassOrInterface> allAvailableClasses;
-    
-    public TYPE(SourceFile sf, Set<ClassOrInterface> allAvailableClasses){
-        this.sf = sf;
+    private final Set<ClassOrInterface> definedClasses;
+
+    public TYPE(Set<ClassOrInterface> definedClasses, Set<ClassOrInterface> allAvailableClasses){
         this.allAvailableClasses = allAvailableClasses;
+        this.definedClasses = definedClasses;
     }
 
     public ConstraintSet getConstraints() {
         ConstraintSet ret = new ConstraintSet();
-        for (ClassOrInterface cl : sf.KlassenVektor) {
-            var allClasses = new HashSet<ClassOrInterface>();
+        for (ClassOrInterface cl : definedClasses) {
+            Set<ClassOrInterface> allClasses = TypeUnifyTaskHelper.getPresizedHashSet(allAvailableClasses.size());
             allClasses.addAll(allAvailableClasses);
-            allClasses.addAll(sf.availableClasses);
             ret.addAll(getConstraintsClass(cl, new TypeInferenceInformation(allClasses)));
         }
         return ret;
@@ -87,12 +91,25 @@ public class TYPE {
         TypeInferenceBlockInformation blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, m);
         TYPEStmt methodScope = new TYPEStmt(blockInfo);
         ConstraintSet constraintSet = new ConstraintSet();
-        m.getParameterList().getFormalparalist().forEach(el -> {
-            if(el instanceof RecordPattern){
-                constraintSet.addAll(addRecursiveParameterConstraints((RecordPattern) el, blockInfo));
 
-            }
-        });
+        if (m.name.equals("main") && Modifier.isStatic(m.modifier) && m.getParameterList().getFormalparalist().size() == 1) {
+            // Add constraint for main method
+            var firstParam = m.getParameterList().getParameterAt(0);
+
+            constraintSet.addUndConstraint(new Pair(firstParam.getType(),
+                new RefType(new JavaClassName("java.util.List"),
+                    List.of(new RefType(new JavaClassName("java.lang.String"), new NullToken())),
+                    new NullToken()),
+                PairOperator.EQUALSDOT));
+        } else {
+            m.getParameterList().getFormalparalist().forEach(el -> {
+                if (el instanceof RecordPattern rp){
+                    constraintSet.addAll(addRecursiveParameterConstraints(rp, blockInfo));
+                }
+            });
+        }
+
+
         m.block.accept(methodScope);
         constraintSet.addAll(methodScope.getConstraints());
         return constraintSet;

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

@@ -2,6 +2,7 @@
 package de.dhbwstuttgart.typeinference.typeAlgo;
 
 import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTaskHelper;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -74,7 +75,7 @@ public class TYPEStmt implements StatementVisitor {
 
     @Override
     public void visit(LambdaExpression lambdaExpression) {
-        TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken());
+        TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken(), -1, false);
         List<RefTypeOrTPHOrWildcardOrGeneric> lambdaParams = lambdaExpression.params.getFormalparalist().stream().map((formalParameter -> formalParameter.getType())).collect(Collectors.toList());
         lambdaParams.add(tphRetType);
         // lambdaParams.add(0,tphRetType);
@@ -117,17 +118,18 @@ public class TYPEStmt implements StatementVisitor {
     @Override
     public void visit(FieldVar fieldVar) {
         fieldVar.receiver.accept(this);
-        Set<Constraint> oderConstraints = new HashSet<>();
+        List<FieldAssumption> fieldAssumptions = info.getFields(fieldVar.fieldVarName);
+        Set<Constraint> oderConstraints = TypeUnifyTaskHelper.getPresizedHashSet(fieldAssumptions.size());
 
 
-        for (FieldAssumption fieldAssumption : info.getFields(fieldVar.fieldVarName)) {
+        for (FieldAssumption fieldAssumption : fieldAssumptions) {
             Constraint constraint = new Constraint();
             GenericsResolver resolver = getResolverInstance();
             constraint.add(new Pair(fieldVar.receiver.getType(), fieldAssumption.getReceiverType(resolver), PairOperator.SMALLERDOT, loc(fieldVar.getOffset()))); // PL 2019-12-09: SMALLERDOT eingefuegt, EQUALSDOT entfernt, wenn ds Field privat ist muesste es EQUALSDOT lauten
             constraint.add(new Pair(fieldVar.getType(), fieldAssumption.getType(resolver), PairOperator.EQUALSDOT, loc(fieldVar.getOffset())));
             oderConstraints.add(constraint);
         }
-        if (oderConstraints.size() == 0)
+        if (oderConstraints.isEmpty())
             throw new TypeinferenceException("Kein Feld " + fieldVar.fieldVarName + " gefunden", fieldVar.getOffset());
         constraintsSet.addOderConstraint(oderConstraints);
     }
@@ -142,7 +144,7 @@ public class TYPEStmt implements StatementVisitor {
 
     @Override
     public void visit(ForEachStmt forEachStmt) {
-        var iterableType = new RefType(ASTFactory.createClass(java.lang.Iterable.class).getClassName(), Arrays.asList(new ExtendsWildcardType(forEachStmt.statement.getType(), new NullToken())), new NullToken());
+        var iterableType = new RefType(ASTFactory.createClass(java.lang.Iterable.class).getClassName(), List.of(new ExtendsWildcardType(forEachStmt.statement.getType(), new NullToken())), new NullToken());
         constraintsSet.addUndConstraint(new Pair(forEachStmt.expression.getType(), iterableType, PairOperator.SMALLERDOT, loc(forEachStmt.getOffset())));
         forEachStmt.statement.accept(this);
         forEachStmt.expression.accept(this);
@@ -190,7 +192,7 @@ public class TYPEStmt implements StatementVisitor {
         methodCall.receiver.accept(this);
         // Overloading:
         Set<Constraint<Pair>> methodConstraints = new HashSet<>();
-        for (MethodAssumption m : this.getMethods(methodCall.name, methodCall.arglist, info)) {
+        for (MethodAssumption m : TYPEStmt.getMethods(methodCall.name, methodCall.arglist, info)) {
             GenericsResolver resolver = getResolverInstance();
             Set<Constraint<Pair>> oneMethodConstraints = generateConstraint(methodCall, m, info, resolver);
             methodConstraints.addAll(oneMethodConstraints);
@@ -200,7 +202,7 @@ public class TYPEStmt implements StatementVisitor {
              * oneMethodConstraint.setExtendConstraint(extendsOneMethodConstraint); extendsOneMethodConstraint.setExtendConstraint(oneMethodConstraint); methodConstraints.add(extendsOneMethodConstraint);
              */
         }
-        if (methodConstraints.size() < 1) {
+        if (methodConstraints.isEmpty()) {
             throw new TypeinferenceException("Methode " + methodCall.name + " ist nicht vorhanden!", methodCall.getOffset());
         }
         constraintsSet.addOderConstraint(methodConstraints);
@@ -213,7 +215,7 @@ public class TYPEStmt implements StatementVisitor {
         for (MethodAssumption m : this.getConstructors(info, (RefType) methodCall.getType(), methodCall.getArgumentList())) {
             methodConstraints.add(generateConstructorConstraint(methodCall, m, info, getResolverInstance()));
         }
-        if (methodConstraints.size() < 1) {
+        if (methodConstraints.isEmpty()) {
             throw new TypeinferenceException("Konstruktor in Klasse " + methodCall.getType().toString() + " ist nicht vorhanden!", methodCall.getOffset());
         }
         constraintsSet.addOderConstraint(methodConstraints);
@@ -283,8 +285,13 @@ public class TYPEStmt implements StatementVisitor {
             // see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
             // Expression muss zu Numeric Convertierbar sein. also von Numeric erben
             Constraint<Pair> numeric;
+            HashSet<JavaClassName> classNames = TypeUnifyTaskHelper.getPresizedHashSet(info.getAvailableClasses().size());
+            for (var classEl : info.getAvailableClasses()) {
+                classNames.add(classEl.getClassName());
+            }
+
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(bytee.getName())) {
+            if (classNames.contains(bytee.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -292,7 +299,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(shortt.getName())) {
+            if (classNames.contains(shortt.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -300,7 +307,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(integer.getName())) {
+            if (classNames.contains(integer.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -308,7 +315,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(longg.getName())) {
+            if (classNames.contains(longg.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -316,7 +323,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(floatt.getName())) {
+            if (classNames.contains(floatt.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -324,7 +331,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(doublee.getName())) {
+            if (classNames.contains(doublee.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -339,7 +346,7 @@ public class TYPEStmt implements StatementVisitor {
 
             if (binary.operation.equals(BinaryExpr.Operator.ADD)) {
                 // Dann kann der Ausdruck auch das aneinanderfügen zweier Strings sein: ("a" + "b") oder (1 + 2)
-                if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(string.getName())) {
+                if (classNames.contains(string.getName())) {
                     Constraint<Pair> stringConcat = new Constraint<>();
                     stringConcat.add(new Pair(binary.lexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
                     stringConcat.add(new Pair(binary.rexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
@@ -347,7 +354,7 @@ public class TYPEStmt implements StatementVisitor {
                     numericAdditionOrStringConcatenation.add(stringConcat);
                 }
             }
-            if (numericAdditionOrStringConcatenation.size() < 1) {
+            if (numericAdditionOrStringConcatenation.isEmpty()) {
                 throw new TypeinferenceException("Kein Typ für " + binary.operation.toString() + " vorhanden", binary.getOffset());
             }
             constraintsSet.addOderConstraint(numericAdditionOrStringConcatenation);
@@ -636,6 +643,7 @@ public class TYPEStmt implements StatementVisitor {
             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 {
@@ -733,7 +741,7 @@ public class TYPEStmt implements StatementVisitor {
         }
 
         // Zuordnung von MethodCall.signature(ReturnType) zu dem ReturnType der ausgewaehlten Methode (assumption.returnType)
-        ret.add(new Pair(foMethod.signature.get(foMethod.signature.size() - 1), assumption.getReturnType(), PairOperator.EQUALSDOT));
+        ret.add(new Pair(foMethod.signature.getLast(), assumption.getReturnType(), PairOperator.EQUALSDOT));
         return ret;
     }
 
@@ -746,8 +754,8 @@ public class TYPEStmt implements StatementVisitor {
                 // funNParams.add(TypePlaceholder.fresh(new NullToken()));
                 funNParams.add(new GenericRefType(NameGenerator.makeNewName(), new NullToken()));
             }
-            funNParams.get(funNParams.size() - 1);
-            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(funNParams.size() - 1), funNParams.subList(0, funNParams.size() - 1), new TypeScope() {
+            funNParams.getLast();
+            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.getLast(), funNParams.subList(0, funNParams.size() - 1), new TypeScope() {
                 @Override
                 public Iterable<? extends GenericTypeVar> getGenerics() {
                     throw new NotImplementedException();
@@ -883,13 +891,9 @@ public class TYPEStmt implements StatementVisitor {
 
             child.getLabels().forEach(el -> {
                 if (el.getType() instanceof RefType) {
-                    var recType = el;
-
-                    if (el.getPattern() instanceof RecordPattern) {
-                        var pattern = (RecordPattern) recType.getPattern();
-                        recursivelyAddRecordConstraints(pattern);
-                    }
-
+                  if (el.getPattern() instanceof RecordPattern pattern) {
+                    recursivelyAddRecordConstraints(pattern);
+                  }
                 }
             });
 
@@ -905,7 +909,7 @@ public class TYPEStmt implements StatementVisitor {
 
         var allClasses = info.getAvailableClasses();
         var interestingClasses = allClasses.stream().filter(as -> as.getClassName().equals(((RefType) pattern.getType()).getName())).toList();
-        var constructors = interestingClasses.get(0).getConstructors();
+        var constructors = interestingClasses.getFirst().getConstructors();
 
         int counter = 0;
 
@@ -935,7 +939,7 @@ public class TYPEStmt implements StatementVisitor {
     @Override
     public void visit(Yield aYield) {
         aYield.retexpr.accept(this);
-        constraintsSet.addUndConstraint(new Pair(aYield.getType(), switchStack.peek().getType(), PairOperator.EQUALSDOT, loc(aYield.getOffset())));
+        constraintsSet.addUndConstraint(new Pair(aYield.getType(), switchStack.peek().getType(), PairOperator.SMALLERDOT, loc(aYield.getOffset())));
         // TODO Auto-generated method stub
     }
 }

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

@@ -0,0 +1,91 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.RecursiveTask;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * An intermediate class for the recursive steps of the TypeUnifyTask:
+ * This allows canceling parts of the recursion tree, instead of only  the whole execution as before. But in
+ * order for that to work, all cancellable child tasks must be added when they are created
+ *
+ * @param <T>
+ */
+public abstract class CancellableTask<T> extends RecursiveTask<T> {
+
+  private final AtomicBoolean executionCancelled = new AtomicBoolean(false);
+  private final List<CancellableTask<?>> childTasks = new LinkedList<>();
+  private CancellableTask<?> parentTask = null;
+
+  /**
+   * Set the execution for this task and all its (recursive) children to be canceled
+   */
+  protected void cancelExecution() {
+    // is this branch already canceled? Then do nothing
+    if (this.executionCancelled.getAndSet(true)) return;
+    this.cancelChildExecution();
+  }
+
+  private void cancelChildExecution() {
+    synchronized (this.childTasks) {
+      for (var childTask : childTasks) {
+        // no need to cancel a branch that is already finished
+        if (!childTask.isDone()) {
+          childTask.cancelExecution();
+        }
+      }
+    }
+  }
+
+  private void cancelChildExecutionAfter(CancellableTask<?> checkpointTask) {
+    boolean reachedCheckpoint = false;
+    int i = 0;
+    for (var childTask : childTasks) {
+      if (!reachedCheckpoint) {
+        reachedCheckpoint = childTask == checkpointTask;
+      }
+      else {
+        // no need to cancel a branch that is already finished
+        if (!childTask.isDone()) {
+          childTask.cancelExecution();
+        }
+        i++;
+      }
+    }
+    System.out.println("Skipped " + i + " younger siblings");
+  }
+
+  protected void cancelSiblingTasks() {
+    if (this.parentTask != null) {
+      boolean thisWasCancelledBefore = this.executionCancelled.get();
+      this.parentTask.cancelChildExecution();
+      this.executionCancelled.set(thisWasCancelledBefore);
+    }
+  }
+
+  public void cancelYoungerSiblingTasks() {
+    if (this.parentTask != null) {
+      this.parentTask.cancelChildExecutionAfter(this);
+    }
+  }
+
+  public Boolean isExecutionCancelled() {
+    return executionCancelled.get();
+  }
+
+  public void addChildTask(CancellableTask<?> childTask) {
+    this.childTasks.add(childTask);
+    childTask.setParentTask(this);
+    if (this.executionCancelled.get()) {
+      childTask.executionCancelled.set(true);
+    }
+  }
+
+  private void setParentTask(CancellableTask<?> parentTask) {
+    this.parentTask = parentTask;
+  }
+
+}

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

@@ -94,8 +94,8 @@ public class MartelliMontanariUnify implements IUnify {
 			// SUBST - Rule
 			if(lhsType instanceof PlaceholderType) {
 				mgu.add((PlaceholderType) lhsType, rhsType);
-				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen. 
-				termsList = termsList.stream().map(x -> mgu.apply(x)).collect(Collectors.toCollection(ArrayList::new));
+				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen.
+				termsList.replaceAll(mgu::apply);
 				idx = idx+1 == termsList.size() ? 0 : idx+1;
 				continue;
 			}