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

modified:   src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
	modified:   src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
	modified:   src/main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingExtend.java
	modified:   src/main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java
	modified:   src/main/java/de/dhbwstuttgart/typeinference/unify/model/PlaceholderType.java
	modified:   src/main/java/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java
	modified:   src/main/java/de/dhbwstuttgart/typeinference/unify/model/UnifyType.java
	modified:   src/test/java/AllgemeinTest.java

.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: '22'
+          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!

pom.xml

@@ -12,60 +12,83 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 	<url>http://maven.apache.org</url>
 	<dependencies>
 		<dependency>
-			<groupId>junit</groupId>
+			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit</artifactId>
+			<artifactId>junit-jupiter-api</artifactId>
-			<version>4.13.2</version>
+			<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.ow2.asm</groupId>
+			<artifactId>asm-util</artifactId>
+			<version>9.8</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>25</source>
-                    <source>23</source>
+                    <target>25</target>
-                    <target>23</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>
@@ -77,7 +100,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>
@@ -90,7 +113,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>

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/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/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/antlr4/de/dhbwstuttgart/parser/antlr/Java17Parser.g4

@@ -539,7 +539,7 @@ catchClause
     ;
 
 catchType
-    : typeType ('|' typeType)*
+    : qualifiedName ('|' qualifiedName)*
     ;
 
 finallyBlock

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/JavaTXCompiler.java

@@ -2,9 +2,11 @@
 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.scope.GenericsRegistry;
@@ -66,13 +68,18 @@ public class JavaTXCompiler {
 	Boolean resultmodel = true;
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
 
-    Boolean log = false; //gibt an ob ein Log-File nach System.getProperty("user.dir")+""/logFiles/"" geschrieben werden soll?
+    Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+""/logFiles/"" geschrieben werden soll?
     public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
     public final DirectoryClassLoader classLoader;
 
 	public final List<File> classPath;
 	private final File outputPath;
 
+	public final Map<String, FunNGenerator.GenericParameters> usedFunN = new HashMap<>();
+	public final Set<Integer> usedFunNSuperTypes = new HashSet<>();
+
+	public Map<String, byte[]> auxiliaries = new HashMap<>();
+
 	public DirectoryClassLoader getClassLoader() {
 		return classLoader;
 	}
@@ -97,7 +104,7 @@ public class JavaTXCompiler {
 			path.add(new File(System.getProperty("user.dir")));
 		}
 		if (outputPath != null) path.add(outputPath);
-		classLoader = new DirectoryClassLoader(path, ClassLoader.getPlatformClassLoader());
+		classLoader = new DirectoryClassLoader(path, ClassLoader.getSystemClassLoader());
 		environment = new CompilationEnvironment(sources, classLoader);
 		classPath = path;
 		this.outputPath = outputPath;
@@ -393,7 +400,12 @@ public class JavaTXCompiler {
 			logFile.write(ASTTypePrinter.print(sf));
 			System.out.println(ASTTypePrinter.print(sf));
 			logFile.flush();
-			System.out.println("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
+			List<UnifyPair> andConstraintsSorted = unifyCons.getUndConstraints().stream()
+					.sorted(Comparator.comparing(UnifyPair::getPairOp).thenComparing(UnifyPair::getLhsType, Comparator.comparing(UnifyType::getName)))
+					.collect(Collectors.toList());
+
+			System.out.println(andConstraintsSorted);
+
 			Set<PlaceholderType> varianceTPHold;
 			Set<PlaceholderType> varianceTPH = new HashSet<>();
 			varianceTPH = varianceInheritanceConstraintSet(unifyCons);
@@ -416,7 +428,14 @@ public class JavaTXCompiler {
 				UnifyResultListenerImpl li = new UnifyResultListenerImpl();
 				urm.addUnifyResultListener(li);
 				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm, usedTasks);
-				System.out.println("RESULT Final: " + li.getResults());
+				//System.out.println("RESULT Final: " + li.getResults());
+				var finalResults = li.getResults().stream().sorted().toList();
+				int i = 0;
+				System.out.println("RESULT Final: ");
+				for (var result : finalResults){
+					System.out.println("Result: " + i++);
+					System.out.println(result.getSortedResults());
+				}
 				System.out.println("Constraints for Generated Generics: " + " ???");
 				logFile.write("RES_FINAL: " + li.getResults().toString() + "\n");
 				logFile.flush();
@@ -457,6 +476,85 @@ public class JavaTXCompiler {
 		return results.stream().map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons))))).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<>();
+		try {
+			Writer logFile = new OutputStreamWriter(new NullOutputStream());
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logFile, classLoader, this);
+			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons);
+			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);
+			TypeUnify unify = new TypeUnify();
+			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);
+				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm, usedTasks);
+				generateBytecode(sf, li.getResults());
+				return new LanguageServerTransferObject(li.getResults(), sf, ASTTypePrinter.print(sf), generatedGenerics);
+			}
+			/* UnifyResultModel End */
+			else {
+				Set<Set<UnifyPair>> result = unify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons, finiteClosure), usedTasks);
+				results.addAll(result);
+
+				results = results.stream().map(x -> {
+					Optional<Set<UnifyPair>> res = new RuleSet().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().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))))).collect(Collectors.toList()));
+		return new LanguageServerTransferObject(results.stream().map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons))))).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.
 	 * 
@@ -631,12 +729,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;
 	}
 

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

@@ -30,7 +30,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
 	 */

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).toArray(URL[]::new), parent);
+        super(directory.stream().map(DirectoryClassLoader::dirToURL).flatMap(List::stream).collect(Collectors.toList()).toArray(new URL[0]), parent.getParent());
     }
 
     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) {
+    default Class<?> loadClass(byte[] code) {
-        return this._defineClass(null, code, 0, code.length);
+        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());
+
+            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());
+        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

@@ -1,7 +1,12 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
 import java.lang.reflect.Modifier;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -11,7 +16,6 @@ import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.target.tree.expression.TargetUnaryOp;
 import de.dhbwstuttgart.target.generate.StatementToTargetExpression;
-import org.antlr.v4.runtime.RuleContext;
 import org.antlr.v4.runtime.Token;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
@@ -146,7 +150,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); 
@@ -634,16 +638,8 @@ public class StatementGenerator {
     }
 
     private Statement convert(Java17Parser.TrycatchblockContext stmt) {
-        Block tryBlock = convert(stmt.block(), false);
+        // TODO
-        List<CatchClause> catchClauses = stmt.catchClause().stream().
+        throw new NotImplementedException();
-                map(x ->
-                        new CatchClause(x.catchType().typeType().stream().map(y -> TypeGenerator.convert(y, reg, generics)).toList(),
-                        x.identifier().getText(),
-                        convert(x.block(), false)
-                        )).toList();
-
-        Optional<Block> finallyBlock = stmt.finallyBlock() != null ? Optional.of(convert(stmt.finallyBlock().block(), false)) : Optional.empty();
-        return new TryCatchFinally(tryBlock, catchClauses, finallyBlock, stmt.getStart());
     }
 
     private Statement convert(Java17Parser.TrycatchresourceContext stmt) {
@@ -1069,7 +1065,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) {
@@ -1079,7 +1075,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 {
@@ -1103,9 +1099,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/SyntacticSugar.java

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

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

@@ -168,7 +168,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/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);
     }

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import de.dhbwstuttgart.syntaxtree.statement.TryCatchFinally;
 import de.dhbwstuttgart.syntaxtree.type.*;
 
 public interface ASTVisitor extends StatementVisitor{
@@ -41,6 +40,4 @@ public interface ASTVisitor extends StatementVisitor{
 
     void visit(GuardedPattern aGuardedPattern);
 
-    void visit(TryCatchFinally tryCatchFinally);
-
 }

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

@@ -1,19 +0,0 @@
-package de.dhbwstuttgart.syntaxtree;
-
-import de.dhbwstuttgart.syntaxtree.statement.Block;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-
-import java.util.List;
-
-public class CatchClause {
-    public List<RefTypeOrTPHOrWildcardOrGeneric> exceptionTypes;
-    public String identifier;
-    public Block catchBlock;
-
-    public CatchClause(List<RefTypeOrTPHOrWildcardOrGeneric> exceptionTypes, String identifier, Block catchBlock){
-        this.exceptionTypes = exceptionTypes;
-        this.identifier = identifier;
-        this.catchBlock = catchBlock;
-    }
-}
-

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/StatementVisitor.java

@@ -85,6 +85,4 @@ public interface StatementVisitor {
     void visit(Throw aThrow);
 
     void visit(Ternary ternary);
-
-    void visit(TryCatchFinally tryCatchFinally);
 }

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

@@ -13,6 +13,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/TryCatchFinally.java

@@ -1,30 +0,0 @@
-package de.dhbwstuttgart.syntaxtree.statement;
-
-import de.dhbwstuttgart.syntaxtree.CatchClause;
-import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import org.antlr.v4.runtime.Token;
-import de.dhbwstuttgart.syntaxtree.type.Void;
-
-import java.util.List;
-import java.util.Optional;
-
-public class TryCatchFinally extends Statement{
-
-    public Block tryBlock;
-    public List<CatchClause> catchClauses;
-    public Optional<Block> finallyBlock;
-
-    public TryCatchFinally(Block tryBlock, List<CatchClause> catchClauses, Optional<Block> finallyBlock, Token offset){
-        super(new Void(offset), offset);
-        this.tryBlock = tryBlock;
-        this.catchClauses = catchClauses;
-        this.finallyBlock = finallyBlock;
-    }
-
-    @Override
-    public void accept(StatementVisitor visitor) {
-        visitor.visit(this);
-    }
-}

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

@@ -530,9 +530,4 @@ public class OutputGenerator implements ASTVisitor {
         out.append(" with ");
         aGuardedPattern.getCondition().accept(this);
     }
-
-    @Override
-    public void visit(TryCatchFinally tryCatchFinally) {
-        out.append("");
-    }
 }

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

