feat: update compiler Interface

.gitea/workflows/build_and_test.yml

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

pom.xml

@@ -12,37 +12,37 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 	<url>http://maven.apache.org</url>
 	<dependencies>
 		<dependency>
-			<groupId>org.junit.jupiter</groupId>
+			<groupId>junit</groupId>
-			<artifactId>junit-jupiter-api</artifactId>
+			<artifactId>junit</artifactId>
-			<version>5.13.2</version>
+			<version>4.13.2</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.antlr/antlr4 -->
 		<dependency>
 			<groupId>org.antlr</groupId>
 			<artifactId>antlr4</artifactId>
-			<version>4.13.2</version>
+			<version>4.11.1</version>
 		</dependency>
 		<dependency>
 			<groupId>commons-io</groupId>
 			<artifactId>commons-io</artifactId>
-			<version>2.19.0</version>
+			<version>2.16.1</version>
 		</dependency>
 		<dependency>
 			<groupId>io.github.classgraph</groupId>
 			<artifactId>classgraph</artifactId>
-			<version>4.8.180</version>
+			<version>4.8.172</version>
 		</dependency>
 		<dependency>
 			<groupId>com.google.guava</groupId>
 			<artifactId>guava</artifactId>
-			<version>33.4.8-jre</version>
+			<version>33.2.0-jre</version>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm -->
 		<dependency>
 			<groupId>org.ow2.asm</groupId>
 			<artifactId>asm</artifactId>
-			<version>9.8</version>
+			<version>9.5</version>
 		</dependency>
 	</dependencies>
 
@@ -51,17 +51,17 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.14.0</version>
+				<version>3.11.0</version>
 				<configuration>
 					<compilerArgs>--enable-preview</compilerArgs>
-                    <source>24</source>
+                    <source>23</source>
-                    <target>24</target>
+                    <target>23</target>
                 </configuration>
 			</plugin>
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.5.3</version>
+				<version>3.1.0</version>
 				<configuration>
 					<redirectTestOutputToFile>true</redirectTestOutputToFile>
 					<reportsDirectory>${project.build.directory}/test-reports</reportsDirectory>
@@ -77,7 +77,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.antlr</groupId>
 				<artifactId>antlr4-maven-plugin</artifactId>
-				<version>4.13.2</version>
+				<version>4.11.1</version>
 				<executions>
 					<execution>
 						<id>antlr</id>
@@ -90,7 +90,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-jar-plugin</artifactId>
-				<version>3.4.2</version>
+				<version>3.3.0</version>
 				<configuration>
 					<archive>
 						<manifest>

resources/bytecode/javFiles/Bug325.jav

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

resources/bytecode/javFiles/Bug363.jav

@@ -1,22 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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/BugXXX.jav

@@ -0,0 +1,16 @@
+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

@@ -1,14 +0,0 @@
-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);
-        }
-    }
-}

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

@@ -13,7 +13,6 @@ import org.objectweb.asm.*;
 import java.lang.invoke.*;
 import java.lang.reflect.Modifier;
 import java.util.*;
-import java.util.stream.Collectors;
 
 import static org.objectweb.asm.Opcodes.*;
 import static de.dhbwstuttgart.target.tree.expression.TargetBinaryOp.*;
@@ -85,16 +84,14 @@ public class Codegen {
         int localCounter;
         MethodVisitor mv;
         TargetType returnType;
-        boolean isStatic = false;
 
         Stack<BreakEnv> breakStack = new Stack<>();
         Stack<Integer> switchResultValue = new Stack<>();
 
-        State(TargetType returnType, MethodVisitor mv, int localCounter, boolean isStatic) {
+        State(TargetType returnType, MethodVisitor mv, int localCounter) {
             this.returnType = returnType;
             this.mv = mv;
             this.localCounter = localCounter;
-            this.isStatic = isStatic;
         }
 
         void enterScope() {
@@ -232,9 +229,9 @@ public class Codegen {
         if (source.equals(dest))
             return;
         if (source.equals(TargetType.Long)) {
-            if (dest.equals(TargetType.Integer))
+            if (dest.equals(TargetType.Integer)) {
                 mv.visitInsn(L2I);
-            else if (dest.equals(TargetType.Float))
+            } else if (dest.equals(TargetType.Float))
                 mv.visitInsn(L2F);
             else if (dest.equals(TargetType.Double))
                 mv.visitInsn(L2D);
@@ -277,8 +274,6 @@ public class Codegen {
                 mv.visitInsn(I2F);
             else if (dest.equals(TargetType.Double))
                 mv.visitInsn(I2D);
-        } else if (source.equals(TargetType.Boolean)) {
-            unboxPrimitive(state, dest);
         } else if (isFunctionalInterface(source) && isFunctionalInterface(dest) &&
                 !(source instanceof TargetFunNType && dest instanceof TargetFunNType)) {
             boxFunctionalInterface(state, source, dest);
@@ -762,16 +757,6 @@ public class Codegen {
         }
     }
 
-    private static TargetType removeGenerics(TargetType param) {
-        return switch (param) {
-            case null -> null;
-            case TargetFunNType funNType -> new TargetFunNType(funNType.name(), funNType.funNParams(), List.of(), funNType.returnArguments());
-            case TargetRefType refType -> new TargetRefType(refType.name());
-            case TargetGenericType targetGenericType -> TargetType.Object;
-            default -> param;
-        };
-    }
-
     private void generateLambdaExpression(State state, TargetLambdaExpression lambda) {
         var mv = state.mv;
 
@@ -783,8 +768,7 @@ public class Codegen {
 
         var parameters = new ArrayList<>(lambda.captures());
         parameters.addAll(signature.parameters());
-        parameters = parameters.stream().map(param -> param.withType(removeGenerics(param.pattern().type()))).collect(Collectors.toCollection(ArrayList::new));
+        var implSignature = new TargetMethod.Signature(Set.of(), parameters, lambda.signature().returnType());
-        var implSignature = new TargetMethod.Signature(Set.of(), parameters, removeGenerics(lambda.signature().returnType()));
 
         TargetMethod impl;
         if (lambdas.containsKey(lambda)) {
@@ -792,22 +776,21 @@ public class Codegen {
         } else {
             var name = "lambda$" + lambdaCounter++;
 
-            impl = new TargetMethod(state.isStatic ? ACC_STATIC : 0, name, lambda.block(), implSignature, null);
+            impl = new TargetMethod(0, name, lambda.block(), implSignature, null);
-            generateMethod(impl, state);
+            generateMethod(impl);
             lambdas.put(lambda, impl);
         }
 
         var mt = MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class, MethodType.class, MethodHandle.class, MethodType.class);
 
         var bootstrap = new Handle(H_INVOKESTATIC, "java/lang/invoke/LambdaMetafactory", "metafactory", mt.toMethodDescriptorString(), false);
-        var handle = new Handle(state.isStatic ? H_INVOKESTATIC : H_INVOKEVIRTUAL, clazz.getName(), impl.name(), implSignature.getDescriptor(), false);
+        var handle = new Handle(H_INVOKEVIRTUAL, clazz.getName(), impl.name(), implSignature.getDescriptor(), false);
 
         var params = new ArrayList<TargetType>();
-        if(!state.isStatic) params.add(new TargetRefType(clazz.qualifiedName().getClassName()));
+        params.add(new TargetRefType(clazz.qualifiedName().getClassName()));
         params.addAll(lambda.captures().stream().map(mp -> mp.pattern().type()).toList());
 
-        if (!state.isStatic)
+        mv.visitVarInsn(ALOAD, 0);
-            mv.visitVarInsn(ALOAD, 0);
         for (var index = 0; index < lambda.captures().size(); index++) {
             var capture = lambda.captures().get(index);
             var pattern = (TargetTypePattern) capture.pattern();
@@ -1535,7 +1518,7 @@ public class Codegen {
         MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "<clinit>", "()V", null, null);
         mv.visitCode();
 
-        var state = new State(null, mv, 0, true);
+        var state = new State(null, mv, 0);
         generate(state, constructor.block());
 
         mv.visitInsn(RETURN);
@@ -1549,7 +1532,7 @@ public class Codegen {
             mv.visitAttribute(new JavaTXSignatureAttribute(constructor.getTXSignature()));
         
         mv.visitCode();
-        var state = new State(null, mv, 1, false);
+        var state = new State(null, mv, 1);
         for (var param : constructor.parameters()) {
             var pattern = param.pattern();
             if (pattern instanceof TargetTypePattern tp)
@@ -1595,31 +1578,9 @@ public class Codegen {
             }
         }
     }
+
     private void generateMethod(TargetMethod method) {
-        generateMethod(method, null);
-    }
-
-    private void generateMainMethod() {
-        var mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
-        mv.visitCode();
-        mv.visitVarInsn(ALOAD, 0);
-        mv.visitMethodInsn(INVOKESTATIC, "java/util/List", "of", "([Ljava/lang/Object;)Ljava/util/List;", true);
-        mv.visitMethodInsn(INVOKESTATIC, className, "main", "(Ljava/util/List;)V", false);
-        mv.visitInsn(RETURN);
-        mv.visitMaxs(0, 0);
-        mv.visitEnd();
-    }
-
-    private void generateMethod(TargetMethod method, State parent) {
         var access = method.access();
-
-        var params = method.signature().parameters();
-        if (method.name().equals("main") && method.isStatic() && params.size() == 1 &&
-            params.getFirst().pattern().type().equals(new TargetRefType("java.util.List", List.of(new TargetRefType("java.lang.String"))))) {
-
-            generateMainMethod();
-        }
-
         if (method.block() == null)
             access |= ACC_ABSTRACT;
         if (clazz instanceof TargetInterface)
@@ -1633,10 +1594,7 @@ public class Codegen {
 
         if (method.block() != null) {
             mv.visitCode();
-            var state = new State(method.signature().returnType(), mv, method.isStatic() ? 0 : 1, method.isStatic());
+            var state = new State(method.signature().returnType(), mv, method.isStatic() ? 0 : 1);
-            if (parent != null) {
-                state.scope.parent = parent.scope;
-            }
             var offset = 1;
             for (var param : method.signature().parameters()) {
                 state.createVariable(param.pattern().name(), param.pattern().type());
@@ -1646,8 +1604,6 @@ public class Codegen {
                     bindLocalVariables(state, cp, offset);
                 offset++;
             }
-            //if (parent != null) System.out.println("parent: " + parent.scope.locals.keySet());
-            //System.out.println(state.scope.locals.keySet());
             generate(state, method.block());
             if (method.signature().returnType() == null)
                 mv.visitInsn(RETURN);
@@ -1739,7 +1695,7 @@ public class Codegen {
                 methodName = fromMethod.name;
 
                 fromReturn = converter.convert(fromMethod.getReturnType());
-                var fromParams = converter.convert(fromMethod.getParameterList()).stream().map(m -> m.pattern().type()).toArray(TargetType[]::new);
+                var fromParams = converter.convert(fromMethod.getParameterList(), converter.generics.javaGenerics()).stream().map(m -> m.pattern().type()).toArray(TargetType[]::new);
                 fromDescriptor = TargetMethod.getDescriptor(fromReturn, fromParams);
             } else {
                 fromReturn = funNType.returnArguments() > 0 ? TargetType.Object : null;
@@ -1749,12 +1705,12 @@ public class Codegen {
             var toClass = compiler.getClass(new JavaClassName(pair.to.name()));
             var toMethod = toClass.getMethods().stream().filter(m -> (m.modifier & ACC_ABSTRACT) != 0).findFirst().orElseThrow();
             var toReturn = converter.convert(toMethod.getReturnType());
-            var toParams = converter.convert(toMethod.getParameterList()).stream().map(m -> m.pattern().type()).toArray(TargetType[]::new);
+            var toParams = converter.convert(toMethod.getParameterList(), converter.generics.javaGenerics()).stream().map(m -> m.pattern().type()).toArray(TargetType[]::new);
             var toDescriptor = TargetMethod.getDescriptor(toReturn, toParams);
 
             // Generate wrapper method
             var mv = cw2.visitMethod(ACC_PUBLIC, toMethod.name, toDescriptor, null, null);
-            var state = new State(null, mv, 0, false);
+            var state = new State(null, mv, 0);
 
             mv.visitVarInsn(ALOAD, 0);
             mv.visitFieldInsn(GETFIELD, className, "wrapped", pair.from.toDescriptor());
@@ -1786,7 +1742,7 @@ public class Codegen {
                 converter.classLoader.findClass(className);
             } catch (ClassNotFoundException e) {
                 try {
-                    converter.classLoader.loadClass(className, bytes);
+                    converter.classLoader.loadClass(bytes);
                 } catch (LinkageError ignored) {}
             }
         }

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

@@ -39,10 +39,6 @@ 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);

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

@@ -5,6 +5,7 @@ import de.dhbwstuttgart.bytecode.Codegen;
 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;
@@ -393,12 +394,7 @@ public class JavaTXCompiler {
 			logFile.write(ASTTypePrinter.print(sf));
 			System.out.println(ASTTypePrinter.print(sf));
 			logFile.flush();
-			List<UnifyPair> andConstraintsSorted = unifyCons.getUndConstraints().stream()
+			System.out.println("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
-					.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);
@@ -421,14 +417,7 @@ 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();
@@ -469,6 +458,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.
 	 * 
@@ -643,12 +711,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();
-		converter.auxiliaries.forEach((name, source) -> {
-			generatedClasses.put(new JavaClassName(name), source);
-		});
 		return generatedClasses;
 	}
 

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

@@ -0,0 +1,13 @@
+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/IByteArrayClassLoader.java

@@ -6,22 +6,18 @@ 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.loadClass(null, code);
+        return this._defineClass(null, code, 0, code.length);
     }
 
-    default Class<?> loadClass(String name, byte[] code) {
+    default Class loadClass(Path path) throws IOException {
-        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,277 @@
+package de.dhbwstuttgart.languageServerInterface;
+
+
+import de.dhbwstuttgart.bytecode.Codegen;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.environment.ByteArrayClassLoader;
+import de.dhbwstuttgart.environment.IByteArrayClassLoader;
+import de.dhbwstuttgart.languageServerInterface.model.LanguageServerTransferObject;
+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 path the URI of the File. See Example.
+     * @throws IOException
+     * @throws ClassNotFoundException
+     * @throws URISyntaxException
+     */
+    public LanguageServerTransferObject getResultSetAndAbstractSyntax(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 = getLanguageServerTransferObject(uri.getPath().split("/")[uri.getPath().split("/").length - 1], new ByteArrayClassLoader(), new File(stringPathWithoutName).getPath());
+        System.setOut(System.out);
+        return test;
+//        File oldTempSourcefile = new File(stringPathWithoutName + "/out/" + uri.getPath().split("/")[uri.getPath().split("/").length - 1].replace(".jav", ".tmp"));
+//        File oldTempOutFile = new File(stringPathWithoutName + "/out/" + uri.getPath().split("/")[uri.getPath().split("/").length - 1].replace(".jav", ".class"));
+//        Files.deleteIfExists(oldTempSourcefile.toPath());
+//        Files.deleteIfExists(oldTempOutFile.toPath());
+//        FileUtils.deleteDirectory(oldTempSourcefile);
+//
+//        File tempSourcefile = new File(stringPathWithoutName + "/out/" + uri.getPath().split("/")[uri.getPath().split("/").length - 1].replace(".jav", ".tmp"));
+//        File tempOutFile = new File(stringPathWithoutName + "/out/");
+//        FileUtils.writeStringToFile(tempSourcefile, input, "UTF-8");
+//
+//        //TODO: Enable for multiple Class-Files
+//        JavaTXCompiler tx = new JavaTXCompiler(new ArrayList<File>(List.of(tempSourcefile)), new ArrayList<File>(List.of((tempSourcefile))), tempOutFile);
+//        var result = tx.getResultSetAndAbstractSyntax(tempSourcefile);
+//        System.setOut(System.out);
+//        tempSourcefile.delete();
+//        tempOutFile.delete();
+//        return result;
+    }
+
+    /**
+     * 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;
+    }
+
+    private static void writeClassFile(String name, byte[] code, Path outputPath) throws IOException {
+        Files.createDirectories(outputPath);
+        Files.write(outputPath.resolve(name + ".class"), code);
+    }
+
+    public static Map<String, ? extends Class<?>> generateClassFiles(IByteArrayClassLoader classLoader, Path path, Path outputPath, String... files) throws IOException, ClassNotFoundException {
+        Files.createDirectories(outputPath);
+        var filenames = Arrays.stream(files).map(filename -> Path.of(path.toString(), filename).toFile()).toList();
+        var compiler = new JavaTXCompiler(filenames, List.of(path.toFile(), outputPath.toFile()), outputPath.toFile());
+
+        var result = new HashMap<String, Class<?>>();
+        for (var file : filenames) {
+            var resultSet = compiler.typeInference(file);
+
+            var sourceFile = compiler.sourceFiles.get(file);
+            var converter = new ASTToTargetAST(compiler, resultSet, sourceFile, classLoader);
+            var classes = compiler.sourceFiles.get(file).getClasses();
+
+            result.putAll(classes.stream().map(cli -> {
+                try {
+                    return generateClass(converter.convert(cli), classLoader, converter, outputPath);
+                } catch (IOException exception) {
+                    throw new RuntimeException(exception);
+                }
+            }).collect(Collectors.toMap(Class::getName, Function.identity())));
+
+            converter.generateFunNTypes();
+
+            for (var entry : converter.auxiliaries.entrySet()) {
+                writeClassFile(entry.getKey(), entry.getValue(), outputPath);
+            }
+        }
+
+        for (var entry : compiler.loadedClasses.entrySet()) {
+            var name = entry.getKey().toString();
+            result.put(name, classLoader.loadClass(Path.of(entry.getValue().classFile().toURI())));
+        }
+
+        return result;
+    }
+
+    public static Class<?> generateClass(TargetStructure clazz, IByteArrayClassLoader classLoader, ASTToTargetAST converter, Path outputPath) throws IOException {
+        Codegen codegen = new Codegen(clazz, converter.compiler, converter);
+        var code = codegen.generate();
+        writeClassFile(clazz.qualifiedName().getClassName(), code, outputPath);
+        return classLoader.loadClass(code);
+    }
+
+    public static Map<String, ? extends Class<?>> generateClassFiles(String filename, IByteArrayClassLoader classLoader, 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());
+        var resultSet = compiler.typeInference(file);
+
+        var sourceFile = compiler.sourceFiles.get(file);
+        var converter = new ASTToTargetAST(compiler, resultSet, sourceFile, classLoader);
+        var classes = compiler.sourceFiles.get(file).getClasses();
+
+        var result = classes.stream().map(cli -> {
+            try {
+                return generateClass(converter.convert(cli), classLoader, converter, Path.of(filePath + "/out/"));
+            } catch (IOException exception) {
+                throw new RuntimeException(exception);
+            }
+        }).collect(Collectors.toMap(Class::getName, Function.identity()));
+
+        converter.generateFunNTypes();
+
+        for (var entry : converter.auxiliaries.entrySet()) {
+            writeClassFile(entry.getKey(), entry.getValue(), Path.of(filePath + "/out/"));
+        }
+
+        return result;
+    }
+
+    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);
+    }
+
+    public static LanguageServerTransferObject getLanguageServerTransferObject(String filename, IByteArrayClassLoader classLoader, 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());
+        var resultSet = compiler.typeInference(file);
+
+        var sourceFile = compiler.sourceFiles.get(file);
+        var converter = new ASTToTargetAST(compiler, resultSet, sourceFile, classLoader);
+        compiler.generateBytecode();
+        converter.generateFunNTypes();
+
+        var ta = converter.javaGenerics();
+        var tb = converter.txGenerics();
+        Map<SourceFile, List<GenericsResult>> generics = new HashMap<>();
+
+        ArrayList<GenericsResult> genericsResults = new ArrayList<>();
+        genericsResults.addAll(ta);
+        genericsResults.addAll(tb);
+        generics.put(converter.compiler.sourceFiles.values().stream().findFirst().get(), ta);
+        var test = new LanguageServerTransferObject(resultSet, converter.compiler.sourceFiles.values().stream().findFirst().get(), "", generics);
+        return test;
+    }
+
+    /**
+     * generates Bytecode for the given Path of the File.
+     * The Generated Bytecode can be found in the same place as the path, except the File lies in an /out/ Directory
+     * Example: file:///c:/test/main.jav -> file:///c:/test/out/main.class
+     *
+     * @param uri the URI of the File. See Example.
+     * @throws IOException
+     * @throws ClassNotFoundException
+     * @throws URISyntaxException
+     */
+    public void generateBytecode(URI uri) throws IOException, ClassNotFoundException, URISyntaxException {
+
+        System.setOut(new PrintStream(OutputStream.nullOutputStream()));
+
+
+        File inputDir = new File(uri.getPath());
+        File outFile = new File(uri.getPath() + "/out");
+        FileUtils.cleanDirectory(outFile);
+        String[] allowedEndings = {".jav"};
+        ArrayList<File> files = new ArrayList<>();
+
+        try (Stream<Path> stream = Files.walk(Paths.get(inputDir.toURI()))) {
+            stream.filter(Files::isRegularFile)
+                    .forEach(el -> files.add(el.toFile()));
+        }
+
+
+        List<String> javFiles = files.stream().filter(el -> el.getName().split("\\.").length >= 2 && el.getName().split("\\.")[el.getName().split("\\.").length - 1].contains("jav")).map(el -> el.getPath().replace(inputDir.getPath(), "").substring(1)).toList();
+        //TODO: Link between Files
+        generateClassFiles(new ByteArrayClassLoader(), Path.of(inputDir.toURI()), Path.of(outFile.toURI()), javFiles.toArray(new String[0]));
+        System.setOut(System.out);
+    }
+}

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

@@ -1099,9 +1099,9 @@ public class StatementGenerator {
             block = lambdaGenerator.convert(expression.lambdaBody().block(), true);
         }
         List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
-        funNParams.add(TypePlaceholder.fresh(expression.getStart(), -1, false));// ret-Type
+        funNParams.add(TypePlaceholder.fresh(expression.getStart()));// ret-Type
         params.getFormalparalist().forEach(formalParameter -> // Für jeden Parameter einen TPH anfügen:
-        	funNParams.add(TypePlaceholder.fresh(expression.getStart(), 1, false)));
+        funNParams.add(TypePlaceholder.fresh(expression.getStart())));
         RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart());
         // RefType lambdaType = new
         // RefType(reg.getName("Fun"+params.getFormalparalist().size()),

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

@@ -7,7 +7,7 @@ import java.util.*;
 /**
  * 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,10 +22,6 @@ 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/factory/NameGenerator.java

@@ -14,6 +14,10 @@ public class NameGenerator {
     	strNextName = "A";
     }
 
+    public static void resetTo(String name) {
+        strNextName = name;
+    }
+    
     /**
      * Berechnet einen neuen, eindeutigen Namen f�r eine neue                          
      * <code>TypePlaceholder</code>. <br>Author: J�rg B�uerle

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

@@ -2,6 +2,7 @@ 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;
@@ -11,14 +12,11 @@ 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.*;
 import de.dhbwstuttgart.typeinference.result.*;
 
-import java.lang.annotation.Target;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -33,9 +31,9 @@ public class ASTToTargetAST {
 
     public static RefType OBJECT = ASTFactory.createObjectType(); // TODO It would be better if I could call this directly but the hashcode seems to change
 
-    public List<Generics> all;
+    protected List<Generics> all;
-    //public Generics generics;
+    public Generics generics;
-    //public List<Generics> currentMethodOverloads;
+    public List<Generics> currentMethodOverloads;
 
     final Map<ClassOrInterface, Set<GenericTypeVar>> userDefinedGenerics = new HashMap<>();
     final Map<Method, Set<SignaturePair>> tphsInMethods = new HashMap<>();
@@ -55,24 +53,24 @@ public class ASTToTargetAST {
         return all.stream().map(generics -> new GenericsResult(generics.javaGenerics)).toList();
     }
 
-    public TargetExpression convert(Pattern pattern, IGenerics generics) {
+    public TargetExpression convert(Pattern pattern) {
-        var converter = new StatementToTargetExpression(this, generics);
+        var converter = new StatementToTargetExpression(this);
         pattern.accept(converter);
         return converter.result;
     }
 
-    public record Generics(IGenerics javaGenerics, IGenerics txGenerics) {
+    public record Generics(JavaGenerics javaGenerics, TxGenerics txGenerics) {
     }
 
 
     public IByteArrayClassLoader classLoader;
     protected SourceFile sourceFile;
 
-    public ASTToTargetAST(List<ResultSet> resultSets, IByteArrayClassLoader classLoader) {
+    public ASTToTargetAST(List<ResultSet> resultSets) {
-        this(null, resultSets, classLoader);
+        this(null, resultSets);
     }
-    public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets, IByteArrayClassLoader classLoader) {
+    public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets) {
-        this(compiler, resultSets, null, classLoader);
+        this(compiler, resultSets, null, new ByteArrayClassLoader());
     }
 
     public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets, SourceFile sourceFile, IByteArrayClassLoader classLoader) {
@@ -84,6 +82,7 @@ public class ASTToTargetAST {
         for (var set : resultSets) {
             all.add(new Generics(new JavaGenerics(this, set), new TxGenerics(this, set)));
         }
+        this.generics = all.get(0);
     }
 
     public void addSignaturePair(TypePlaceholder signature, RefTypeOrTPHOrWildcardOrGeneric parameter) {
@@ -112,23 +111,20 @@ public class ASTToTargetAST {
             return false;
 
         for (var i = 0; i < pars.size(); i++) {
-            var type1 = pars.get(i).getType();
+            var type1 = convert(pars.get(i).getType(), generics.javaGenerics);
             var type2 = arguments.get(i);
-            //if (type1 instanceof GenericRefType)
+            if (type1 instanceof TargetGenericType)
-            //    return true;
+                return true;
-            //if (TargetType.toPrimitive(type2).equals(type1))
+            if (TargetType.toPrimitive(type2).equals(type1))
-            //    return true;
+                return true;
-            if (type1 instanceof RefType rt) {
+            if (!type1.equals(type2))
-                if (type2 instanceof TargetRefType rt2 && !rt2.name().equals(rt.getName().toString())) {
+                return false;
-                    return false;
-                }
-            }
         }
 
         return true;
     }
 
-    Set<TargetGeneric> convert(Set<GenerateGenerics.Pair> result, IGenerics generics) {
+    Set<TargetGeneric> convert(Set<GenerateGenerics.Pair> result, GenerateGenerics generics) {
         return result.stream().map(p -> {
             if (p instanceof GenerateGenerics.PairLT pair) {
                 return new TargetGeneric(pair.left.resolve().getName(), convert(pair.right.resolve(), generics));
@@ -140,7 +136,7 @@ public class ASTToTargetAST {
         }).collect(Collectors.toSet());
     }
 
-    public List<TargetGeneric> convert(GenericTypeVar typeVar, IGenerics generics) {
+    public List<TargetGeneric> convert(GenericTypeVar typeVar, GenerateGenerics generics) {
         var ret = new ArrayList<TargetGeneric>();
         for (var bound : typeVar.getBounds()) {
             ret.add(new TargetGeneric(typeVar.getName(), generics.getTargetType(bound)));
@@ -149,7 +145,6 @@ public class ASTToTargetAST {
     }
 
     // This finds a common sealed interface type to group together methods that use different records
-    // This function should do matching or unification
     private List<ClassOrInterface> commonSuperInterfaceTypes(TargetType a, TargetType b) {
         if (a instanceof TargetGenericType && b instanceof TargetGenericType) return List.of(ASTFactory.createObjectClass());
         if (a instanceof TargetRefType ta && b instanceof TargetGenericType)
@@ -187,28 +182,44 @@ public class ASTToTargetAST {
         return List.of();
     }
 
-    private boolean canCombine(Signature m1, Signature m2) {
+    // TODO This is ugly and probably doesn't work right
-        var pl1 = m1.java.parameters();
+    private boolean patternStrictlyEquals(TargetComplexPattern a, TargetComplexPattern b) {
-        var pl2 = m2.java.parameters();
+        if (!a.name().equals(b.name())) return false;
-        if (pl1.size() != pl2.size()) return false;
+        if (a.subPatterns().size() != b.subPatterns().size()) return false;
-        if (pl1.isEmpty()) return false;
+        for (var i = 0; i < a.subPatterns().size(); i++) {
-        for (var i = 0; i < pl1.size(); i++) {
+            var p1 = a.subPatterns().get(i);
-            var p1 = pl1.get(i).pattern();
+            var p2 = b.subPatterns().get(i);
-            var p2 = pl2.get(i).pattern();
-            // TPH <> RefType sind nicht unterscheidbar
-            if (p1.type() instanceof TargetGenericType || p2.type() instanceof TargetGenericType) continue;
-            // Pattern(X) <> Pattern(Y) ist nicht unterscheidbar
             if (p1 instanceof TargetComplexPattern pc1 && p2 instanceof TargetComplexPattern pc2 &&
-                pc1.type().equals(pc2.type())) continue;
+                patternStrictlyEquals(pc1, pc2)) return false;
-            if (!p1.equals(p2)) return false;
+            if (p1 instanceof TargetTypePattern pt1 && p2 instanceof TargetTypePattern pt2) {
+                if (pt1.type() instanceof TargetGenericType && pt2.type() instanceof TargetGenericType) continue;
+            }
+            if (!p1.type().equals(p2.type()) && commonSuperInterfaceTypes(p1.type(), p2.type()).isEmpty()) return false;
         }
         return true;
     }
 
-    private record Combination(MethodWithTphs a, MethodWithTphs b) {
+    private boolean canCombine(TargetMethod m1, TargetMethod m2) {
+        if (!m1.name().equals(m2.name())) return false;
+        var s1 = m1.signature();
+        var s2 = m2.signature();
+        if (s1.parameters().size() != s2.parameters().size()) return false;
+        if (s1.parameters().isEmpty()) return false;
+        for (var i = 0; i < s1.parameters().size(); i++) {
+            var p1 = s1.parameters().get(i).pattern();
+            var p2 = s2.parameters().get(i).pattern();
+            if (p1.type() instanceof TargetGenericType || p2.type() instanceof TargetGenericType) continue;
+            if (p1 instanceof TargetComplexPattern pc1 && p2 instanceof TargetComplexPattern pc2 &&
+                patternStrictlyEquals(pc1, pc2)) return false;
+            if (!p1.equals(p2) && commonSuperInterfaceTypes(p1.type(), p2.type()).isEmpty()) return false;
+        }
+        return true;
+    }
+
+    private record Combination(TargetMethod a, TargetMethod b) {
         @Override
         public boolean equals(Object o) {
-            if (!(o instanceof Combination(MethodWithTphs a1, MethodWithTphs b1))) return false;
+            if (!(o instanceof Combination(TargetMethod a1, TargetMethod b1))) return false;
             return this.a.equals(a1) && this.b.equals(b1) ||
                 this.a.equals(b1) && this.b.equals(a1);
         }
@@ -219,10 +230,10 @@ public class ASTToTargetAST {
         }
     }
 
-    private List<List<MethodWithTphs>> groupOverloads(ClassOrInterface input, List<Method> methods) {
+    public List<List<TargetMethod>> groupOverloads(ClassOrInterface input, List<Method> methods) {
-        var mapOfTargetMethods = new HashMap<Generics, MethodWithTphs[]>();
+        var mapOfTargetMethods = new HashMap<Generics, TargetMethod[]>();
-        for (var gen : all) {
+        for (var generics : all) {
-            mapOfTargetMethods.put(gen, new MethodWithTphs[methods.size()]);
+            mapOfTargetMethods.put(generics, new TargetMethod[methods.size()]);
         }
 
         for (var i = 0; i < methods.size(); i++) {
@@ -231,14 +242,14 @@ public class ASTToTargetAST {
             var methodsWithTphs = convert(input, method);
             for (var m : methodsWithTphs) {
                 var resultMethods = mapOfTargetMethods.get(m.generics);
-                resultMethods[i] = new MethodWithTphs(m.method, m.generics, m.signature);
+                resultMethods[i] = m.method;
             }
         }
-        System.out.println("============== INPUT ==============");
+        /*System.out.println("============== INPUT ==============");
         for (var m : mapOfTargetMethods.values()) {
-            for (var v : m) if (v != null) System.out.println(v.method.name + " " + v.signature.java.getSignature());
+            for (var v : m) System.out.println(v.name() + " " + v.getSignature());
             System.out.println();
-        }
+        }*/
 
         var allCombinations = new HashSet<Set<Combination>>();
         // Combine methods based on their signature and position in the result set
@@ -256,8 +267,8 @@ public class ASTToTargetAST {
 
                     var combinations = new HashSet<Combination>();
 
-                    if (canCombine(m1.signature, m2.signature)) {
+                    if (canCombine(m1, m2)) {
-                        System.out.println("     Combining " + m1.signature.java.getSignature() + " and " + m2.signature.java.getSignature());
+                        //System.out.println("     Combining " + m1.getSignature() + " and " + m2.getSignature());
                         combinations.add(new Combination(m1, m2));
                         for (var j = 0; j < methods.size(); j++) {
                             if (j == i) continue;
@@ -266,10 +277,10 @@ public class ASTToTargetAST {
                             var m4 = resMeth1[j];
                             if (m4 == null) continue;
                             combinations.add(new Combination(m4, m3));
-                            System.out.println("Also Combining " + m4.signature.java.getSignature() + " and " + m3.signature.java.getSignature());
+                            //System.out.println("Also Combining " + m4.getSignature() + " and " + m3.getSignature());
                         }
                     } else {
-                        System.out.println(" Not Combining " + m1.signature.java.getSignature() + " and " + m2.signature.java.getSignature());
+                        //System.out.println(" Not Combining " + m1.getSignature() + " and " + m2.getSignature());
                     }
                     if (!combinations.isEmpty()) allCombinations.add(combinations);
                 }
@@ -279,14 +290,14 @@ public class ASTToTargetAST {
         if (allCombinations.isEmpty()) allCombinations.add(new HashSet<>());
 
         // Combine back into output format
-        var r0 = new HashSet<Set<MethodWithTphs>>();
+        var r0 = new HashSet<Set<TargetMethod>>();
         for (var combinations : allCombinations) {
-            var r1 = new HashSet<Set<MethodWithTphs>>();
+            var r1 = new HashSet<Set<TargetMethod>>();
             // This is used to weed out duplicates
-            var uniqued = new HashSet<MethodWithTphs>();
+            var uniqued = new HashSet<TargetMethod>();
             // We go over all methods in the result
             for (var g : all) for (var i = 0; i < methods.size(); i++) {
-                var r2 = new HashSet<MethodWithTphs>();
+                var r2 = new HashSet<TargetMethod>();
                 var m = mapOfTargetMethods.get(g)[i];
                 if (m == null) continue;
                 if (!uniqued.contains(m)) {
@@ -328,14 +339,13 @@ public class ASTToTargetAST {
 
         System.out.println("============== OUTPUT ==============");
         for (var l : result) {
-            for (var m : l) System.out.println(m.method.name + " " + m.signature.java.getSignature());
+            for (var m : l) System.out.println(m.name() + " " + m.getSignature());
             System.out.println();
         }
         return result;
     }
 
     public TargetStructure convert(ClassOrInterface input) {
-        var generics = all.getFirst();
         Set<TargetGeneric> javaGenerics = new HashSet<>();
         Set<TargetGeneric> txGenerics = new HashSet<>();
 
@@ -348,7 +358,7 @@ public class ASTToTargetAST {
                 var next = genericsIter.next();
                 userDefinedGenerics.add(next);
                 // TODO Support multiple bounds
-                javaGenerics.add(new TargetGeneric(next.getName(), convert(next.getBounds().getFirst(), generics.javaGenerics)));
+                javaGenerics.add(new TargetGeneric(next.getName(), convert(next.getBounds().get(0))));
             }
         } else {
             this.userDefinedGenerics.put(input, new HashSet<>());
@@ -359,20 +369,18 @@ public class ASTToTargetAST {
 
         TargetBlock fieldInitializer = null;
         if (input.getfieldInitializations().isPresent())
-            fieldInitializer = convert(input.getfieldInitializations().get().block, generics.javaGenerics);
+            fieldInitializer = convert(input.getfieldInitializations().get().block);
         TargetBlock finalFieldInitializer = fieldInitializer;
 
         var superInterfaces = input.getSuperInterfaces().stream().map(clazz -> convert(clazz, generics.javaGenerics)).toList();
-        var constructors = input.getConstructors().stream().map(constructor -> this.convert(input, constructor, finalFieldInitializer, generics)).flatMap(List::stream).toList();
+        var constructors = input.getConstructors().stream().map(constructor -> this.convert(input, constructor, finalFieldInitializer)).flatMap(List::stream).toList();
-        var fields = input.getFieldDecl().stream().map(f -> convert(f, generics.javaGenerics)).toList();
+        var fields = input.getFieldDecl().stream().map(this::convert).toList();
         var methods = groupOverloads(input, input.getMethods()).stream().map(m -> generatePatternOverloads(input, m)).flatMap(List::stream)
                 .collect(Collectors.toSet()).stream().toList(); // Unique generated methods
 
         TargetMethod staticConstructor = null;
-        if (input.getStaticInitializer().isPresent()) {
+        if (input.getStaticInitializer().isPresent())
-            var init = this.convert(input, input.getStaticInitializer().get()).stream().findFirst().orElseThrow();
+            staticConstructor = this.convert(input, input.getStaticInitializer().get()).stream().findFirst().orElseThrow().method;
-            staticConstructor = this.convert(init, init.generics.javaGenerics);
-        }
 
         if (input instanceof Record)
             return new TargetRecord(input.getModifiers(), input.getClassName(), javaGenerics, txGenerics, superInterfaces, constructors, staticConstructor, fields, methods);
@@ -381,16 +389,11 @@ public class ASTToTargetAST {
         else return new TargetClass(input.getModifiers(), input.getClassName(), convert(input.getSuperClass(), generics.javaGenerics), javaGenerics, txGenerics, superInterfaces, constructors, staticConstructor, fields, methods);
     }
 
-    @Deprecated
+    public List<MethodParameter> convert(ParameterList input, GenerateGenerics generics) {
-    public List<MethodParameter> convert(ParameterList input) {
-        return convert(input, all.getFirst().javaGenerics);
-    }
-
-    public List<MethodParameter> convert(ParameterList input, IGenerics generics) {
         var res = new ArrayList<MethodParameter>();
         for (var i = 0; i < input.getFormalparalist().size(); i++) {
             var param = input.getFormalparalist().get(i);
-            var pattern = (TargetPattern) convert(param, generics);
+            var pattern = (TargetPattern) convert(param);
             if (pattern instanceof TargetComplexPattern) pattern = pattern.withName("__var" + i);
             res.add(new MethodParameter(pattern));
         }
@@ -401,7 +404,7 @@ public class ASTToTargetAST {
         return generics.stream().anyMatch(g -> g.name().equals(type.getParsedName()));
     }
 
-    private Set<TargetGeneric> collectMethodGenerics(ClassOrInterface clazz, IGenerics generateGenerics, Set<GenerateGenerics.Pair> generics, Method input) {
+    private Set<TargetGeneric> collectMethodGenerics(ClassOrInterface clazz, GenerateGenerics generateGenerics, Set<GenerateGenerics.Pair> generics, Method input) {
         var convertedGenerics = new HashSet<>(convert(generics, generateGenerics));
         outer: for (GenericTypeVar typeVar : input.getGenerics()) {
             for (var classGeneric : clazz.getGenerics()) {
@@ -419,7 +422,7 @@ public class ASTToTargetAST {
         return convertedGenerics;
     }
 
-    private List<TargetConstructor> convert(ClassOrInterface currentClass, Constructor input, TargetBlock fieldInitializer, Generics generics) {
+    private List<TargetConstructor> convert(ClassOrInterface currentClass, Constructor input, TargetBlock fieldInitializer) {
         generics = all.get(0);
         List<TargetConstructor> result = new ArrayList<>();
         Set<List<MethodParameter>> parameterSet = new HashSet<>();
@@ -427,15 +430,15 @@ public class ASTToTargetAST {
 
         for (var s : all) {
             generics = s;
-            var javaGenerics = generics.javaGenerics.generics(currentClass, input);
+            var javaGenerics = this.generics.javaGenerics.generics(currentClass, input);
-            var txGenerics = generics.txGenerics.generics(currentClass, input);
+            var txGenerics = this.generics.txGenerics.generics(currentClass, input);
-            List<MethodParameter> params = convert(input.getParameterList(), generics.javaGenerics);
+            List<MethodParameter> params = convert(input.getParameterList(), this.generics.javaGenerics);
             if (parameterSet.stream().noneMatch(p -> p.equals(params))) {
-                List<MethodParameter> txParams = convert(input.getParameterList(), generics.txGenerics);
+                List<MethodParameter> txParams = convert(input.getParameterList(), this.generics.txGenerics);
                 var javaMethodGenerics = collectMethodGenerics(currentClass, generics.javaGenerics(), javaGenerics, input);
                 var txMethodGenerics = collectMethodGenerics(currentClass, generics.txGenerics(), txGenerics, input);
 
-                result.add(new TargetConstructor(input.modifier, javaMethodGenerics, txMethodGenerics, params, txParams, convert(input.block, generics.javaGenerics), fieldInitializer));
+                result.add(new TargetConstructor(input.modifier, javaMethodGenerics, txMethodGenerics, params, txParams, convert(input.block), fieldInitializer));
                 parameterSet.add(params);
             }
         }
@@ -443,13 +446,10 @@ public class ASTToTargetAST {
         return result;
     }
 
-    private static int counter = 0;
     private String encodeName(String name, TargetMethod.Signature params) {
         var res = new StringBuilder();
         res.append(name);
         res.append('$');
-        res.append(counter++);
-        res.append('$');
         for (var param : params.parameters()) {
             encodeName(param.pattern(), res);
         }
@@ -525,14 +525,12 @@ public class ASTToTargetAST {
                 var j = 0;
                 for (var param : m.signature().parameters()) {
                     if (j >= patternsRec.size()) return true;
-                    if (!patternsRec.get(j).equals(param.pattern())) return false;
+                    if (!patternsRec.get(j).type().equals(param.pattern().type())) return false;
                     j++;
                 }
                 return true;
             }).toList();
 
-            //System.out.println(offset + " -> " + lastPattern);
-            //candidates.forEach(m -> System.out.println(m.getSignature()));
             var caseBody = generatePatternOverloadsRec(offset + 1, expr, params, patternsRec, candidates, classType);
             var body = new TargetBlock(List.of(caseBody));
             var case_ = new TargetSwitch.Case(List.of(lastPattern), body);
@@ -543,14 +541,19 @@ public class ASTToTargetAST {
         return new TargetSwitch(switchExpr, cases, null, true);
     }
 
-    private List<TargetMethod> generatePatternOverloads(ClassOrInterface clazz, List<MethodWithTphs> overloadedMethods) {
+    private List<TargetMethod> generatePatternOverloads(ClassOrInterface clazz, List<TargetMethod> overloadedMethods) {
-        if (overloadedMethods.isEmpty()) return List.of();
+        if (overloadedMethods.size() <= 1) return overloadedMethods;
         // Check if we have a pattern as a parameter
-        var firstMethod = convert(overloadedMethods.getFirst(), overloadedMethods.getFirst().generics.javaGenerics);
+        var firstMethod = overloadedMethods.getFirst();
-        if (overloadedMethods.size() == 1) return List.of(firstMethod);
+        var secondMethod = overloadedMethods.get(1);
-        var secondMethod = convert(overloadedMethods.get(1), overloadedMethods.get(1).generics.javaGenerics);
+        if (firstMethod.signature().parameters().stream().noneMatch(mp -> mp.pattern() instanceof TargetComplexPattern)) return overloadedMethods;
-        if (firstMethod.signature().parameters().stream().noneMatch(mp -> mp.pattern() instanceof TargetComplexPattern))
+        // Rename existing methods
-            return overloadedMethods.stream().map(m -> convert(m, m.generics.javaGenerics)).toList();
+
+        var res = new ArrayList<TargetMethod>();
+        for (var method : overloadedMethods) {
+            var name = encodeName(method.name(), method.signature());
+            res.add(new TargetMethod(method.access(), name, method.block(), method.signature(), method.txSignature()));
+        }
 
         var signatureParams = new ArrayList<MethodParameter>();
         for (var i = 0; i < firstMethod.signature().parameters().size(); i++) {
@@ -559,7 +562,7 @@ public class ASTToTargetAST {
             var t2 = secondMethod.signature().parameters().get(i).pattern().type();
             var commonSubTypes = new HashSet<>(commonSuperInterfaceTypes(t1, t2));
             for (var m : overloadedMethods.subList(2, overloadedMethods.size())) {
-                var t3 = m.signature().java.parameters().get(i).pattern().type();
+                var t3 = m.signature().parameters().get(i).pattern().type();
                 commonSubTypes.retainAll(commonSuperInterfaceTypes(t1, t3));
             }
             if (commonSubTypes.size() > 1) throw new DebugException("Invalid overload");
@@ -574,28 +577,9 @@ public class ASTToTargetAST {
             signatureParams.add(new MethodParameter(new TargetRefType(superType.getClassName().toString()), name));
         }
 
-        // Rename existing methods
-
-        var res = new ArrayList<TargetMethod>();
-        for (var method : overloadedMethods) {
-            var name = encodeName(method.method.name, method.signature.java);
-
-            var generics = new OverlayGenerics(method.generics.javaGenerics, this);
-            var m = overloadedMethods.getFirst();
-            var params = m.method.getParameterList().getFormalparalist();
-            for (var i = 0; i < params.size(); i++) {
-                var param = params.get(i);
-                if (param.getType() instanceof TypePlaceholder tph) {
-                    generics.addOverlay(tph, signatureParams.get(i).pattern().type());
-                }
-            }
-            var tMethod = convert(method, generics);
-            res.add(new TargetMethod(tMethod.access(), name, tMethod.block(), tMethod.signature(), tMethod.txSignature()));
-        }
-
         var commonSubTypes = new HashSet<>(commonSuperInterfaceTypes(firstMethod.signature().returnType(), secondMethod.signature().returnType()));
         for (var m : overloadedMethods.subList(2, overloadedMethods.size())) {
-            commonSubTypes.retainAll(commonSuperInterfaceTypes(firstMethod.signature().returnType(), m.signature().java.returnType()));
+            commonSubTypes.retainAll(commonSuperInterfaceTypes(firstMethod.signature().returnType(), m.signature().returnType()));
         }
         var returnType = commonSubTypes.isEmpty() ? TargetType.Object : new TargetRefType(commonSubTypes.iterator().next().getClassName().toString());
 
@@ -616,7 +600,7 @@ public class ASTToTargetAST {
     }
 
     private Expression makeRecordSwitch(RefTypeOrTPHOrWildcardOrGeneric returnType, ParameterList params, List<Method> overloadedMethods) {
-        var param = params.getFormalparalist().getFirst();
+        var param = params.getFormalparalist().get(0);
         assert param instanceof RecordPattern; // TODO
 
         var cases = new ArrayList<SwitchBlock>();
@@ -636,7 +620,7 @@ public class ASTToTargetAST {
         return swtch;
     }
 
-    private Optional<Method> findSuperMethodToOverride(ClassOrInterface currentClass, String name, List<MethodParameter> params, IGenerics generics) {
+    private Optional<Method> findSuperMethodToOverride(ClassOrInterface currentClass, String name, List<MethodParameter> params) {
         var superClass = compiler.getClass(currentClass.getSuperClass().getName());
         var methodStream = superClass.getMethods().stream();
         for (var superInterface : currentClass.getSuperInterfaces()) {
@@ -649,106 +633,115 @@ public class ASTToTargetAST {
             if (sParams.getFormalparalist().size() != params.size()) return false;
             for (var i = 0; i < params.size(); i++) {
                 var a = TargetType.toPrimitive(params.get(i).pattern().type());
-                var b = convert(sParams.getFormalparalist().get(i).getType(), generics);
+                var b = convert(sParams.getFormalparalist().get(i).getType());
                 if (!Objects.equals(a, b)) return false;
             }
             return true;
         }).findFirst();
     }
 
-    record MethodWithTphs(Method method, Generics generics, Signature signature) {
+    record MethodWithTphs(TargetMethod method, Generics generics, List<SignaturePairTarget> args) {
         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
             if (!(o instanceof MethodWithTphs that)) return false;
-            return Objects.equals(method, that.method) && Objects.equals(signature, that.signature);
+            return Objects.equals(method, that.method) && Objects.equals(args, that.args);
         }
 
         @Override
         public int hashCode() {
-            return Objects.hash(method, signature);
+            return Objects.hash(method, args);
         }
     }
 
-    private TargetMethod convert(MethodWithTphs mtph, IGenerics generics) {
-        return new TargetMethod(mtph.method.modifier, mtph.method.name, convert(mtph.method.block, generics), mtph.signature.java(), mtph.signature.tx());
-    }
-
     record Signature(TargetMethod.Signature java, TargetMethod.Signature tx, Generics generics) {}
 
     private List<MethodWithTphs> convert(ClassOrInterface currentClass, Method method) {
+        generics = all.getFirst();
         List<MethodWithTphs> result = new ArrayList<>();
         this.currentMethod = method;
 
         List<Signature> signatures = new ArrayList<>();
-        for (var generics : all) {
+        HashMap<TargetMethod.Signature, List<Generics>> collectedGenerics = new HashMap<>();
-            var javaGenerics = generics.javaGenerics.generics(currentClass, method);
+
-            var txGenerics = generics.txGenerics.generics(currentClass, method);
+        for (var s : all) {
-            List<MethodParameter> params = convert(method.getParameterList(), generics.javaGenerics);
+            generics = s;
-            var returnType = convert(method.getReturnType(), generics.javaGenerics);
+            var javaGenerics = this.generics.javaGenerics.generics(currentClass, method);
-            var superMethod = findSuperMethodToOverride(currentClass, method.getName(), params, generics.javaGenerics);
+            var txGenerics = this.generics.txGenerics.generics(currentClass, method);
+            List<MethodParameter> params = convert(method.getParameterList(), this.generics.javaGenerics);
+            var returnType = convert(method.getReturnType(), this.generics.javaGenerics);
+            var superMethod = findSuperMethodToOverride(currentClass, method.getName(), params);
             if (superMethod.isPresent()) {
                 // If we find a super method to override, use its parameters and return types
-                var newReturnType = convert(superMethod.get().getReturnType(), generics.javaGenerics);
+                var newReturnType = convert(superMethod.get().getReturnType(), this.generics.javaGenerics);
                 if (newReturnType instanceof TargetPrimitiveType && TargetType.toPrimitive(returnType).equals(newReturnType)) {
                     returnType = newReturnType;
-                    params = convert(superMethod.get().getParameterList(), method.getParameterList(), generics.javaGenerics);
+                    params = convert(superMethod.get().getParameterList(), method.getParameterList(), this.generics.javaGenerics);
                 }
             }
 
-            List<MethodParameter> txParams = convert(method.getParameterList(), generics.txGenerics);
+            List<MethodParameter> txParams = convert(method.getParameterList(), this.generics.txGenerics);
 
             var javaMethodGenerics = collectMethodGenerics(currentClass, generics.javaGenerics(), javaGenerics, method);
             var txMethodGenerics = collectMethodGenerics(currentClass, generics.txGenerics(), txGenerics, method);
 
             var javaSignature = new TargetMethod.Signature(javaMethodGenerics, params, returnType);
-            var txSignature = new TargetMethod.Signature(txMethodGenerics, txParams, convert(method.getReturnType(), generics.txGenerics));
+            var txSignature = new TargetMethod.Signature(txMethodGenerics, txParams, convert(method.getReturnType(), this.generics.txGenerics));
 
             signatures.add(new Signature(javaSignature, txSignature, generics));
+            var listOfGenerics = collectedGenerics.getOrDefault(javaSignature, new ArrayList<>());
+            listOfGenerics.add(generics);
+            collectedGenerics.put(javaSignature, listOfGenerics);
         }
 
         for (var signature : signatures) {
-            result.add(new MethodWithTphs(method, signature.generics, signature));
+            generics = signature.generics;
+            currentMethodOverloads = collectedGenerics.get(signature.java);
+
+            var newMethod = new TargetMethod(method.modifier, method.name, convert(method.block), signature.java, signature.tx);
+            var concreteParams = tphsInMethods.getOrDefault(method, new HashSet<>()).stream().map(sig -> new SignaturePairTarget(convert(sig.signature), convert(sig.parameter))).toList();
+
+            result.add(new MethodWithTphs(newMethod, generics, concreteParams));
         }
 
         return result;
     }
 
-    private List<MethodParameter> convert(ParameterList superList, ParameterList paraList, IGenerics generics) {
+    private List<MethodParameter> convert(ParameterList superList, ParameterList paraList, JavaGenerics generics) {
         var list = new ArrayList<MethodParameter>();
         for (var i = 0; i < paraList.getFormalparalist().size(); i++) {
             var param = paraList.getParameterAt(i);
-            var pattern = (TargetPattern) convert(param, generics);
+            var pattern = (TargetPattern) convert(param);
             if (pattern instanceof TargetComplexPattern) pattern = pattern.withName("__var" + i);
             list.add(new MethodParameter(pattern).withType(convert(superList.getParameterAt(i).getType(), generics)));
         }
         return list;
     }
 
-    protected TargetSwitch.Case convert(SwitchBlock block, IGenerics generics) {
+    protected TargetSwitch.Case convert(SwitchBlock block) {
-        return new TargetSwitch.Case(block.getLabels().stream().map(s -> convert(s, generics)).toList(), convert((Block) block, generics), block.isExpression);
+        return new TargetSwitch.Case(block.getLabels().stream().map(this::convert).toList(), convert((Block) block), block.isExpression);
     }
 
-    protected TargetBlock convert(Block block, IGenerics generics) {
+    protected TargetBlock convert(Block block) {
         if (block == null) return null;
-        return new TargetBlock(block.statements.stream().map(s -> convert(s, generics)).toList());
+        return new TargetBlock(block.statements.stream().map(this::convert).toList());
     }
 
-    protected TargetBlock convertWrapInBlock(Expression expression, IGenerics generics) {
+    protected TargetBlock convertWrapInBlock(Expression expression) {
-        var res = convert(expression, generics);
+        var res = convert(expression);
         if (!(res instanceof TargetBlock))
             return new TargetBlock(List.of(res));
         return (TargetBlock) res;
     }
 
-    protected TargetExpression convert(Expression expr, IGenerics generics) {
+    protected TargetExpression convert(Expression expr) {
-        var converter = new StatementToTargetExpression(this, generics);
+        var converter = new StatementToTargetExpression(this);
         expr.accept(converter);
         return converter.result;
     }
 
-    private TargetField convert(Field input, IGenerics generics) {
+    private TargetField convert(Field input) {
-        return new TargetField(input.modifier, convert(input.getType(), generics), input.getName());
+        return new TargetField(input.modifier, convert(input.getType(), generics.javaGenerics), input.getName());
     }
 
     private final Map<String, FunNGenerator.GenericParameters> usedFunN = new HashMap<>();
@@ -756,6 +749,9 @@ public class ASTToTargetAST {
 
     public Map<String, byte[]> auxiliaries = new HashMap<>();
 
+    public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input) {
+        return convert(input, generics.javaGenerics);
+    }
 
     private static void collectArguments(TargetSpecializedType tspec, List<TargetType> newParams) {
         for (var i = 0; i < tspec.params().size(); i++) {
@@ -785,15 +781,7 @@ 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;
@@ -830,17 +818,19 @@ public class ASTToTargetAST {
                 .toList();
 
             var code = FunNGenerator.generateSpecializedBytecode(gep, superInterfaces);
+
+            try {
+                classLoader.findClass(entry.getKey());
+            } catch (ClassNotFoundException e) {
+                try {
+                    classLoader.loadClass(code);
+                } catch (LinkageError ignored) {}
+            }
             auxiliaries.put(entry.getKey(), code);
         }
     }
 
-    // FIXME This method shouldn't be used
+    protected TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, GenerateGenerics generics) {
-    @Deprecated
-    public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input) {
-        return convert(input, all.getFirst().javaGenerics);
-    }
-
-    public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, IGenerics generics) {
         return input.acceptTV(new TypeVisitor<>() {
             @Override
             public TargetType visit(RefType refType) {
@@ -866,7 +856,7 @@ public class ASTToTargetAST {
                             classLoader.findClass(superClassName);
                         } catch (ClassNotFoundException e) {
                             try {
-                                classLoader.loadClass(superClassName, code);
+                                classLoader.loadClass(code);
                             } catch (LinkageError ignored) {}
                         }
                         auxiliaries.put(superClassName, code);

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

@@ -16,7 +16,7 @@ import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public abstract class GenerateGenerics implements IGenerics {
+public abstract class GenerateGenerics {
 
     private final ASTToTargetAST astToTargetAST;
 
@@ -151,6 +151,22 @@ public abstract class GenerateGenerics implements IGenerics {
         System.out.println("Simplified constraints: " + simplifiedConstraints);
     }
 
+    /*public record GenericsState(Map<TPH, RefTypeOrTPHOrWildcardOrGeneric> concreteTypes, Map<TypePlaceholder, TypePlaceholder> equality) {}
+
+    public GenericsState store() {
+        return new GenericsState(new HashMap<>(concreteTypes), new HashMap<>(equality));
+    }
+
+    public void restore(GenericsState state) {
+        this.concreteTypes = state.concreteTypes;
+        this.equality = state.equality;
+    }
+
+    public void addOverlay(TypePlaceholder from, RefTypeOrTPHOrWildcardOrGeneric to) {
+        if (to instanceof TypePlaceholder t) equality.put(from, t);
+        else if (to instanceof RefType t) concreteTypes.put(new TPH(from), t);
+    }*/
+
     Set<TPH> findTypeVariables(ParameterList params) {
         var res = new HashSet<TPH>();
         for (var param : params.getFormalparalist()) {
@@ -266,7 +282,6 @@ public abstract class GenerateGenerics implements IGenerics {
             Set<Pair> result
     ) {
         var userDefinedGenericsOfClass = astToTargetAST.userDefinedGenerics.get(owner);
-        var generics = this;
 
         // Type variables with bounds that are also type variables of the method
         for (var typeVariable : new HashSet<>(typeVariables)) {
@@ -314,7 +329,7 @@ public abstract class GenerateGenerics implements IGenerics {
 
                     if (methodCall.receiver instanceof ExpressionReceiver expressionReceiver) {
                         if (expressionReceiver.expr instanceof This) {
-                            var optMethod = astToTargetAST.findMethod(owner, methodCall.name, methodCall.signatureArguments().stream().map(sa -> astToTargetAST.convert(sa, generics)).toList());
+                            var optMethod = astToTargetAST.findMethod(owner, methodCall.name, methodCall.signatureArguments().stream().map(astToTargetAST::convert).toList());
                             if (optMethod.isEmpty()) return;
                             var method2 = optMethod.get();
                             System.out.println("In: " + method.getName() + " Method: " + method2.getName());
@@ -524,6 +539,8 @@ public abstract class GenerateGenerics implements IGenerics {
             });
     }
 
+    abstract void generics(ClassOrInterface owner, Method method, Set<Pair> result, Set<TPH> javaTypeVariablesOfClass);
+
     Set<Pair> family(ClassOrInterface owner, Method method) {
         Set<Pair> result = new HashSet<>();
         if (familyOfMethods.containsKey(method))
@@ -547,8 +564,7 @@ public abstract class GenerateGenerics implements IGenerics {
         return result;
     }
 
-    @Override
+    Set<Pair> generics(ClassOrInterface owner, Method method) {
-    public Set<Pair> generics(ClassOrInterface owner, Method method) {
         if (computedGenericsOfMethods.containsKey(method)) {
             var cached = computedGenericsOfMethods.get(method);
             System.out.println("Cached " + method.getName() + ": " + cached);
@@ -636,10 +652,8 @@ public abstract class GenerateGenerics implements IGenerics {
     }
 
     abstract void generics(ClassOrInterface classOrInterface, Set<Pair> result, Set<TPH> referenced);
-    abstract void generics(ClassOrInterface owner, Method method, Set<Pair> result, Set<TPH> referenced);
 
-    @Override
+    Set<Pair> generics(ClassOrInterface classOrInterface) {
-    public Set<Pair> generics(ClassOrInterface classOrInterface) {
         if (computedGenericsOfClasses.containsKey(classOrInterface))
             return computedGenericsOfClasses.get(classOrInterface);
 
@@ -974,13 +988,7 @@ public abstract class GenerateGenerics implements IGenerics {
         } while (foundInfima);
     }
 
-    @Override
+    RefTypeOrTPHOrWildcardOrGeneric getType(RefTypeOrTPHOrWildcardOrGeneric type) {
-    public TypePlaceholder getEqualType(TypePlaceholder tph) {
-        return this.equality.getOrDefault(tph, tph);
-    }
-
-    @Override
-    public RefTypeOrTPHOrWildcardOrGeneric getType(RefTypeOrTPHOrWildcardOrGeneric type) {
         if (type instanceof TypePlaceholder tph) {
             if (equality.containsKey(tph)) {
                 return getType(equality.get(tph));
@@ -990,8 +998,7 @@ public abstract class GenerateGenerics implements IGenerics {
         return type;
     }
 
-    @Override
+    TargetType getTargetType(RefTypeOrTPHOrWildcardOrGeneric in) {
-    public TargetType getTargetType(RefTypeOrTPHOrWildcardOrGeneric in) {
         if (in instanceof TypePlaceholder tph) {
             if (equality.containsKey(tph)) {
                 return getTargetType(equality.get(tph));

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

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

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

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

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

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

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

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

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

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

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

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

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> implements Comparable<Constraint<A>> {
+public class Constraint<A> extends HashSet<A> {
 	private static final long serialVersionUID = 1L;
 	private Boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
 	private Boolean isImplemented = false;
@@ -74,8 +74,4 @@ public class Constraint<A> extends HashSet<A> implements Comparable<Constraint<A
 		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> implements Comparable<ResultPair<A,B>> {
+public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric,B extends RefTypeOrTPHOrWildcardOrGeneric> {
     private final A left;
     private final B right;
 
@@ -59,13 +59,4 @@ public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric, B ex
 		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,8 +1,6 @@
 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;
@@ -14,7 +12,7 @@ import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
 @SuppressWarnings("rawtypes")
-public class ResultSet implements Comparable<ResultSet>{
+public class ResultSet {
 
     public final Set<ResultPair> results;
     public Set<ResultPair<TypePlaceholder, TypePlaceholder>> genIns;
@@ -25,10 +23,6 @@ public class ResultSet implements Comparable<ResultSet>{
         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);
     }
@@ -69,21 +63,6 @@ public class ResultSet implements Comparable<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,7 +1,6 @@
 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;
@@ -10,18 +9,15 @@ 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 {
@@ -91,25 +87,12 @@ 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

@@ -73,7 +73,7 @@ public class TYPEStmt implements StatementVisitor {
 
     @Override
     public void visit(LambdaExpression lambdaExpression) {
-        TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken(), -1, false);
+        TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken());
         List<RefTypeOrTPHOrWildcardOrGeneric> lambdaParams = lambdaExpression.params.getFormalparalist().stream().map((formalParameter -> formalParameter.getType())).collect(Collectors.toList());
         lambdaParams.add(tphRetType);
         // lambdaParams.add(0,tphRetType);
@@ -635,7 +635,6 @@ 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 {

src/test/java/AllgemeinTest.java

@@ -1,6 +1,6 @@
 
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
 import static targetast.TestCodegen.generateClassFiles;
 
 import java.io.File;
@@ -9,12 +9,13 @@ import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.Arrays;
 
-import org.junit.jupiter.api.BeforeAll;
+import org.junit.BeforeClass;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
 
 import com.google.common.collect.Lists;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.environment.ByteArrayClassLoader;
 
 public class AllgemeinTest {
 

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.jupiter.api.Test;
+import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
 
 public class GenericsParserTest {
 

src/test/java/TestPackages.java

@@ -1,6 +1,6 @@
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import org.junit.jupiter.api.Disabled;
+import org.junit.Ignore;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
 
 import java.io.File;
 import java.util.List;
@@ -24,7 +24,7 @@ public class TestPackages {
     }
 
     @Test
-    @Disabled("This doesn't work")
+    @Ignore("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.jupiter.api.Test;
+import org.junit.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.jupiter.api.Test;
+import org.junit.Test;
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
@@ -12,8 +12,7 @@ import java.lang.reflect.TypeVariable;
 import java.util.Arrays;
 import java.util.HashMap;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.Assert.*;
-
 
 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.jupiter.api.Test;
+import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.Collection;

src/test/java/languageServerInterfaceTest/LangaugeServerInterfaceTest.java

@@ -0,0 +1,51 @@
+package languageServerInterfaceTest;
+
+import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import org.junit.Ignore;
+import org.junit.Test;
+import de.dhbwstuttgart.languageServerInterface.LanguageServerInterface;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class LangaugeServerInterfaceTest {
+    @Test
+    @Ignore
+    public void consoleInterfaceTest() throws IOException, ClassNotFoundException, URISyntaxException {
+
+
+        LanguageServerInterface languageServerInterface = new LanguageServerInterface();
+        var resp = languageServerInterface.getResultSetAndAbstractSyntax("/home/ruben/code/JavaCompilerCore/src/test/java/languageServerInterfaceTest/test.jav");
+
+        System.out.println("\n-----------------------------------------\n");
+        System.out.println(ASTPrinter.print(resp.getAst()));
+        System.out.println("\n-----------------------------------------\n");
+
+        LanguageServerInterface languageServerInterface2 = new LanguageServerInterface();
+        var ast = languageServerInterface2.getAst("/home/ruben/code/JavaCompilerCore/src/test/java/languageServerInterfaceTest/test.jav", "N");
+
+        System.out.println("\n-----------------------------------------\n");
+        System.out.println(ASTPrinter.print(ast));
+        System.out.println("\n-----------------------------------------\n");
+        System.out.println("");
+    }
+
+    @Test
+    @Ignore
+    public void testBytecodeGen() throws IOException, ClassNotFoundException, URISyntaxException {
+
+        //TODO: Ordner und Datei löschen wenn sie bereits existieren
+        LanguageServerInterface languageServerInterface = new LanguageServerInterface();
+        languageServerInterface.generateBytecode(new URI("c%3A/Users/ruben/Neuer%20Ordner%20%282%29/LSP-Vortrag/images/"));
+    }
+}

src/test/java/languageServerInterfaceTest/test.jav

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

src/test/java/syntaxtreegenerator/TestComplete.java

@@ -1,5 +1,9 @@
 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;
@@ -8,23 +12,21 @@ import java.io.ObjectOutputStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 
-import org.junit.jupiter.api.BeforeAll;
+import org.junit.BeforeClass;
-import org.junit.jupiter.api.Test;
+import org.junit.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<>();
 
-    @BeforeAll
+    @BeforeClass
     public static void setUp() {
         final String testFileDirectory = "resources/bytecode/javFiles/";
         final String expectedASTDirectory = "resources/syntaxtreegenerator/";
@@ -351,7 +353,7 @@ public class TestComplete {
             assertEquals("Comparing expected and resulting AST for mathStrucInteger.jav", expectedAST, resultingAST);
         } catch (Exception exc) {
             exc.printStackTrace();
-            assertInstanceOf(NotImplementedException.class, exc);
+            assertTrue("An error occured while generating the AST for mathStrucInteger.jav", exc instanceof NotImplementedException);
         }
     }
 

src/test/java/syntaxtreegenerator/TestNewFeatures.java

@@ -1,15 +1,15 @@
 package syntaxtreegenerator;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.Assert.assertEquals;
-import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.Assert.fail;
 
 import java.io.File;
 import java.io.FileFilter;
 import java.io.FileInputStream;
 import java.util.HashMap;
 
-import org.junit.jupiter.api.BeforeAll;
+import org.junit.BeforeClass;
-import org.junit.jupiter.api.Test;
+import org.junit.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<>();
 
-    @BeforeAll
+    @BeforeClass
     public static void setUp() {
         final String testFileDirectory = "resources/syntaxtreegenerator/javFiles/";
         final String expectedASTDirectory = "resources/syntaxtreegenerator/";

src/test/java/targetast/ASTToTypedTargetAST.java

@@ -2,6 +2,7 @@ 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.*;
@@ -9,13 +10,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.jupiter.api.Disabled;
+import org.junit.Ignore;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
 
 import java.nio.file.Path;
 import java.util.*;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
 
 public class ASTToTypedTargetAST {
 
@@ -23,7 +24,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), TestCodegen.createClassLoader()).convert(emptyClass);
+        TargetStructure emptyTargetClass = new ASTToTargetAST(List.of(emptyResultSet)).convert(emptyClass);
         assert emptyTargetClass.getName().equals("EmptyClass");
         assert emptyTargetClass.methods().size() == 0;
         assert emptyTargetClass.fields().size() == 0;
@@ -31,14 +32,13 @@ 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, classLoader);
+        var converter = new ASTToTargetAST(compiler, resultSet);
         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,54 +54,46 @@ 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, classLoader);
+        var converter = new ASTToTargetAST(compiler, resultSet);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var tphAndGenerics = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
+        var tphAndGenerics = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
     }
 
     @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, classLoader);
+        var converter = new ASTToTargetAST(compiler, resultSet);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var cycle = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
+        var cycle = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
     }
 
     @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, classLoader);
+        var converter = new ASTToTargetAST(compiler, resultSet);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var infimum = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
+        var infimum = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
     }
 
     @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, classLoader);
+        var converter = new ASTToTargetAST(compiler, resultSet);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), TestCodegen.createClassLoader());
+        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
         var m = generics.getDeclaredMethod("m", Vector.class);
         var mReturnType = m.getGenericReturnType();
         assertEquals(mReturnType, m.getParameters()[0].getParameterizedType());
@@ -111,15 +103,13 @@ 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, classLoader);
+        var converter = new ASTToTargetAST(compiler, resultSet);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
+        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
         var B = generics.getTypeParameters()[0];
         var mt1 = generics.getDeclaredMethod("mt1", Object.class);
         var constructor = generics.getDeclaredConstructor(Object.class);
@@ -131,15 +121,13 @@ 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, classLoader);
+        var converter = new ASTToTargetAST(compiler, resultSet);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics2 = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
+        var generics2 = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
         assertEquals(generics2.getTypeParameters()[0].getBounds()[0], String.class);
         var m = generics2.getDeclaredMethod("m1", Object.class);
         assertEquals(m.getTypeParameters()[0].getBounds()[0], Integer.class);
@@ -147,30 +135,26 @@ public class ASTToTypedTargetAST {
     }
 
     @Test
-    @Disabled("Not implemented")
+    @Ignore("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, classLoader);
+        var converter = new ASTToTargetAST(compiler, resultSet);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics3 = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
+        var generics3 = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
     }
 
     @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, classLoader);
+        var converter = new ASTToTargetAST(compiler, resultSet);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics4 = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
+        var generics4 = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
 
         // var instance = generics4.getDeclaredConstructor().newInstance();
         // var method = generics4.getDeclaredMethod("m2", Object.class);

src/test/java/targetast/GreaterEqualTest.java

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

src/test/java/targetast/GreaterThanTest.java

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

src/test/java/targetast/InheritTest.java

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

src/test/java/targetast/InheritTest2.java

@@ -1,22 +1,23 @@
 package targetast;
 
-import org.junit.jupiter.api.BeforeAll;
+import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.jupiter.api.Disabled;
+import org.junit.BeforeClass;
-import org.junit.jupiter.api.Test;
+import org.junit.Ignore;
+import org.junit.Test;
 
 import java.lang.reflect.Method;
 import java.util.Vector;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.Assert.assertEquals;
 
-@Disabled("FIXME")
+@Ignore("FIXME")
 public class InheritTest2 {
     private static Class<?> classToTest, classToTestAA, classToTestBB, classToTestCC, classToTestDD;
     private static Object instanceOfClass, instanceOfClassAA, instanceOfClassBB, instanceOfClassCC, instanceOfClassDD;
 
-    @BeforeAll
+    @BeforeClass
     public static void setUpBeforeClass() throws Exception {
-        var classLoader = TestCodegen.createClassLoader();
+        var classLoader = new ByteArrayClassLoader();
         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,20 +1,21 @@
 package targetast;
 
-import org.junit.jupiter.api.BeforeAll;
+import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.jupiter.api.Test;
+import org.junit.BeforeClass;
+import org.junit.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.Assert.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.Assert.assertTrue;
 
 public class LessEqualTest {
     static Class<?> classToTest;
     static Object instance;
 
-    @BeforeAll
+    @BeforeClass
     public static void beforeClass() throws Exception {
-        var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "LessEqual.jav");
+        var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "LessEqual.jav");
         classToTest = classFiles.get("LessEqual");
         instance = classToTest.getDeclaredConstructor().newInstance();
     }

src/test/java/targetast/LessThanTest.java

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

src/test/java/targetast/OLTest.java

@@ -1,12 +1,12 @@
 package targetast;
 
-import org.junit.jupiter.api.BeforeAll;
+import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.jupiter.api.Test;
+import org.junit.BeforeClass;
+import org.junit.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.Assert.assertEquals;
-
 
 public class OLTest {
 	private static Class<?> classToTest;
@@ -14,9 +14,9 @@ public class OLTest {
 	private static Object instanceOfClass;
 	private static Object instanceOfClass1;
 	
-	@BeforeAll
+	@BeforeClass
 	public static void setUpBeforeClass() throws Exception {
-		var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "OL.jav");
+		var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "OL.jav");
 		classToTest = classFiles.get("OL");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 		classToTest1 = classFiles.get("OLMain");

src/test/java/targetast/PostIncTest.java

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

src/test/java/targetast/PreIncTest.java

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

src/test/java/targetast/PutTest.java

@@ -1,21 +1,22 @@
 package targetast;
 
-import org.junit.jupiter.api.BeforeAll;
+import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.jupiter.api.Test;
+import org.junit.BeforeClass;
+import org.junit.Test;
 
 import java.lang.reflect.Method;
 import java.util.Stack;
 import java.util.Vector;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.Assert.assertEquals;
 
 public class PutTest {
 	private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	
-	@BeforeAll
+	@BeforeClass
 	public static void setUpBeforeClass() throws Exception {
-		var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "Put.jav");
+		var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "Put.jav");
 		classToTest = classFiles.get("Put");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}

src/test/java/targetast/TestCodegen.java

@@ -2,7 +2,7 @@ package targetast;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.bytecode.Codegen;
-import de.dhbwstuttgart.environment.DirectoryClassLoader;
+import de.dhbwstuttgart.environment.ByteArrayClassLoader;
 import de.dhbwstuttgart.environment.IByteArrayClassLoader;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.target.generate.ASTToTargetAST;
@@ -14,10 +14,10 @@ import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.TargetFunNType;
 import de.dhbwstuttgart.target.tree.type.TargetRefType;
 import de.dhbwstuttgart.target.tree.type.TargetType;
-import org.junit.jupiter.api.Disabled;
+import org.junit.Ignore;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
 
 import org.objectweb.asm.Opcodes;
 
@@ -37,10 +37,6 @@ public class TestCodegen {
         Files.write(outputPath.resolve(name + ".class"), code);
     }
 
-    public static IByteArrayClassLoader createClassLoader() {
-        return new DirectoryClassLoader(List.of(outputPath.toFile()), ClassLoader.getSystemClassLoader());
-    }
-
     public static Path path = Path.of(System.getProperty("user.dir"), "resources/bytecode/javFiles/");
 
     public static Map<String, ? extends Class<?>> generateClassFiles(IByteArrayClassLoader classLoader, String... files) throws IOException, ClassNotFoundException {
@@ -123,7 +119,7 @@ public class TestCodegen {
     public void testEmptyClass() throws Exception {
         var clazz = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("Empty"));
         clazz.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "main", List.of(), null, new TargetBlock(List.of()));
-        generateClass(clazz, createClassLoader()).getDeclaredMethod("main").invoke(null);
+        generateClass(clazz, new ByteArrayClassLoader()).getDeclaredMethod("main").invoke(null);
     }
 
     @Test
@@ -136,7 +132,7 @@ public class TestCodegen {
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "mul", List.of(new MethodParameter(TargetType.Integer, "a"), new MethodParameter(TargetType.Integer, "b")), TargetType.Integer, new TargetBlock(List.of(new TargetReturn(new TargetBinaryOp.Mul(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "a"), new TargetLocalVar(TargetType.Integer, "b"))))));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "rem", List.of(new MethodParameter(TargetType.Integer, "a"), new MethodParameter(TargetType.Integer, "b")), TargetType.Integer, new TargetBlock(List.of(new TargetReturn(new TargetBinaryOp.Rem(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "a"), new TargetLocalVar(TargetType.Integer, "b"))))));
 
-        var clazz = generateClass(targetClass, createClassLoader());
+        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
         assertEquals(clazz.getDeclaredMethod("add", Integer.class, Integer.class).invoke(null, 10, 10), 20);
         assertEquals(clazz.getDeclaredMethod("sub", Integer.class, Integer.class).invoke(null, 20, 10), 10);
         assertEquals(clazz.getDeclaredMethod("div", Integer.class, Integer.class).invoke(null, 20, 10), 2);
@@ -152,7 +148,7 @@ public class TestCodegen {
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "neg", List.of(new MethodParameter(TargetType.Integer, "a")), TargetType.Integer, new TargetBlock(List.of(new TargetReturn(new TargetUnaryOp.Negate(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "a"))))));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "add", List.of(new MethodParameter(TargetType.Integer, "a")), TargetType.Integer, new TargetBlock(List.of(new TargetReturn(new TargetUnaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "a"))))));
 
-        var clazz = generateClass(targetClass, createClassLoader());
+        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
         assertEquals(clazz.getDeclaredMethod("not", Integer.class).invoke(null, 10), -11);
         assertEquals(clazz.getDeclaredMethod("neg", Integer.class).invoke(null, 10), -10);
         assertEquals(clazz.getDeclaredMethod("add", Integer.class).invoke(null, 10), 10);
@@ -166,7 +162,7 @@ public class TestCodegen {
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "and", List.of(new MethodParameter(TargetType.Boolean, "a"), new MethodParameter(TargetType.Boolean, "b")), TargetType.Boolean, new TargetBlock(List.of(new TargetReturn(new TargetBinaryOp.And(TargetType.Boolean, new TargetLocalVar(TargetType.Boolean, "a"), new TargetLocalVar(TargetType.Boolean, "b"))))));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "or", List.of(new MethodParameter(TargetType.Boolean, "a"), new MethodParameter(TargetType.Boolean, "b")), TargetType.Boolean, new TargetBlock(List.of(new TargetReturn(new TargetBinaryOp.Or(TargetType.Boolean, new TargetLocalVar(TargetType.Boolean, "a"), new TargetLocalVar(TargetType.Boolean, "b"))))));
 
-        var clazz = generateClass(targetClass, createClassLoader());
+        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
         var and = clazz.getDeclaredMethod("and", Boolean.class, Boolean.class);
         var or = clazz.getDeclaredMethod("or", Boolean.class, Boolean.class);
         assertEquals(and.invoke(null, true, false), false);
@@ -180,7 +176,7 @@ public class TestCodegen {
     public void testArithmeticConvert() throws Exception {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("ArithmeticConvert"));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "add", List.of(), TargetType.Long, new TargetBlock(List.of(new TargetReturn(new TargetBinaryOp.Add(TargetType.Long, new TargetLiteral.CharLiteral((char) 10), new TargetLiteral.LongLiteral((long) 20))))));
-        var clazz = generateClass(targetClass, createClassLoader());
+        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
         assertEquals(clazz.getDeclaredMethod("add").invoke(null), (long) 30);
     }
 
@@ -189,7 +185,7 @@ public class TestCodegen {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("HelloWorld"));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "helloWorld", List.of(), null, new TargetBlock(List.of(new TargetMethodCall(null, new TargetFieldVar(new TargetRefType("java.io.PrintStream"), new TargetRefType("java.lang.System"), true, new TargetClassName(new TargetRefType("java.lang.System")), "out"), List.of(new TargetLiteral.StringLiteral("Hello World!")), new TargetRefType("java.io.PrintStream"), "println", false, false, false))));
 
-        var clazz = generateClass(targetClass, createClassLoader());
+        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
         clazz.getDeclaredMethod("helloWorld").invoke(null);
     }
 
@@ -197,7 +193,7 @@ public class TestCodegen {
     public void testIfStatement() throws Exception {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("IfStmt"));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "ifStmt", List.of(new MethodParameter(TargetType.Integer, "val")), TargetType.Integer, new TargetBlock(List.of(new TargetIf(new TargetBinaryOp.Equal(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "val"), new TargetLiteral.IntLiteral(10)), new TargetReturn(new TargetLiteral.IntLiteral(1)), new TargetIf(new TargetBinaryOp.Less(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "val"), new TargetLiteral.IntLiteral(5)), new TargetReturn(new TargetLiteral.IntLiteral(2)), new TargetReturn(new TargetLiteral.IntLiteral(3)))))));
-        var clazz = generateClass(targetClass, createClassLoader());
+        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
         var ifStmt = clazz.getDeclaredMethod("ifStmt", Integer.class);
         assertEquals(ifStmt.invoke(null, 10), 1);
         assertEquals(ifStmt.invoke(null, 3), 2);
@@ -208,7 +204,7 @@ public class TestCodegen {
     public void testFor() throws Exception {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("For"));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "forLoop", List.of(), TargetType.Integer, new TargetBlock(List.of(new TargetVarDecl(TargetType.Integer, "sum", new TargetLiteral.IntLiteral(0)), new TargetFor(List.of(new TargetVarDecl(TargetType.Integer, "i", new TargetLiteral.IntLiteral(0))), new TargetBinaryOp.Less(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(10)), List.of(new TargetAssign(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetBinaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(1)))), new TargetBlock(List.of(new TargetAssign(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "sum"), new TargetBinaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "sum"), new TargetLocalVar(TargetType.Integer, "i")))))), new TargetReturn(new TargetLocalVar(TargetType.Integer, "sum")))));
-        var clazz = generateClass(targetClass, createClassLoader());
+        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
         assertEquals(clazz.getDeclaredMethod("forLoop").invoke(null), 45);
     }
 
@@ -216,7 +212,7 @@ public class TestCodegen {
     public void testWhile() throws Exception {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("While"));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "whileLoop", List.of(), TargetType.Integer, new TargetBlock(List.of(new TargetVarDecl(TargetType.Integer, "i", new TargetLiteral.IntLiteral(0)), new TargetWhile(new TargetBinaryOp.Less(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(10)), new TargetBlock(List.of(new TargetAssign(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetBinaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(1)))))), new TargetReturn(new TargetLocalVar(TargetType.Integer, "i")))));
-        var clazz = generateClass(targetClass, createClassLoader());
+        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
         assertEquals(clazz.getDeclaredMethod("whileLoop").invoke(null), 10);
     }
 
@@ -239,7 +235,7 @@ public class TestCodegen {
                 new TargetReturn(new TargetLocalVar(TargetType.Integer, "res"))
         )));
 
-        var clazz = generateClass(targetClass, createClassLoader());
+        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
         var m = clazz.getDeclaredMethod("switchClassic", Integer.class);
         assertEquals(m.invoke(null, 10), 0);
         assertEquals(m.invoke(null, 15), 1);
@@ -268,7 +264,7 @@ public class TestCodegen {
                         List.of(new TargetLiteral.IntLiteral(2))
                 ), true), TargetType.Integer)
                 ))));
-        var clazz = generateClass(targetClass, createClassLoader());
+        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
         var m = clazz.getDeclaredMethod("switchType", Object.class);
         assertEquals(m.invoke(null, "String"), 0);
         assertEquals(m.invoke(null,  10), 1);
@@ -277,9 +273,9 @@ public class TestCodegen {
     }
 
     @Test
-    @Disabled("The lambda class is not generated because we don't call ASTToTargetAST")
+    @Ignore("The lambda class is not generated because we don't call ASTToTargetAST")
     public void testLambda() throws Exception {
-        var classLoader = createClassLoader();
+        var classLoader = new ByteArrayClassLoader();
         // var fun = classLoader.loadClass(Path.of(System.getProperty("user.dir"), "src/test/java/targetast/Fun1$$.class"));
         var interfaceType = TargetFunNType.fromParams(List.of(TargetType.Integer), 1);
 

src/test/java/targetast/TestGenerics.java

@@ -12,9 +12,9 @@ import de.dhbwstuttgart.target.generate.Bound;
 import static de.dhbwstuttgart.target.generate.Bound.*;
 import de.dhbwstuttgart.target.generate.BoundsList;
 import de.dhbwstuttgart.target.generate.GenericsResult;
-import org.junit.jupiter.api.Disabled;
+import org.junit.Ignore;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
 
 import java.io.File;
 import java.io.IOException;
@@ -22,7 +22,7 @@ import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
 
-@Disabled("TODO: Rewrite with the new algorithm")
+@Ignore("TODO: Rewrite with the new algorithm")
 public class TestGenerics {
     private static final String rootDirectory = System.getProperty("user.dir") + "/resources/insertGenerics/javFiles/";
     private static final String bytecodeDirectory = System.getProperty("user.dir") + "targetTest";
@@ -65,7 +65,7 @@ public class TestGenerics {
         var b = result.findField("b");
 
         var generics = result.genericsResults.get(0);
-        assertEquals(1, generics.get(result.clazz, anyMethod).size());
+        assertEquals(1, generics.get(anyMethod).size());
         assertEquals(2, generics.get(result.clazz).size());
 
         var ECK1 = generics.getBounds(otherMethod.getParameterList().getParameterAt(0).getType(), result.clazz, anyMethod);
@@ -86,7 +86,7 @@ public class TestGenerics {
 
         var generics = result.genericsResults.get(0);
         assertEquals(1, generics.get(result.clazz).size());
-        assertEquals(0, generics.get(result.clazz, fReturn).size());
+        assertEquals(0, generics.get(fReturn).size());
 
         var N = generics.getBounds(fReturn.getReturnType(), result.clazz);
         var NChain = new BoundsList(onClass(OBJECT));
@@ -101,8 +101,8 @@ public class TestGenerics {
 
         var generics = result.genericsResults.get(0);
         assertEquals(0, generics.get(result.clazz).size());
-        assertEquals(3, generics.get(result.clazz, m).size());
+        assertEquals(3, generics.get(m).size());
-        assertEquals(3, generics.get(result.clazz, main).size());
+        assertEquals(3, generics.get(main).size());
 
         {
             var AJ = generics.getBounds(m.getParameterList().getParameterAt(0).getType(), result.clazz, m);
@@ -143,9 +143,9 @@ public class TestGenerics {
 
         var generics = result.genericsResults.get(0);
         assertEquals(1, generics.get(result.clazz).size());
-        assertEquals(2, generics.get(result.clazz, id).size());
+        assertEquals(2, generics.get(id).size());
-        assertEquals(1, generics.get(result.clazz, setA).size());
+        assertEquals(1, generics.get(setA).size());
-        assertEquals(2, generics.get(result.clazz, m).size());
+        assertEquals(2, generics.get(m).size());
 
         var R = generics.getBounds(a.getType(), result.clazz);
         var RChain =  new BoundsList(onClass(OBJECT));
@@ -183,9 +183,9 @@ public class TestGenerics {
 
         var generics = result.genericsResults.get(0);
         assertEquals(1, generics.get(result.clazz).size());
-        assertEquals(2, generics.get(result.clazz, id).size());
+        assertEquals(2, generics.get(id).size());
-        assertEquals(2, generics.get(result.clazz, m).size());
+        assertEquals(2, generics.get(m).size());
-        assertEquals(3, generics.get(result.clazz, main).size());
+        assertEquals(3, generics.get(main).size());
 
         var N = generics.getBounds(a.getType(), result.clazz);
         assertEquals(N, new BoundsList(onClass(OBJECT)));
@@ -215,7 +215,7 @@ public class TestGenerics {
         var anyMethod = result.findMethod("anyMethod");
 
         var generics = result.genericsResults.get(0);
-        assertEquals(1, generics.get(result.clazz, anyMethod).size());
+        assertEquals(1, generics.get(anyMethod).size());
 
         var M = generics.getBounds(anyMethod.getReturnType(), result.clazz, anyMethod);
         assertEquals(M, new BoundsList(onMethod(OBJECT)));

src/test/java/targetast/TphTest.java

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

src/test/java/targetast/WhileTest.java

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

src/test/java/typeinference/JavaTXCompilerTest.java

@@ -8,8 +8,8 @@ import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
-import org.junit.jupiter.api.Test;
+import org.junit.Ignore;
-import org.junit.jupiter.api.Disabled;
+import org.junit.Test;
 
 import java.io.File;
 import java.io.IOException;
@@ -22,7 +22,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-@Disabled("To be renewed")
+@Ignore("To be renewed")
 public class JavaTXCompilerTest {
 
     public static final String rootDirectory = System.getProperty("user.dir") + "/src/test/resources/javFiles/";