@@ -1,8 +1,8 @@
+
 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,6 +12,8 @@ import de.dhbwstuttgart.syntaxtree.Record;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
+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.*;
@@ -35,7 +37,6 @@ public class ASTToTargetAST {
     public Generics generics;
     public List<Generics> currentMethodOverloads;
 
-    final Map<ClassOrInterface, Set<GenericTypeVar>> userDefinedGenerics = new HashMap<>();
     final Map<Method, Set<SignaturePair>> tphsInMethods = new HashMap<>();
     private Method currentMethod;
 
@@ -60,17 +61,19 @@ public class ASTToTargetAST {
     }
 
     public record Generics(JavaGenerics javaGenerics, TxGenerics txGenerics) {
+        public Generics(JavaTXCompiler compiler, ResultSet set) {
+            this(new JavaGenerics(compiler, set), new TxGenerics(compiler, set));
+        }
     }
 
-
     public IByteArrayClassLoader classLoader;
     protected SourceFile sourceFile;
 
-    public ASTToTargetAST(List<ResultSet> resultSets) {
+    public ASTToTargetAST(List<ResultSet> resultSets, IByteArrayClassLoader classLoader) {
-        this(null, resultSets);
+        this(null, resultSets, classLoader);
     }
-    public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets) {
+    public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets, IByteArrayClassLoader classLoader) {
-        this(compiler, resultSets, null, new ByteArrayClassLoader());
+        this(compiler, resultSets, null, classLoader);
     }
 
     public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets, SourceFile sourceFile, IByteArrayClassLoader classLoader) {
@@ -80,9 +83,9 @@ 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);
+        this.generics = all.getFirst();
     }
 
     public void addSignaturePair(TypePlaceholder signature, RefTypeOrTPHOrWildcardOrGeneric parameter) {
@@ -92,9 +95,13 @@ public class ASTToTargetAST {
     }
 
     Optional<Method> findMethod(ClassOrInterface owner, String name, List<TargetType> argumentList) {
+        return findMethod(owner, name, argumentList, this.generics.javaGenerics, this.compiler);
+    }
+
+    public static Optional<Method> findMethod(ClassOrInterface owner, String name, List<TargetType> argumentList, GenerateGenerics 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(), argumentList, generics)).findFirst();
             if (owner.getClassName().toString().equals("java.lang.Object")) break;
             owner = compiler.getClass(owner.getSuperClass().getName());
         }
@@ -102,16 +109,16 @@ public class ASTToTargetAST {
     }
 
     Optional<Constructor> findConstructor(ClassOrInterface owner, List<TargetType> argumentList) {
-        return owner.getConstructors().stream().filter(c -> parameterEquals(c.getParameterList(), argumentList)).findFirst();
+        return owner.getConstructors().stream().filter(c -> parameterEquals(c.getParameterList(), argumentList, generics.javaGenerics)).findFirst();
     }
 
-    boolean parameterEquals(ParameterList parameterList, List<TargetType> arguments) {
+    static boolean parameterEquals(ParameterList parameterList, List<TargetType> arguments, GenerateGenerics generics) {
         var pars = parameterList.getFormalparalist();
         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 = generics.getTargetType(pars.get(i).getType());
             var type2 = arguments.get(i);
             if (type1 instanceof TargetGenericType)
                 return true;
@@ -349,19 +356,14 @@ public class ASTToTargetAST {
         Set<TargetGeneric> javaGenerics = new HashSet<>();
         Set<TargetGeneric> txGenerics = new HashSet<>();
 
-        var genericsIter = input.getGenerics().iterator();
+        var userDefinedGenerics = input.getUserDefinedGenerics();
-        if (genericsIter.hasNext()) {
+        if (!userDefinedGenerics.isEmpty()) {
             // Add empty set of generics to cache so that it doesn't try to calculate it later
-            var userDefinedGenerics = new HashSet<GenericTypeVar>();
+            for (var generic : userDefinedGenerics) {
-            this.userDefinedGenerics.put(input, userDefinedGenerics);
+                // TODO Support multiple bouds
-            while (genericsIter.hasNext()) {
+                javaGenerics.add(new TargetGeneric(generic.getName(), convert(generic.getBounds().getFirst())));
-                var next = genericsIter.next();
-                userDefinedGenerics.add(next);
-                // TODO Support multiple bounds
-                javaGenerics.add(new TargetGeneric(next.getName(), convert(next.getBounds().get(0))));
             }
         } else {
-            this.userDefinedGenerics.put(input, new HashSet<>());
             // Generate generics only if there are no user defined ones
             javaGenerics = convert(generics.javaGenerics.generics(input), generics.javaGenerics);
             txGenerics = convert(generics.txGenerics.generics(input), generics.txGenerics);
@@ -423,7 +425,7 @@ public class ASTToTargetAST {
     }
 
     private List<TargetConstructor> convert(ClassOrInterface currentClass, Constructor input, TargetBlock fieldInitializer) {
-        generics = all.get(0);
+        generics = all.getFirst();
         List<TargetConstructor> result = new ArrayList<>();
         Set<List<MethodParameter>> parameterSet = new HashSet<>();
         this.currentMethod = input;
@@ -467,13 +469,6 @@ public class ASTToTargetAST {
         }
     }
 
-    private TargetType unwrap(TargetType type) {
-        if (type instanceof TargetRefType ref) {
-            if (!ref.params().isEmpty()) return new TargetRefType(ref.name());
-        }
-        return type;
-    }
-
     private TargetExpression generatePatternOverloadsRec(int offset, TargetExpression switchExpr, List<TargetLocalVar> params, List<TargetPattern> patterns, List<TargetMethod> methods, TargetType classType) {
         if (methods.isEmpty()) throw new DebugException("Couldn't find a candidate for switch overloading");
         if (methods.size() == 1) {
@@ -744,11 +739,6 @@ public class ASTToTargetAST {
         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);
     }
@@ -781,7 +771,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;
@@ -809,28 +807,24 @@ 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);
-
+            compiler.auxiliaries.put(entry.getKey(), code);
-            try {
-                classLoader.findClass(entry.getKey());
-            } catch (ClassNotFoundException e) {
-                try {
-                    classLoader.loadClass(code);
-                } catch (LinkageError ignored) {}
-            }
-            auxiliaries.put(entry.getKey(), code);
         }
     }
 
-    protected TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, GenerateGenerics generics) {
+    public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, GenerateGenerics generics) {
+        return convert(input, generics, compiler);
+    }
+
+    public static TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, GenerateGenerics generics, JavaTXCompiler compiler) {
         return input.acceptTV(new TypeVisitor<>() {
             @Override
             public TargetType visit(RefType refType) {
@@ -842,31 +836,24 @@ 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())) {
+                    if (!compiler.usedFunNSuperTypes.contains(params.size())) {
-                        usedFunNSuperTypes.add(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 {
+                        compiler.auxiliaries.put(superClassName, code);
-                            classLoader.findClass(superClassName);
-                        } catch (ClassNotFoundException e) {
-                            try {
-                                classLoader.loadClass(code);
-                            } catch (LinkageError ignored) {}
-                        }
-                        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);
                 }
@@ -875,7 +862,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
@@ -885,7 +872,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

@@ -1,5 +1,7 @@
 package de.dhbwstuttgart.target.generate;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.parser.JavaTXParser;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@@ -18,7 +20,7 @@ import java.util.stream.Stream;
 
 public abstract class GenerateGenerics {
 
-    private final ASTToTargetAST astToTargetAST;
+    private final JavaTXCompiler compiler;
 
     public class TPH {
         private final TypePlaceholder wrap;
@@ -134,8 +136,8 @@ public abstract class GenerateGenerics {
     Map<TPH, RefTypeOrTPHOrWildcardOrGeneric> concreteTypes = new HashMap<>();
     Map<TypePlaceholder, TypePlaceholder> equality = new HashMap<>();
 
-    GenerateGenerics(ASTToTargetAST astToTargetAST, ResultSet constraints) {
+    GenerateGenerics(JavaTXCompiler compiler, ResultSet constraints) {
-        this.astToTargetAST = astToTargetAST;
+        this.compiler = compiler;
         for (var constraint : constraints.results) {
             if (constraint instanceof PairTPHsmallerTPH p) {
                 System.out.println(p.left + " " + p.left.getVariance());
@@ -281,7 +283,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)) {
@@ -329,7 +331,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();
                             System.out.println("In: " + method.getName() + " Method: " + method2.getName());
@@ -434,11 +436,6 @@ public abstract class GenerateGenerics {
                     whileStmt.loopBlock.accept(this);
                 }
 
-                @Override
-                public void visit(TryCatchFinally tryCatchFinally) {
-
-                }
-
                 @Override
                 public void visit(ArgumentList arglist) {
                     for (int i = 0; i < arglist.getArguments().size(); i++) {
@@ -541,11 +538,6 @@ public abstract class GenerateGenerics {
                     super.visit(methodCall);
                     typeVariables.addAll(findTypeVariables(methodCall.getType()));
                 }
-
-                @Override
-                public void visit(TryCatchFinally tryCatchFinally) {
-
-                }
             });
     }
 
@@ -1015,8 +1007,8 @@ public abstract class GenerateGenerics {
             }
             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

@@ -69,8 +69,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/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) {
+    JavaGenerics(JavaTXCompiler compiler, ResultSet constraints) {
-        super(astToTargetAST, constraints);
+        super(compiler, constraints);
     }
 
     @Override

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

@@ -14,6 +14,7 @@ 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;
@@ -32,59 +33,71 @@ 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()), 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()), p.getName())))
+            .toList();
+    }
+
     @Override
     public void visit(LambdaExpression lambdaExpression) {
-        var parameters = StreamSupport.stream(lambdaExpression.params.spliterator(), false)
+        var parameters = createParameters(lambdaExpression);
-                .map(p -> (FormalParameter) p)
-                .map(p -> new MethodParameter(new TargetTypePattern(converter.convert(p.getType()), p.getName())))
-                .toList();
-
         List<MethodParameter> captures = new ArrayList<>();
-        lambdaExpression.methodBody.accept(new TracingStatementVisitor() {
+        var visitor = new LambdaCaptureFinder(parameters, captures);
-            // TODO The same mechanism is implemented in Codegen, maybe use it from there?
+        lambdaExpression.methodBody.accept(visitor);
-            final Stack<Set<String>> localVariables = new Stack<>();
-            {
-                localVariables.push(new HashSet<>());
-            }
-
-            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(TryCatchFinally tryCatchFinally) {
-
-            }
-
-            @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());
@@ -125,7 +138,10 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(BoolExpression bool) {
-        System.out.println("BoolExpression");
+        result = switch(bool.operation) {
+        case OR -> new TargetBinaryOp.Or(converter.convert(bool.getType()), converter.convert(bool.lexpr), converter.convert(bool.rexpr));
+        case AND -> new TargetBinaryOp.And(converter.convert(bool.getType()), converter.convert(bool.lexpr), converter.convert(bool.rexpr));
+        };
     }
 
     @Override
@@ -145,7 +161,6 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(FieldVar fieldVar) {
-        var isStatic = false;
         var type = converter.convert(fieldVar.receiver.getType());
         var clazz = converter.compiler.getClass(new JavaClassName(type.name()));
         var field = clazz.getField(fieldVar.fieldVarName).orElseThrow();
@@ -596,14 +611,4 @@ public class StatementToTargetExpression implements ASTVisitor {
     public void visit(GuardedPattern aGuardedPattern) {
         result = new TargetGuard((TargetPattern) converter.convert(aGuardedPattern.getNestedPattern()), converter.convert(aGuardedPattern.getCondition()));
     }
-
-    @Override
-    public void visit(TryCatchFinally tryCatchFinally) {
-
-        result = new TargetTryCatchFinally(
-                converter.convert(tryCatchFinally.tryBlock),
-                tryCatchFinally.catchClauses.stream().map(x -> new TargetCatchClause(x.exceptionTypes.stream().map(converter::convert).toList(), x.identifier, converter.convert(x.catchBlock))).toList(),
-                tryCatchFinally.finallyBlock.map(converter::convert)
-        );
-    }
 }

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) {
+    TxGenerics(JavaTXCompiler compiler, ResultSet constraints) {
-        super(astToTargetAST, constraints);
+        super(compiler, constraints);
     }
 
     @Override

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/TargetCatchClause.java

@@ -1,8 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-import de.dhbwstuttgart.target.tree.type.TargetType;
-
-import java.util.List;
-
-public record TargetCatchClause(List<TargetType> exceptionNames, String identifier, TargetBlock catchBlock) {
-}

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

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

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/TargetTryCatchFinally.java

@@ -1,7 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-import java.util.List;
-import java.util.Optional;
-
-public record TargetTryCatchFinally(TargetBlock tryBlock, List<TargetCatchClause> catchClauses, Optional<TargetBlock> finallyBlock) implements TargetExpression{
-}

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

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() + ";";
     }
 

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() {

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 += signatureParameters(params());
-            ret += "<";
-            for (var param : params()) {
-                ret += param.toDescriptor();
-            }
-            ret += ">";
-        }
         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

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

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.typedeployment;
 
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
-import de.dhbwstuttgart.syntaxtree.statement.TryCatchFinally;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.target.generate.GenericsResult;
 import de.dhbwstuttgart.target.generate.GenericsResultSet;
@@ -33,11 +32,6 @@ public class TypeInsertPlacer extends AbstractASTWalker {
         TypeInsertPlacerClass cl = new TypeInsertPlacerClass(classOrInterface, withResults, genericsResult);
         this.inserts.addAll(cl.inserts);
     }
-
-    @Override
-    public void visit(TryCatchFinally tryCatchFinally) {
-
-    }
 }
 
 class TypeInsertPlacerClass extends AbstractASTWalker{
@@ -69,11 +63,6 @@ class TypeInsertPlacerClass extends AbstractASTWalker{
         super.visit(method);
     }
 
-    @Override
-    public void visit(TryCatchFinally tryCatchFinally) {
-
-    }
-
     @Override
     public void visit(Field field) {
         if(field.getType() instanceof TypePlaceholder){

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

@@ -6,7 +6,7 @@ import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 
-public class Constraint<A> extends HashSet<A> {
+public class Constraint<A> extends HashSet<A> implements Comparable<Constraint<A>> {
 	private static final long serialVersionUID = 1L;
 	private Boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
 	private Boolean isImplemented = false;
@@ -73,5 +73,9 @@ public class Constraint<A> extends HashSet<A> {
 	public String toStringBase() {
 		return super.toString();
 	}
-	
+
+	@Override
+	public int compareTo(Constraint<A> o) {
+		return this.toString().compareTo(o.toString());
+	}
 }

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

@@ -5,7 +5,7 @@ import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 /**
  * Paare, welche das Unifikationsergebnis darstellen
  */
-public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric,B extends RefTypeOrTPHOrWildcardOrGeneric> {
+public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric, B extends RefTypeOrTPHOrWildcardOrGeneric> implements Comparable<ResultPair<A,B>> {
     private final A left;
     private final B right;
 
@@ -58,5 +58,14 @@ public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric,B ext
 			return false;
 		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());
+	}
    
 }

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

@@ -1,6 +1,8 @@
 package de.dhbwstuttgart.typeinference.result;
 
+import java.util.Collections;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
@@ -12,7 +14,7 @@ import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
 @SuppressWarnings("rawtypes")
-public class ResultSet {
+public class ResultSet implements Comparable<ResultSet>{
 
     public final Set<ResultPair> results;
     public Set<ResultPair<TypePlaceholder, TypePlaceholder>> genIns;
@@ -22,6 +24,10 @@ public class ResultSet {
         this.genIns = new HashSet<>();
         results.forEach(x -> { if (x instanceof PairTPHsmallerTPH) { this.genIns.add(x);}} );
     }
+
+    public List<ResultPair> getSortedResults() {
+    	return results.stream().sorted().toList();
+    }
     
     public boolean contains(ResultPair toCheck) {
     	return this.results.contains(toCheck);
@@ -63,6 +69,21 @@ public class ResultSet {
 	public int hashCode() {
 		return results.hashCode();
 	}
+
+    @Override
+    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;
+    }
 }
 
 class Resolver implements ResultSetVisitor {

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,15 +10,18 @@ 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.model.PairOperator;
 import de.dhbwstuttgart.util.BiRelation;
 import org.antlr.v4.runtime.Token;
 
+import java.lang.reflect.Modifier;
 import java.util.*;
 
 public class TYPE {
@@ -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

@@ -1,6 +1,8 @@
 //PL 2018-12-19: Merge chekcen
 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;
 
@@ -73,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);
@@ -116,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 = new HashSet<>();//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);
     }
@@ -141,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);
@@ -189,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);
@@ -199,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);
@@ -212,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);
@@ -282,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 = new HashSet<>(); //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())));
@@ -291,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())));
@@ -299,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())));
@@ -307,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())));
@@ -315,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())));
@@ -323,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())));
@@ -338,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())));
@@ -346,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);
@@ -500,12 +508,6 @@ public class TYPEStmt implements StatementVisitor {
         constraintsSet.addUndConstraint(new Pair(ternary.iffalse.getType(), ternary.getType(), PairOperator.SMALLERDOT));
     }
 
-    @Override
-    public void visit(TryCatchFinally tryCatchFinally) {
-        tryCatchFinally.tryBlock.accept(this);
-        tryCatchFinally.catchClauses.forEach(c -> c.catchBlock.accept(this));
-    }
-
     @Override
     public void visit(Return returnExpr) {
         returnExpr.retexpr.accept(this);
@@ -641,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 {
@@ -699,8 +702,8 @@ public class TYPEStmt implements StatementVisitor {
 
         Set<Pair> methodSignatureConstraint = generatemethodSignatureConstraint(forMethod, assumption, info, resolver);
 
-        //System.out.println("methodSignatureConstraint: " + methodSignatureConstraint);
+        //context.logger().info("methodSignatureConstraint: " + methodSignatureConstraint);
-        //System.out.println("methodConstraint: " + methodConstraint);
+        //context.logger().info("methodConstraint: " + methodConstraint);
 
         methodConstraint.setmethodSignatureConstraint(methodSignatureConstraint);
         extendsMethodConstraint.setmethodSignatureConstraint(methodSignatureConstraint);
@@ -733,12 +736,12 @@ public class TYPEStmt implements StatementVisitor {
 
         for (int i = 0; i < foMethod.arglist.getArguments().size(); i++) {
             // Zuordnung von MethoCall.signature (Argumenttypen) zu der Argumenttypen der ausgewaehlten Methode (assumption.params)
-            ret.add(new Pair(foMethod.signature.get(i), assumption.getArgTypes().get(i), PairOperator.EQUALSDOT));
+            ret.add(new Pair(resolver.resolve(foMethod.signature.get(i)), resolver.resolve(assumption.getArgTypes().get(i)), PairOperator.EQUALSDOT));
 
         }
 
         // 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(resolver.resolve(foMethod.signature.getLast()), resolver.resolve(assumption.getReturnType()), PairOperator.EQUALSDOT));
         return ret;
     }
 
@@ -751,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);
+            funNParams.getLast();
-            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(funNParams.size() - 1), funNParams.subList(0, funNParams.size() - 1), new TypeScope() {
+            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();
@@ -847,7 +850,7 @@ public class TYPEStmt implements StatementVisitor {
             for (var child : switchStmt.getBlocks()) {
                 for (var label : child.getLabels()) {
                     if (label.getPattern() == null) {
-                        //System.out.println("DefaultCase");
+                        //context.logger().info("DefaultCase");
                     } else {
                         constraintsSet.addUndConstraint(
                                 new Pair(
@@ -888,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 pattern) {
-
+                    recursivelyAddRecordConstraints(pattern);
-                    if (el.getPattern() instanceof RecordPattern) {
+                  }
-                        var pattern = (RecordPattern) recType.getPattern();
-                        recursivelyAddRecordConstraints(pattern);
-                    }
-
                 }
             });
 
@@ -910,13 +909,13 @@ 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;
 
         for (var subPattern : pattern.getSubPattern()) {
             for (Constructor con : constructors) {
-                //System.out.println("----------------------\n" + subPattern.getType() + " | " + con.getParameterList().getParameterAt(counter).getType() + "\n----------------------\n");
+                //context.logger().info("----------------------\n" + subPattern.getType() + " | " + con.getParameterList().getParameterAt(counter).getType() + "\n----------------------\n");
                 constraintsSet.addUndConstraint(new Pair(subPattern.getType(), con.getParameterList().getParameterAt(counter).getType(), PairOperator.SMALLERDOT, loc(con.getParameterList().getParameterAt(counter).getOffset())));
             }
             if (subPattern instanceof RecordPattern) recursivelyAddRecordConstraints((RecordPattern) subPattern);
@@ -940,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/RuleSet.java

@@ -745,7 +745,7 @@ public class RuleSet implements IRuleSet{
 		
 		UnifyType lhsType = pair.getLhsType();
 		UnifyType rhsType = pair.getRhsType();
-		if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof ExtendsType))
+		if((!(lhsType instanceof ReferenceType) && !(lhsType instanceof FunNType)) || !(rhsType instanceof ExtendsType))
 			return Optional.empty();
 		
 		return Optional.of(new UnifyPair(lhsType, ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
@@ -771,7 +771,7 @@ public class RuleSet implements IRuleSet{
 		
 		UnifyType lhsType = pair.getLhsType();
 		UnifyType rhsType = pair.getRhsType();
-		if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof SuperType))
+		if((!(lhsType instanceof ReferenceType) && !(lhsType instanceof FunNType)) || !(rhsType instanceof SuperType))
 			return Optional.empty();
 		
 		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), lhsType, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
@@ -861,16 +861,19 @@ public class RuleSet implements IRuleSet{
         								   UnifyType r = x.getRhsType();
         								   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 								     } );
+
 		try {
-			logFile.write("FUNgreater: " + pair + "\n");
+			                       logFile.write("FUNgreater: " + pair + "\n");
-				logFile.write("FUNred: " + result + "\n");
+			                       logFile.write("FUNgreater: " + result + "\n");
-				logFile.flush();
+			                       logFile.flush();
-			}
+			               }
 		catch (IOException e) {
-			System.out.println("logFile-Error");
+			System.out.println("lofFile-Error");
 		}
+			
 		return Optional.of(result);
 	}
+
 	
 	
 	@Override
@@ -897,7 +900,7 @@ public class RuleSet implements IRuleSet{
 
 			var fiArgs = intf.getFunctionalInterfaceTypeArguments(refType);
 			var retType = fiArgs.getFirst();
-			var lhsArgs = intf.getFunctionalInterfaceTypeArguments(lhsType);
+			var lhsArgs = intf.getFunctionalInterfaceTypeArguments(lhsType); //FALSCHRUM????
 			var lhsRet = lhsArgs.getFirst();
 
 			Set<UnifyPair> result = new HashSet<>();
@@ -934,8 +937,8 @@ public class RuleSet implements IRuleSet{
 
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
-		Integer variance = ((PlaceholderType)rhsType).getVariance();
+		int variance = ((PlaceholderType)rhsType).getVariance();
-		Integer inversVariance = distributeVariance.inverseVariance(variance);
+		int inversVariance = distributeVariance.inverseVariance(variance);
 		
 		UnifyType[] freshPlaceholders = new UnifyType[funNLhsType.getTypeParams().size()];
 		for(int i = 0; i < freshPlaceholders.length-1; i++) {
@@ -943,6 +946,7 @@ public class RuleSet implements IRuleSet{
 			((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
 		}
 		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
+
 		((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
 		result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), freshPlaceholders[funNLhsType.getTypeParams().size()-1], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 		
@@ -953,42 +957,94 @@ public class RuleSet implements IRuleSet{
 		result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		
 		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
-									   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+									   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
 									   UnifyType r = x.getRhsType();
 									   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 									 } );
-		try {
+
-			logFile.write("FUNgreater: " + pair + "\n");
+		 try {
-			logFile.write("FUNgreater: " + result + "\n");
+			 logFile.write("FUNgreater: " + pair + "\n");
-			logFile.flush();
+			 logFile.write("FUNsmaller: " + result + "\n");
-		}
+			 logFile.flush();
-	catch (IOException e) {
+		 }
-		System.out.println("lofFile-Error");
+		 catch (IOException e) {
-	}
+			 System.out.println("lofFile-Error");
+		 }
+
 		return Optional.of(result);
 	}
 
 	@Override
-	public Optional<Set<UnifyPair>> smallerFunN(UnifyPair pair) {
+	public Optional<Set<UnifyPair>> smallerFunN(UnifyPair pair, IFiniteClosure fc) {
 		if(pair.getPairOp() != PairOperator.SMALLERDOT)
 			return Optional.empty();
 		
 		UnifyType lhsType = pair.getLhsType();
 		UnifyType rhsType = pair.getRhsType();
 		
-		if(!(lhsType instanceof PlaceholderType) || !(rhsType instanceof FunNType))
+		if(!(rhsType instanceof FunNType))
 			return Optional.empty();
+		
+		/* muss nach angepasst werden */
+		//FunN$$<...> <. FunctinalInterface<...> wird umgewandelt in FunN$$<...> <. FunN$$<... args aus FuntionalInterface ...>
+		if (lhsType instanceof ReferenceType) {
+			UnifyType typeFI = pair.getLhsType();
+					
+			Optional<UnifyType> opt = fc.getRightHandedFunctionalInterfaceType(typeFI.getName());
+			if(!opt.isPresent())
+				return Optional.empty();
+					
+			if (!(typeFI instanceof ReferenceType refType) || !(refType instanceof FunInterfaceType intf))
+				return Optional.empty();
+
+			var fiArgs = intf.getFunctionalInterfaceTypeArguments(refType);
+			var retType = fiArgs.getFirst();
+			var rhsArgs = intf.getFunctionalInterfaceTypeArguments(rhsType);
+			var rhsRet = rhsArgs.getFirst();
+
+			Set<UnifyPair> result = new HashSet<>();
+			//if (retType instanceof ExtendsType) {
+				result.add(new UnifyPair(retType, rhsRet, PairOperator.SMALLER));
+			//} else if (retType instanceof SuperType) {
+			//	return Optional.empty();
+			//} else {
+			//	result.add(new UnifyPair(lhsRet, retType, PairOperator.EQUALSDOT));
+			//}
+
+			for (var i = 1; i < fiArgs.size(); i++) {
+				var rh = rhsArgs.get(i);
+				var lh = fiArgs.get(i);
+
+				//if (rh instanceof SuperType) {
+					result.add(new UnifyPair(rh, lh, PairOperator.SMALLER));
+				//} else if (rh instanceof ExtendsType) {
+				//			return Optional.empty();
+				//} else {
+				//	result.add(new UnifyPair(lh, rh, PairOperator.EQUALSDOT));
+				//}
+			}
+
+			return Optional.of(result);
+		}
+
+		else {
+			if(!(lhsType instanceof PlaceholderType))
+				return Optional.empty();
+		}
+		
+		
+		
 
 		FunNType funNRhsType = (FunNType) rhsType;
 
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
-		Integer variance = ((PlaceholderType)lhsType).getVariance();
+		int variance = ((PlaceholderType)lhsType).getVariance();
-		Integer inversVariance = distributeVariance.inverseVariance(variance);
+		int inversVariance = distributeVariance.inverseVariance(variance);
 		
 		UnifyType[] freshPlaceholders = new UnifyType[funNRhsType.getTypeParams().size()];
 		for(int i = 0; i < freshPlaceholders.length-1; i++) {
-			freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
+			freshPlaceholders[i] =  PlaceholderType.freshPlaceholder();
 			((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
 		}
 		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
@@ -1003,21 +1059,139 @@ public class RuleSet implements IRuleSet{
 		result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		
 		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
-		   							   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+		   							   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
 		   							   UnifyType r = x.getRhsType();
 		   							   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 									 } );
-		try {
+
-			logFile.write("FUNgreater: " + pair + "\n");
+
-			logFile.write("FUNsmaller: " + result + "\n");
+		 try {
-			logFile.flush();
+			 logFile.write("FUNgreater: " + pair + "\n");
+			 logFile.write("FUNsmaller: " + result + "\n");
+			 logFile.flush();
+		 }
+		 catch (IOException e) {
+			 System.out.println("lofFile-Error");
+		 }
+		 
+		 return Optional.of(result);
+	}	
+	
+	@Override
+	public Optional<Set<UnifyPair>> reduceFIFunN(UnifyPair pair, IFiniteClosure fc) {
+		if(pair.getPairOp() != PairOperator.EQUALSDOT)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		
+		if(!(rhsType instanceof FunNType))
+			return Optional.empty();
+		
+		/* muss nach angepasst werden */
+		//FunN$$<...> <. FunctinalInterface<...> wird umgewandelt in FunN$$<...> <. FunN$$<... args aus FuntionalInterface ...>
+		if (lhsType instanceof ReferenceType) {
+			UnifyType typeFI = pair.getLhsType();
+					
+			Optional<UnifyType> opt = fc.getRightHandedFunctionalInterfaceType(typeFI.getName());
+			if(!opt.isPresent())
+				return Optional.empty();
+					
+			if (!(typeFI instanceof ReferenceType refType) || !(refType instanceof FunInterfaceType intf))
+				return Optional.empty();
+
+			var fiArgs = intf.getFunctionalInterfaceTypeArguments(refType);
+			var retType = fiArgs.getFirst();
+			var rhsArgs = intf.getFunctionalInterfaceTypeArguments(rhsType);
+			var rhsRet = rhsArgs.getFirst();
+
+			Set<UnifyPair> result = new HashSet<>();
+			//if (retType instanceof ExtendsType) {
+				result.add(new UnifyPair(retType, rhsRet, PairOperator.EQUALSDOT));
+			//} else if (retType instanceof SuperType) {
+			//	return Optional.empty();
+			//} else {
+			//	result.add(new UnifyPair(lhsRet, retType, PairOperator.EQUALSDOT));
+			//}
+
+			for (var i = 1; i < fiArgs.size(); i++) {
+				var rh = rhsArgs.get(i);
+				var lh = fiArgs.get(i);
+
+				//if (rh instanceof SuperType) {
+					result.add(new UnifyPair(rh, lh, PairOperator.EQUALSDOT));
+				//} else if (rh instanceof ExtendsType) {
+				//			return Optional.empty();
+				//} else {
+				//	result.add(new UnifyPair(lh, rh, PairOperator.EQUALSDOT));
+				//}
+			}
+
+			return Optional.of(result);
+		}
+		else {
+			return Optional.empty();
 		}
-	catch (IOException e) {
-		System.out.println("lofFile-Error");
 	}
-		return Optional.of(result);
+	
+	@Override
+	public Optional<Set<UnifyPair>> reduceFunNFi(UnifyPair pair, IFiniteClosure fc) {
+		if(pair.getPairOp() != PairOperator.EQUALSDOT)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		
+		if(!(lhsType instanceof FunNType)) 
+			return Optional.empty();
+		
+		//FunN$$<...> <. FunctinalInterface<...> wird umgewandelt in FunN$$<...> <. FunN$$<... args aus FuntionalInterface ...>
+		if (rhsType instanceof ReferenceType) {
+			UnifyType typeFI = pair.getRhsType();
+			
+			Optional<UnifyType> opt = fc.getRightHandedFunctionalInterfaceType(typeFI.getName());
+			if(!opt.isPresent())
+				return Optional.empty();
+			
+			if (!(typeFI instanceof ReferenceType refType) || !(refType instanceof FunInterfaceType intf))
+				return Optional.empty();
+
+			var fiArgs = intf.getFunctionalInterfaceTypeArguments(refType);
+			var retType = fiArgs.getFirst();
+			var lhsArgs = intf.getFunctionalInterfaceTypeArguments(lhsType);
+			var lhsRet = lhsArgs.getFirst();
+
+			Set<UnifyPair> result = new HashSet<>();
+			//if (retType instanceof ExtendsType) {
+			//	result.add(new UnifyPair(lhsRet, retType, PairOperator.SMALLERDOTWC));
+			//} else if (retType instanceof SuperType) {
+			//	return Optional.empty();
+			//} else {
+				result.add(new UnifyPair(lhsRet, retType, PairOperator.EQUALSDOT));
+			//}
+
+			for (var i = 1; i < fiArgs.size(); i++) {
+				var lh = lhsArgs.get(i);
+				var rh = fiArgs.get(i);
+
+				//if (rh instanceof SuperType) {
+				//	result.add(new UnifyPair(lh, rh, PairOperator.SMALLERDOTWC));
+				//} else if (rh instanceof ExtendsType) {
+				//	return Optional.empty();
+				//} else {
+					result.add(new UnifyPair(lh, rh, PairOperator.EQUALSDOT));
+				//}
+			}
+
+			return Optional.of(result);
+		}
+
+		else {
+				return Optional.empty();
+		}
 	}
 
+	
 	@Override
 	public Optional<UnifyPair> reduceTph(UnifyPair pair) {
 		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
@@ -1025,7 +1199,7 @@ public class RuleSet implements IRuleSet{
 		
 		UnifyType lhsType = pair.getLhsType();
 		UnifyType rhsType = pair.getRhsType();
-		if(!(lhsType instanceof PlaceholderType) || !(rhsType instanceof ReferenceType))
+		if(!(lhsType instanceof PlaceholderType) || (!(rhsType instanceof ReferenceType) && !(rhsType instanceof FunNType)))
 			return Optional.empty();
 		
 		return Optional.of(new UnifyPair(lhsType, rhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
@@ -1051,7 +1225,7 @@ public class RuleSet implements IRuleSet{
 		if(isGen)
 			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		else {
-			UnifyType freshTph = PlaceholderType.freshPlaceholder();
+			UnifyType freshTph =  PlaceholderType.freshPlaceholder();
 			result.add(new UnifyPair(rhsType, new ExtendsType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 			result.add(new UnifyPair(extendedType, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 		}
@@ -1079,7 +1253,7 @@ public class RuleSet implements IRuleSet{
 		if(isGen)
 			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		else {
-			UnifyType freshTph = PlaceholderType.freshPlaceholder();
+			UnifyType freshTph =  PlaceholderType.freshPlaceholder();
 			result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 			Set<UnifyType> fBounded = pair.getfBounded();
 			fBounded.add(lhsType);

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

@@ -16,6 +16,7 @@ import java.util.Set;
 import java.util.concurrent.RecursiveTask;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -814,6 +815,21 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			
 			writeLog("nextSet: " + nextSet.toString());
 			writeLog("nextSetasList: " + nextSetasList.toString());
+			Function<Set<UnifyPair>, Set<UnifyPair>> setInnterType_false = 
+					a_elem -> a_elem.stream().map(up -> { UnifyType lhs = up.getLhsType();
+														  UnifyType rhs = up.getRhsType();
+														  if (lhs instanceof PlaceholderType) {
+															  PlaceholderType newLhs = new PlaceholderType((PlaceholderType)lhs);
+															  newLhs.setInnerType(false);
+															  lhs = newLhs;
+														  }
+														  if (rhs instanceof PlaceholderType) {
+															  PlaceholderType newRhs = new PlaceholderType((PlaceholderType)rhs);
+															  newRhs.setInnerType(false);
+															  rhs = newRhs;
+														  }
+														  UnifyPair up_new = new UnifyPair(up, lhs, rhs);	
+														  return up_new;}).collect(Collectors.toCollection(HashSet::new));
 			if (variance == 1) {
 				a = oup.max(nextSetasList.iterator());
 				writeLog("Max: a in " + variance + " "+ a);
@@ -826,8 +842,9 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				Iterator<Set<UnifyPair>> nextSetasListItRest = new ArrayList<Set<UnifyPair>>(nextSetasListRest).iterator();
 				while (nextSetasListItRest.hasNext()) {
 					Set<UnifyPair> a_next = nextSetasListItRest.next();
+					
 					if (//a.equals(a_next) || 
-							(oup.compare(a, a_next) == 1)) {
+							(oup.compare(setInnterType_false.apply(a), setInnterType_false.apply(a_next)) == 1)) {
 						nextSetasListRest.remove(a_next);
 					}
 				}
@@ -848,8 +865,10 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				Iterator<Set<UnifyPair>> nextSetasListItRest = new ArrayList<Set<UnifyPair>>(nextSetasListRest).iterator();
 				while (nextSetasListItRest.hasNext()) {
 					Set<UnifyPair> a_next = nextSetasListItRest.next();
+					if (new ArrayList<>((a_next)).getFirst().getLhsType().getName().equals("AES"))
+						System.out.println();
 					if (//a.equals(a_next) || 
-							(oup.compare(a, a_next) == -1)) {
+							(oup.compare(setInnterType_false.apply(a), setInnterType_false.apply(a_next)) == -1)) {
 						nextSetasListRest.remove(a_next);
 					}
 				}
@@ -1828,7 +1847,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			// FunN Rules
 			optSet = optSet.isPresent() ? optSet : rules.reduceFunN(pair);
 			optSet = optSet.isPresent() ? optSet : rules.greaterFunN(pair, fc);
-			optSet = optSet.isPresent() ? optSet : rules.smallerFunN(pair);
+			optSet = optSet.isPresent() ? optSet : rules.smallerFunN(pair,fc);
 			
 			// One of the rules has been applied
 			if(optSet.isPresent()) {

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

@@ -40,6 +40,8 @@ public class UnifyResultModel {
 		Set<Set<UnifyPair>> eqPrimePrimeSetRet = eqPrimePrimeSet.stream().map(x -> {
 			Optional<Set<UnifyPair>> res = new RuleSet().subst(x.stream().map(y -> { 
 				if (y.getPairOp() == PairOperator.SMALLERDOTWC) y.setPairOp(PairOperator.EQUALSDOT);
+				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

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

@@ -61,7 +61,9 @@ public interface IRuleSet {
 	 */
 	public Optional<Set<UnifyPair>> reduceFunN(UnifyPair pair);
 	public Optional<Set<UnifyPair>> greaterFunN(UnifyPair pair, IFiniteClosure fc);
-	public Optional<Set<UnifyPair>> smallerFunN(UnifyPair pair);
+	public Optional<Set<UnifyPair>> smallerFunN(UnifyPair pair,  IFiniteClosure fc);
+	public Optional<Set<UnifyPair>> reduceFIFunN(UnifyPair pair, IFiniteClosure fc);
+	public Optional<Set<UnifyPair>> reduceFunNFi(UnifyPair pair, IFiniteClosure fc);
 	
 	/**
 	 * Checks whether the erase1-Rule applies to the pair.

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

@@ -53,7 +53,7 @@ class Node<T> {
 			addDescendant(descendant);
 		}
 	}
-	
+
 	/**
 	 * Adds a directed edge from the predecessor to this node (predecessor -> this)
 	 */
@@ -73,7 +73,7 @@ class Node<T> {
 			addPredecessor(predecessor);
 		}
 	}
-	
+
 	/**
 	 * The content of this node.
 	 */

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

@@ -35,7 +35,11 @@ public abstract class OrderingExtend<T> extends com.google.common.collect.Orderi
 		
 			T min = min(iterable);
 			ret.add(min);
-		
+			if (min instanceof Set) {
+				String x = ((UnifyPair)(new ArrayList<>((Set)min)).getFirst()).getLhsType().typeName;
+				if (((UnifyPair)(new ArrayList((Set)min)).getFirst()).getLhsType().typeName.equals("AES"))
+					System.out.println();
+			}
 			Iterator<T> it = iterable.iterator();
 			while (it.hasNext()) {
 				T elem = it.next();

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

@@ -251,7 +251,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 				.filter(x -> (x.getPairOp() == PairOperator.SMALLERDOT))
 				.collect(Collectors.toCollection(HashSet::new));
 		
-		/*
+		///*
 		synchronized(this) {
 					try {
 			((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
@@ -269,7 +269,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 			catch (IOException ie) {
 			}
 		}
-		*/
+		//*/
 		
 		
 		Integer compareEq;

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

@@ -95,6 +95,15 @@ public final class PlaceholderType extends UnifyType{
 		IsGenerated = isGenerated;
 	}
 	
+	public PlaceholderType(PlaceholderType ph) {
+		super(ph);
+		IsGenerated = ph.isGenerated();
+		wildcardable = ph.isWildcardable();
+		innerType = ph.isInnerType();
+		variance = ph.getVariance();
+		orCons = ph.getOrCons();
+	}
+	
 	public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht) {
 		return visitor.visit(this, ht);
 	}

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

@@ -101,6 +101,19 @@ public class UnifyPair {
 		hashCode = 17 + 31 * lhs.hashCode() + 31 * rhs.hashCode() + 31 * pairOp.hashCode();
 	}
 
+	public UnifyPair(UnifyPair up, UnifyType lhs, UnifyType rhs) {
+		this.lhs = lhs;
+		this.rhs = rhs;
+		pairOp = up.pairOp;
+		substitution = up.substitution;
+		basePair = up.getBasePair();
+		this.location = up.location;
+		this.fBounded = up.fBounded;
+
+		// Caching hashcode
+		hashCode = 17 + 31 * lhs.hashCode() + 31 * rhs.hashCode() + 31 * pairOp.hashCode();
+	}
+	
 	public SourceLoc getLocation() {
 		if (location != null) return location;
 		else if (basePair != null) return basePair.getLocation();

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

@@ -36,6 +36,10 @@ public abstract class UnifyType {
 		typeParams = p;
 	}
 	
+	protected UnifyType(UnifyType ut) {
+		typeName = ut.getName();
+		typeParams = ut.typeParams;
+	}
 
 	abstract public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht); 
 	

src/test/java/AllgemeinTest.java

@@ -1,6 +1,6 @@
 
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 import static targetast.TestCodegen.generateClassFiles;
 
 import java.io.File;
@@ -9,13 +9,12 @@ import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.Arrays;
 
-import org.junit.BeforeClass;
+import org.junit.jupiter.api.BeforeAll;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import com.google.common.collect.Lists;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
 
 public class AllgemeinTest {
 
@@ -64,11 +63,12 @@ public class AllgemeinTest {
 		//String className = "Cycle";
 		//String className = "TripleTest";
 		//String className = "WildcardList";
-		String className = "List";
+		//String className = "List";
 		//String className = "Box";
 		//String className = "GenBox";
 		//String className = "InnerInf";
 		//String className = "Foo";
+		String className = "Kombinatoren_After_Lazy2";
 		//PL 2019-10-24: genutzt fuer unterschiedliche Tests
 		path = System.getProperty("user.dir")+"/resources/AllgemeinTest/" + className + ".jav";
 		//path = System.getProperty("user.dir")+"/src/test/resources/AllgemeinTest/Overloading_Generics.jav";

src/test/java/GenericsParserTest.java

@@ -6,12 +6,12 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.target.generate.ASTToTargetAST;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class GenericsParserTest {
 

src/test/java/TestPackages.java

@@ -1,6 +1,6 @@
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.File;
 import java.util.List;
@@ -24,7 +24,7 @@ public class TestPackages {
     }
 
     @Test
-    @Ignore("This doesn't work")
+    @Disabled("This doesn't work")
     public void testPackagesCircular() throws Exception {
         var cmp = new JavaTXCompiler(
             List.of(

src/test/java/TestTypeDeployment.java

@@ -4,7 +4,7 @@ import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.File;
 import java.nio.file.Path;

src/test/java/astfactory/ASTFactoryTest.java

@@ -4,7 +4,7 @@ package astfactory;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
@@ -12,7 +12,8 @@ import java.lang.reflect.TypeVariable;
 import java.util.Arrays;
 import java.util.HashMap;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 
 public class ASTFactoryTest<A> extends HashMap<String, A>{
     @Test

src/test/java/finiteClosure/SuperInterfacesTest.java

@@ -3,7 +3,7 @@ package finiteClosure;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Collection;

src/test/java/languageServerInterfaceTest/test.jav

@@ -0,0 +1,5 @@
+public class t{
+    public mofus(){
+        return 1;
+    }
+}

src/test/java/syntaxtreegenerator/TestComplete.java

@@ -1,9 +1,5 @@
 package syntaxtreegenerator;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
 import java.io.File;
 import java.io.FileFilter;
 import java.io.FileInputStream;
@@ -12,21 +8,23 @@ import java.io.ObjectOutputStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 
-import org.junit.BeforeClass;
+import org.junit.jupiter.api.BeforeAll;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 /**
  * Unit-Tests für den 'SyntaxTreeGenerator' aus dem Package 'parser' nach Vorbild der Klasse 'TestComplete' aus dem Test-Package 'targetast'
  */
 public class TestComplete {
     private static HashMap<String, File[]> javFiles = new HashMap<>();
 
-    @BeforeClass
+    @BeforeAll
     public static void setUp() {
         final String testFileDirectory = "resources/bytecode/javFiles/";
         final String expectedASTDirectory = "resources/syntaxtreegenerator/";
@@ -353,7 +351,7 @@ public class TestComplete {
             assertEquals("Comparing expected and resulting AST for mathStrucInteger.jav", expectedAST, resultingAST);
         } catch (Exception exc) {
             exc.printStackTrace();
-            assertTrue("An error occured while generating the AST for mathStrucInteger.jav", exc instanceof NotImplementedException);
+            assertInstanceOf(NotImplementedException.class, exc);
         }
     }
 

src/test/java/syntaxtreegenerator/TestNewFeatures.java

@@ -1,15 +1,15 @@
 package syntaxtreegenerator;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.fail;
 
 import java.io.File;
 import java.io.FileFilter;
 import java.io.FileInputStream;
 import java.util.HashMap;
 
-import org.junit.BeforeClass;
+import org.junit.jupiter.api.BeforeAll;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
@@ -17,7 +17,7 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
 public class TestNewFeatures {
     private static HashMap<String, File[]> javFiles = new HashMap<>();
 
-    @BeforeClass
+    @BeforeAll
     public static void setUp() {
         final String testFileDirectory = "resources/syntaxtreegenerator/javFiles/";
         final String expectedASTDirectory = "resources/syntaxtreegenerator/";

src/test/java/targetast/ASTToTypedTargetAST.java

@@ -2,7 +2,6 @@ package targetast;
 
 import com.google.common.reflect.TypeToken;
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.*;
@@ -10,13 +9,13 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.target.generate.ASTToTargetAST;
 import de.dhbwstuttgart.target.tree.TargetStructure;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
-import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.nio.file.Path;
 import java.util.*;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ASTToTypedTargetAST {
 
@@ -24,7 +23,7 @@ public class ASTToTypedTargetAST {
     public void emptyClass() {
         ClassOrInterface emptyClass = new ClassOrInterface(0, new JavaClassName("EmptyClass"), new ArrayList<>(), Optional.empty(), Optional.empty(), new ArrayList<>(), new ArrayList<>(), new GenericDeclarationList(new ArrayList<>(), new NullToken()), new RefType(new JavaClassName("Object"), new NullToken()), false, false, new ArrayList<>(), new ArrayList<>(), new NullToken(), null);
         ResultSet emptyResultSet = new ResultSet(new HashSet<>());
-        TargetStructure emptyTargetClass = new ASTToTargetAST(List.of(emptyResultSet)).convert(emptyClass);
+        TargetStructure emptyTargetClass = new ASTToTargetAST(List.of(emptyResultSet), TestCodegen.createClassLoader()).convert(emptyClass);
         assert emptyTargetClass.getName().equals("EmptyClass");
         assert emptyTargetClass.methods().size() == 0;
         assert emptyTargetClass.fields().size() == 0;
@@ -32,13 +31,14 @@ public class ASTToTypedTargetAST {
 
     @Test
     public void overloading() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Overloading.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var classLoader = new ByteArrayClassLoader();
         var overloading = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
         var overloading2 = TestCodegen.generateClass(converter.convert(classes.get(1)), classLoader);
 
@@ -54,46 +54,54 @@ public class ASTToTypedTargetAST {
 
     @Test
     public void tphsAndGenerics() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Tph2.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var tphAndGenerics = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var tphAndGenerics = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
     }
 
     @Test
     public void cycles() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Cycle.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var cycle = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var cycle = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
     }
 
     @Test
     public void infimum() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Infimum.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var infimum = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var infimum = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
     }
 
     @Test
     public void gen() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Gen.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), TestCodegen.createClassLoader());
         var m = generics.getDeclaredMethod("m", Vector.class);
         var mReturnType = m.getGenericReturnType();
         assertEquals(mReturnType, m.getParameters()[0].getParameterizedType());
@@ -103,13 +111,15 @@ public class ASTToTypedTargetAST {
 
     @Test
     public void definedGenerics() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Generics.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
         var B = generics.getTypeParameters()[0];
         var mt1 = generics.getDeclaredMethod("mt1", Object.class);
         var constructor = generics.getDeclaredConstructor(Object.class);
@@ -121,13 +131,15 @@ public class ASTToTypedTargetAST {
 
     @Test
     public void definedGenerics2() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Generics2.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics2 = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var generics2 = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
         assertEquals(generics2.getTypeParameters()[0].getBounds()[0], String.class);
         var m = generics2.getDeclaredMethod("m1", Object.class);
         assertEquals(m.getTypeParameters()[0].getBounds()[0], Integer.class);
@@ -135,26 +147,30 @@ public class ASTToTypedTargetAST {
     }
 
     @Test
-    @Ignore("Not implemented")
+    @Disabled("Not implemented")
     public void definedGenerics3() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Generics3.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics3 = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var generics3 = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
     }
 
     @Test
     public void definedGenerics4() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Generics4.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics4 = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var generics4 = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
 
         // var instance = generics4.getDeclaredConstructor().newInstance();
         // var method = generics4.getDeclaredMethod("m2", Object.class);

src/test/java/targetast/GreaterEqualTest.java

@@ -1,22 +1,21 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
+import org.junit.jupiter.api.BeforeAll;
-import org.junit.BeforeClass;
+import org.junit.jupiter.api.Test;
-import org.junit.Test;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class GreaterEqualTest {
     static Class<?> classToTest;
     static Object instance;
 
-    @BeforeClass
+    @BeforeAll
     public static void beforeClass() throws Exception {
-        var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "GreaterEqual.jav");
+        var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "GreaterEqual.jav");
         classToTest = classFiles.get("GreaterEqual");
         instance = classToTest.getDeclaredConstructor().newInstance();
     }

src/test/java/targetast/GreaterThanTest.java

@@ -1,21 +1,20 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
+import org.junit.jupiter.api.BeforeAll;
-import org.junit.BeforeClass;
+import org.junit.jupiter.api.Test;
-import org.junit.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class GreaterThanTest {
     static Class<?> classToTest;
     static Object instance;
 
-    @BeforeClass
+    @BeforeAll
     public static void beforeClass() throws Exception {
-        var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "GreaterThan.jav");
+        var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "GreaterThan.jav");
         classToTest = classFiles.get("GreaterThan");
         instance = classToTest.getDeclaredConstructor().newInstance();
     }

src/test/java/targetast/InheritTest.java

@@ -1,22 +1,20 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
+import org.junit.jupiter.api.BeforeAll;
-import org.junit.BeforeClass;
+import org.junit.jupiter.api.Test;
-import org.junit.Test;
 
 import java.lang.reflect.Method;
-import java.nio.file.Path;
 import java.util.Vector;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class InheritTest {
     private static Class<?> classToTest, classToTestAA, classToTestBB, classToTestCC, classToTestDD;
     private static Object instanceOfClass, instanceOfClassAA, instanceOfClassBB, instanceOfClassCC, instanceOfClassDD;
 
-    @BeforeClass
+    @BeforeAll
     public static void setUpBeforeClass() throws Exception {
-        var classLoader = new ByteArrayClassLoader();
+        var classLoader = TestCodegen.createClassLoader();
 
         var classes = TestCodegen.generateClassFiles(classLoader, "Inherit.jav");
         classToTest = classes.get("Inherit");
@@ -35,72 +33,72 @@ public class InheritTest {
     @Test
     public void testmainAA() throws Exception {
         Method m = classToTestAA.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassAA, 5), "AA");
+        assertEquals("AA", m.invoke(instanceOfClassAA, 5));
         Method main = classToTest.getDeclaredMethod("main", classToTestAA, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, instanceOfClassAA, 5), "AA");
+        assertEquals("AA", main.invoke(instanceOfClass, instanceOfClassAA, 5));
     }
 
     @Test
     public void testmainBB() throws Exception {
         Method m = classToTestAA.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassBB, 5), "AA");
+        assertEquals("AA", m.invoke(instanceOfClassBB, 5));
         Method main = classToTest.getDeclaredMethod("main", classToTestAA, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, instanceOfClassBB, 5), "AA");
+        assertEquals("AA", main.invoke(instanceOfClass, instanceOfClassBB, 5));
     }
 
     @Test
     public void testmainCC() throws Exception {
         Method m = classToTestCC.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassCC, 5), "CC");
+        assertEquals("CC", m.invoke(instanceOfClassCC, 5));
         Method main = classToTest.getDeclaredMethod("main", classToTestCC, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, instanceOfClassCC, 5), "CC");
+        assertEquals("CC", main.invoke(instanceOfClass, instanceOfClassCC, 5));
     }
 
     @Test
     public void testmainDD() throws Exception {
         Method m = classToTestCC.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassDD, 5), "CC");
+        assertEquals("CC", m.invoke(instanceOfClassDD, 5));
         Method main = classToTest.getDeclaredMethod("main", classToTestCC, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, instanceOfClassDD, 5), "CC");
+        assertEquals("CC", main.invoke(instanceOfClass, instanceOfClassDD, 5));
     }
 
     @Test
     public void testmainVectorAA() throws Exception {
         Method m = classToTestAA.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassAA, 5), "AA");
+        assertEquals("AA", m.invoke(instanceOfClassAA, 5));
         Vector v = new Vector<>();
         v.add(instanceOfClassAA);
         Method main = classToTest.getDeclaredMethod("main", Vector.class, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, v, 5), "AA");
+        assertEquals("AA", main.invoke(instanceOfClass, v, 5));
     }
 
     @Test
     public void testmainVectorBB() throws Exception {
         Method m = classToTestAA.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassBB, 5), "AA");
+        assertEquals("AA", m.invoke(instanceOfClassBB, 5));
         Vector v = new Vector<>();
         v.add(instanceOfClassBB);
         Method main = classToTest.getDeclaredMethod("main", Vector.class, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, v, 5), "AA");
+        assertEquals("AA", main.invoke(instanceOfClass, v, 5));
     }
 
     @Test
     public void testmainVectorCC() throws Exception {
         Method m = classToTestCC.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassCC, 5), "CC");
+        assertEquals("CC", m.invoke(instanceOfClassCC, 5));
         Vector v = new Vector<>();
         v.add(instanceOfClassCC);
         Method main = classToTest.getDeclaredMethod("main", Vector.class, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, v, 5), "CC");
+        assertEquals("CC", main.invoke(instanceOfClass, v, 5));
     }
 
     @Test
     public void testmainVectorDD() throws Exception {
         Method m = classToTestCC.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassDD, 5), "CC");
+        assertEquals("CC", m.invoke(instanceOfClassDD, 5));
         Vector v = new Vector<>();
         v.add(instanceOfClassDD);
         Method main = classToTest.getDeclaredMethod("main", Vector.class, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, v, 5), "CC");
+        assertEquals("CC", main.invoke(instanceOfClass, v, 5));
     }
 }

src/test/java/targetast/InheritTest2.java

@@ -1,23 +1,22 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
+import org.junit.jupiter.api.BeforeAll;
-import org.junit.BeforeClass;
+import org.junit.jupiter.api.Disabled;
-import org.junit.Ignore;
+import org.junit.jupiter.api.Test;
-import org.junit.Test;
 
 import java.lang.reflect.Method;
 import java.util.Vector;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-@Ignore("FIXME")
+@Disabled("FIXME")
 public class InheritTest2 {
     private static Class<?> classToTest, classToTestAA, classToTestBB, classToTestCC, classToTestDD;
     private static Object instanceOfClass, instanceOfClassAA, instanceOfClassBB, instanceOfClassCC, instanceOfClassDD;
 
-    @BeforeClass
+    @BeforeAll
     public static void setUpBeforeClass() throws Exception {
-        var classLoader = new ByteArrayClassLoader();
+        var classLoader = TestCodegen.createClassLoader();
         classToTest   = TestCodegen.generateClassFiles(classLoader, "Inherit2.jav").get("Inherit2");
         classToTestAA = TestCodegen.generateClassFiles(classLoader, "AA.jav").get("AA");
         classToTestBB = TestCodegen.generateClassFiles(classLoader, "BB.jav").get("BB");

src/test/java/targetast/LessEqualTest.java

@@ -1,21 +1,20 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
+import org.junit.jupiter.api.BeforeAll;
-import org.junit.BeforeClass;
+import org.junit.jupiter.api.Test;
-import org.junit.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class LessEqualTest {
     static Class<?> classToTest;
     static Object instance;
 
-    @BeforeClass
+    @BeforeAll
     public static void beforeClass() throws Exception {
-        var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "LessEqual.jav");
+        var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "LessEqual.jav");
         classToTest = classFiles.get("LessEqual");
         instance = classToTest.getDeclaredConstructor().newInstance();
     }

src/test/java/targetast/LessThanTest.java

@@ -1,21 +1,20 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
+import org.junit.jupiter.api.BeforeAll;
-import org.junit.BeforeClass;
+import org.junit.jupiter.api.Test;
-import org.junit.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class LessThanTest {
     static Class<?> classToTest;
     static Object instance;
 
-    @BeforeClass
+    @BeforeAll
     public static void beforeClass() throws Exception {
-        var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "LessThan.jav");
+        var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "LessThan.jav");
         classToTest = classFiles.get("LessThan");
         instance = classToTest.getDeclaredConstructor().newInstance();
     }