feat: fix merge problems, update type inference to work with updated environment

chore: optimize imports

feat: implement parameters for client-server separation

feat: add web sockets and packet communication

feat: add web sockets and packet communication

feat: Implement client to server data serialization

chore: adding comments, optimizing imports, formatting some code

feat: added some missing properties to packets

feat: make server configurable via arguments, cleanup some code

.gitea/workflows/build_and_test.yml

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

Makefile

@@ -0,0 +1,3 @@
+NoOptParallel:
+	mvn -DskipTests package
+	cp target/JavaTXcompiler-0.1-jar-with-dependencies.jar target/JavaTXcompiler-0.1-jar-with-dependencies_NoOptParallel.jar

pom.xml

@@ -44,6 +44,23 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<artifactId>asm</artifactId>
 			<version>9.5</version>
 		</dependency>
+
+		<dependency>
+			<groupId>org.java-websocket</groupId>
+			<artifactId>Java-WebSocket</artifactId>
+			<version>1.5.2</version>
+		</dependency>
+		<dependency>
+			<groupId>org.slf4j</groupId>
+			<artifactId>slf4j-simple</artifactId>
+			<version>1.7.25</version>
+		</dependency>
+		<dependency>
+			<groupId>com.fasterxml.jackson.core</groupId>
+			<artifactId>jackson-databind</artifactId>
+			<version>2.17.2</version>
+		</dependency>
+
 	</dependencies>
 
 	<build>

resources/bytecode/javFiles/Scalar.jav

@@ -1,4 +1,4 @@
-import java.util.Vector;
+//import java.util.Vector;
 import java.lang.Integer;
 import java.lang.Float;
 //import java.lang.Byte;
@@ -20,7 +20,6 @@ public class Scalar extends Vector<Integer> {
         var i = 0;
         while(i < size()) {
             ret = ret + this.elementAt(i) * v.elementAt(i);
-	    i = i+1;
          }
         return ret;
     }

server-tests/.gitignore

@@ -0,0 +1,2 @@
+out
+outputs

server-tests/Lambda.jav

@@ -0,0 +1,13 @@
+
+class Apply { }
+
+public class Lambda {
+
+  m () {
+   var lam1 = (x) -> {
+        return x;
+   };
+   return lam1.apply(new Apply());
+  }
+}
+

server-tests/Matrix.jav

@@ -0,0 +1,28 @@
+import java.util.Vector;
+import java.lang.Integer;
+
+class Matrix extends Vector<Vector<Integer>> {
+	Integer mul1(Integer x, Integer y) { return x;}
+	Integer add1(Integer x, Integer y) { return x;}
+    mul(m) {
+        var ret = new Matrix();
+        var i = 0;
+        while(i < size()) {
+            var v1 = this.elementAt(i);
+            var v2 = new Vector<Integer>();
+            var j = 0;
+            while(j < v1.size()) {
+                var erg = 0;
+                var k = 0;
+                while(k < v1.size()) {
+                  erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
+                  //erg = add1(erg, mul1(v1.elementAt(k),
+                  //           m.elementAt(k).elementAt(j)));
+                    k++; }
+                v2.addElement(new Integer(erg));
+                j++; }
+            ret.addElement(v2);
+            i++; }
+        return ret;
+    }
+}

server-tests/SomeList.jav

@@ -0,0 +1,25 @@
+import java.util.Vector;
+import java.lang.Integer;
+
+class SomeEvenMoreAbstractList<A, B> extends Vector<A> {
+}
+
+class SomeAbstractList<A, B> extends SomeEvenMoreAbstractList<A, B> {
+}
+
+class SomeList extends SomeAbstractList<Integer, Integer> {
+
+    mul(otherList) {
+        var result = new SomeList();
+
+        var i = 0;
+        while (i < 4) {
+            i++;
+            var a = this.elementAt(i);
+            var b = otherList.elementAt(i);
+            result.addElement(a * b);
+        }
+
+        return result;
+    }
+}

server-tests/_runClient.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+# build the compiler if -c is set
+if [[ "${@,,}" == *"-c"* ]]; then
+  (cd .. && make || exit)
+fi
+
+# a very small and short running example
+# JAV_FILE="Lambda.jav"
+
+# a medium and average running example
+JAV_FILE="SomeList.jav"
+
+# a very large and long running example
+# JAV_FILE="Matrix.jav"
+
+
+# remove old generated files and run the compiler
+rm -rf ./out/client
+mkdir -p ./out/client \
+  && java -jar ../target/JavaTXcompiler-0.1-jar-with-dependencies.jar -d ./out/client $JAV_FILE

server-tests/_runServer.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+# build the compiler if -c is set
+if [[ "${@,,}" == *"-c"* ]]; then
+  (cd .. && make || exit)
+fi
+
+# remove old generated files
+rm -rf ./out/server
+
+# run the server
+mkdir -p ./out/server && java -jar ../target/JavaTXcompiler-0.1-jar-with-dependencies.jar -d ./out/server -server 5000

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

@@ -14,9 +14,9 @@ import java.lang.invoke.*;
 import java.lang.reflect.Modifier;
 import java.util.*;
 
-import static org.objectweb.asm.Opcodes.*;
 import static de.dhbwstuttgart.target.tree.expression.TargetBinaryOp.*;
 import static de.dhbwstuttgart.target.tree.expression.TargetLiteral.*;
+import static org.objectweb.asm.Opcodes.*;
 
 public class Codegen {
     private final TargetStructure clazz;

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

@@ -5,41 +5,72 @@ import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.util.*;
-public class ConsoleInterface {
+import java.util.ArrayList;
-	private static final String directory = System.getProperty("user.dir");
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
 
-	public static void main(String[] args) throws IOException, ClassNotFoundException {
+public class ConsoleInterface {
-		List<File> input = new ArrayList<>();
+    private static final String directory = System.getProperty("user.dir");
-		List<File> classpath = new ArrayList<>();
+
+    public static void main(String[] args) throws IOException, ClassNotFoundException {
+        List<File> input = new ArrayList<>();
+        List<File> classpath = new ArrayList<>();
         String outputPath = null;
-		Iterator<String> it = Arrays.asList(args).iterator();
+        int runAsServerWithPort = -1;
-        if(args.length == 0){
+        String unificationServer = null;
+
+        Iterator<String> it = Arrays.asList(args).iterator();
+        if (args.length == 0) {
             System.out.println("No input files given. Get help with --help");
             System.exit(1);
-        }else if(args.length == 1 && args[0].equals("--help")){
+        } else if (args.length == 1 && args[0].equals("--help")) {
             System.out.println("Usage: javatx [OPTION]... [FILE]...\n" +
                     "\t-cp\tSet Classpath\n" +
-                    "\t-d\tSet destination directory");
+                    "\t-d\tSet destination directory\n" +
+                    "\t-s\tRun the compiler in server mode and listen for incoming requests on the given port\n" +
+                    "\t-us\tSet the address of a remote server for the unification process"
+            );
             System.exit(1);
         }
-		while(it.hasNext()){
+        while (it.hasNext()) {
             String arg = it.next();
-            if(arg.equals("-d")){
+            if (arg.equals("-d")) {
                 outputPath = it.next();
-            }else if(arg.startsWith("-d")) {
+            }
+            else if (arg.startsWith("-d")) {
                 outputPath = arg.substring(2);
-            }else if(arg.equals("-cp") || arg.equals("-classpath")){
+            }
+            else if (arg.equals("-cp") || arg.equals("-classpath")) {
                 String[] cps = it.next().split(":");
-                for(String cp : cps){
+                for (String cp : cps) {
                     classpath.add(new File(cp));
                 }
-            }else{
+            }
+            else if (arg.equals("-s") || arg.equals("-server")) {
+                if (unificationServer != null) {
+                    throw new IllegalArgumentException("Cannot run in server-Mode and use unification server at the same time");
+                }
+                runAsServerWithPort = Integer.parseInt(it.next());
+            }
+            else if (arg.equals("-us") || arg.equals("-unification-server")) {
+                if (runAsServerWithPort != -1) {
+                    throw new IllegalArgumentException("Cannot run in server-Mode and use unification server at the same time");
+                }
+                unificationServer = it.next();
+            } else {
                 input.add(new File(arg));
             }
         }
-		JavaTXCompiler compiler = new JavaTXCompiler(input, classpath, outputPath != null ? new File(outputPath) : null);
+
-		//compiler.typeInference();
+        if (runAsServerWithPort != -1) {
-		compiler.generateBytecode();
+            JavaTXServer server = new JavaTXServer(runAsServerWithPort);
+        }
+        else {
+            JavaTXCompiler compiler = new JavaTXCompiler(input, classpath, outputPath != null ? new File(outputPath) : null);
+            //compiler.typeInference();
+            compiler.generateBytecode();
+        }
 	}
 
 

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

@@ -12,6 +12,7 @@ import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.antlr.Java17Parser.SourceFileContext;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
+import de.dhbwstuttgart.server.SocketClient;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
@@ -30,24 +31,19 @@ import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
 import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.target.generate.ASTToTargetAST;
 import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.typeinference.TypeInference;
+import de.dhbwstuttgart.typeinference.TypeInferenceHelper;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
-import de.dhbwstuttgart.typeinference.unify.RuleSet;
+import de.dhbwstuttgart.typeinference.unify.*;
-import de.dhbwstuttgart.typeinference.unify.TypeUnify;
-import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
-import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
-import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
 
 import java.io.*;
 import java.lang.reflect.Modifier;
@@ -57,6 +53,7 @@ import java.util.Map.Entry;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import de.dhbwstuttgart.util.Logger;
 import org.apache.commons.io.output.NullOutputStream;
 
 public class JavaTXCompiler {
@@ -64,11 +61,12 @@ public class JavaTXCompiler {
 	// public static JavaTXCompiler INSTANCE;
 	final CompilationEnvironment environment;
 	Boolean resultmodel = true;
+    Optional<String> unificationServer = Optional.empty();
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
 
     Boolean log = false; //gibt an ob ein Log-File nach System.getProperty("user.dir")+""/logFiles/"" geschrieben werden soll?
-    public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
+	public UnifyTaskModelParallel usedTasks = new UnifyTaskModelParallel();
-    public final DirectoryClassLoader classLoader;
+	public final DirectoryClassLoader classLoader;
 
 	public final List<File> classPath;
 	private final File outputPath;
@@ -282,7 +280,7 @@ public class JavaTXCompiler {
 	 * x.getRhsType().accept(new distributeVariance(), a.getVariance());}); eq1 = new HashSet<>(eq); eq1.removeIf(x -> !(x.getRhsType() instanceof PlaceholderType && ((PlaceholderType)x.getRhsType()).equals(a))); eq1.stream().forEach(x -> { x.getLhsType().accept(new distributeVariance(), a.getVariance());}); phSetVariance = new ArrayList<>(phSet); phSetVariance.removeIf(x -> (x.getVariance() == 0 || usedTPH.contains(x))); } }
 	 */
 
-	public UnifyResultModel typeInferenceAsync(UnifyResultListener resultListener, Writer logFile) throws ClassNotFoundException, IOException {
+	public UnifyResultModelParallel typeInferenceAsync(UnifyResultListener resultListener, Writer logFile) throws ClassNotFoundException, IOException {
 		List<ClassOrInterface> allClasses = new ArrayList<>();// environment.getAllAvailableClasses();
 		// Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
 		for (Entry<File, SourceFile> source : this.sourceFiles.entrySet()) {
@@ -298,13 +296,17 @@ public class JavaTXCompiler {
 		}
 
 		Set<Set<UnifyPair>> results = new HashSet<>();
-		UnifyResultModel urm = null;
+		UnifyResultModelParallel urm = null;
 		// urm.addUnifyResultListener(resultListener);
 		try {
-			logFile = logFile == null ? new FileWriter(new File("log_" + sourceFiles.keySet().iterator().next().getName())) : logFile;
+			Logger logger = new Logger(true, "log_" + sourceFiles.keySet().iterator().next().getName());
-			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile, getClassLoader(), this);
+			if (logFile == null) {
+				logFile = logger.getLogFileWriter();
+			}
+
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logger, getClassLoader(), this);
 			System.out.println(finiteClosure);
-			urm = new UnifyResultModel(cons, finiteClosure);
+			urm = new UnifyResultModelParallel(cons, finiteClosure);
 			urm.addUnifyResultListener(resultListener);
 			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons);
 
@@ -350,6 +352,12 @@ public class JavaTXCompiler {
 	}
 
 	public List<ResultSet> typeInference(File file) throws ClassNotFoundException, IOException {
+
+		// START create logger
+		Logger logger = new Logger(log, "log_" + sourceFiles.keySet().iterator().next().getName());
+		// END create logger
+
+		// START gather classes and interfaces
 		var sf = sourceFiles.get(file);
 		Set<ClassOrInterface> allClasses = new HashSet<>();// environment.getAllAvailableClasses();
 		allClasses.addAll(getAvailableClasses(sf));
@@ -362,99 +370,51 @@ public class JavaTXCompiler {
 			if (allClasses.stream().noneMatch(old -> old.getClassName().equals(clazz.getClassName())))
 				allClasses.add(clazz);
 		}
+		logger.write(ASTTypePrinter.print(sf));
+		// END gather classes and interfaces
 
-		final ConstraintSet<Pair> cons = getConstraints(file);
+		// START create finite closure
-		Set<Set<UnifyPair>> results = new HashSet<>();
+		IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logger, classLoader, this);
-		try {
+		logger.write("FC:\\" + finiteClosure.toString() + "\n");
-			var logFolder = new File(System.getProperty("user.dir") + "/logFiles/");
+		// END create finite closure
-			if (log) logFolder.mkdirs();
-			Writer logFile = log ? new FileWriter(new File(logFolder, "log_" + sourceFiles.keySet().iterator().next().getName())) : new OutputStreamWriter(new NullOutputStream());
-			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logFile, classLoader, this);
-			System.out.println(finiteClosure);
-			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons);
-			System.out.println("xxx1");
-			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;
 
-			};
+		// START create unify constraints
+		ConstraintSet<Pair> cons = getConstraints(file);
+		ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons);
+		logger.write("Unify:" + unifyCons.toString());
+		unifyCons = unifyCons.map(TypeInferenceHelper::distributeInnerVars);
+		logger.write("\nUnify_distributeInnerVars: " + unifyCons.toString());
+		System.out.println("xxx1");
+		// END create unify constraints
 
-			logFile.write("Unify:" + unifyCons.toString());
+		// START unused variance calculation
-			System.out.println("Unify:" + unifyCons.toString());
+		Set<PlaceholderType> varianceTPHold;
-			unifyCons = unifyCons.map(distributeInnerVars);
+		Set<PlaceholderType> varianceTPH = varianceInheritanceConstraintSet(unifyCons);
-			logFile.write("\nUnify_distributeInnerVars: " + unifyCons.toString());
+		/*
-			TypeUnify unify = new TypeUnify();
+		 * PL 2018-11-07 wird in varianceInheritanceConstraintSet erledigt do { //PL 2018-11-05 Huellenbildung Variance auf alle TPHs der Terme auf der jeweiligen //anderen Seite übertragen varianceTPHold = new HashSet<>(varianceTPH); varianceTPH = varianceInheritanceConstraintSet(unifyCons); unifyCons.map( y -> { if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) { if (((PlaceholderType)y.getLhsType()).getVariance() != 0 &&
-			// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
+		 * ((PlaceholderType)y.getRhsType()).getVariance() == 0) { ((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType( )).getVariance()); } if (((PlaceholderType)y.getLhsType()).getVariance() == 0 && ((PlaceholderType)y.getRhsType()).getVariance() != 0) { ((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType( )).getVariance()); } } return y; } ); } while (!varianceTPHold.equals(varianceTPH));
-			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
+		 */
-			logFile.write(ASTTypePrinter.print(sf));
+		// END unused variance calculation
-			System.out.println(ASTTypePrinter.print(sf));
-			logFile.flush();
-			System.out.println("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
-			Set<PlaceholderType> varianceTPHold;
-			Set<PlaceholderType> varianceTPH = new HashSet<>();
-			varianceTPH = varianceInheritanceConstraintSet(unifyCons);
 
-			/*
+		TypeInference typeInference = new TypeInference(
-			 * PL 2018-11-07 wird in varianceInheritanceConstraintSet erledigt do { //PL 2018-11-05 Huellenbildung Variance auf alle TPHs der Terme auf der jeweiligen //anderen Seite übertragen varianceTPHold = new HashSet<>(varianceTPH); varianceTPH = varianceInheritanceConstraintSet(unifyCons); unifyCons.map( y -> { if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) { if (((PlaceholderType)y.getLhsType()).getVariance() != 0 &&
+			logger,
-			 * ((PlaceholderType)y.getRhsType()).getVariance() == 0) { ((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType( )).getVariance()); } if (((PlaceholderType)y.getLhsType()).getVariance() == 0 && ((PlaceholderType)y.getRhsType()).getVariance() != 0) { ((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType( )).getVariance()); } } return y; } ); } while (!varianceTPHold.equals(varianceTPH));
+			classLoader,
-			 */
+			usedTasks,
-
+			file,
-			// Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
+			cons,
-			// logFile, log);
+			allClasses,
-			// Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
+			finiteClosure,
-			List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints()// .stream().map(x -> {
+			unifyCons
-			/*
+		);
-			 * Set<Set<UnifyPair>> ret = new HashSet<>(); for (Constraint<UnifyPair> y : x) { ret.add(new HashSet<>(y)); } return ret; }).collect(Collectors.toCollection(ArrayList::new))
+		if (unificationServer.isPresent()) {
-			 */;
+			return typeInference.executeOnRemoteServer(unificationServer.get());
-			if (resultmodel) {
+		}
-				/* UnifyResultModel Anfang */
+		else if (resultmodel) {
-				UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
+			return typeInference.executeResultModel();
-				UnifyResultListenerImpl li = new UnifyResultListenerImpl();
+		}
-				urm.addUnifyResultListener(li);
+		else {
-				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm, usedTasks);
+			return typeInference.executeNoResultModel();
-				System.out.println("RESULT Final: " + li.getResults());
-				System.out.println("Constraints for Generated Generics: " + " ???");
-				logFile.write("RES_FINAL: " + li.getResults().toString() + "\n");
-				logFile.flush();
-				return li.getResults();
-			}
-			/* UnifyResultModel End */
-			else {
-				// Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(),
-				// oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons,
-				// finiteClosure));
-				Set<Set<UnifyPair>> result = unify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons, finiteClosure), usedTasks);
-				System.out.println("RESULT: " + result);
-				logFile.write("RES: " + result.toString() + "\n");
-				logFile.flush();
-				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));
-				System.out.println("RESULT Final: " + results);
-				System.out.println("Constraints for Generated Generics: " + " ???");
-				logFile.write("RES_FINAL: " + results.toString() + "\n");
-				logFile.flush();
-				logFile.write("PLACEHOLDERS: " + PlaceholderType.EXISTING_PLACEHOLDERS);
-				logFile.flush();
-			}
-		} catch (IOException e) {
-			System.err.println("kein LogFile");
 		}
-		return results.stream().map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons))))).collect(Collectors.toList());
 	}
 
 	/**

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

@@ -0,0 +1,15 @@
+package de.dhbwstuttgart.core;
+
+import de.dhbwstuttgart.server.SocketServer;
+
+public class JavaTXServer {
+
+  JavaTXServer(int port) {
+    try {
+      SocketServer socketServer = new SocketServer(port);
+      socketServer.start();
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+}

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

@@ -1,11 +1,5 @@
 package de.dhbwstuttgart.environment;
 
-import java.io.File;
-import java.io.IOException;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.*;
-
 import com.google.common.collect.Lists;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
@@ -18,6 +12,17 @@ import de.dhbwstuttgart.parser.antlr.Java17Parser.SourceFileContext;
 import de.dhbwstuttgart.parser.antlr.Java17Parser.SrcfileContext;
 import de.dhbwstuttgart.parser.scope.GatherNames;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
 
 /**
  * Stellt die Java-Environment dar und speichert alle Binarys, Librarys und Sourcefiles im zu kompilierenden Projekt Sie erstellt anhand dieser Informationen die JavaClassNameRegistry

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

@@ -11,10 +11,10 @@ import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
 
-import java.io.*;
+import java.io.File;
-import java.nio.charset.StandardCharsets;
+import java.io.FileInputStream;
-import java.util.ArrayList;
+import java.io.IOException;
-import java.util.List;
+import java.io.InputStream;
 
 public class JavaTXParser {
     public static Java17Parser.SourceFileContext parse(File source) throws IOException, java.lang.ClassNotFoundException {

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

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.statement.AssignLeftSide;
-import de.dhbwstuttgart.syntaxtree.statement.Expression;
 import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
 
 public class AssignToLocal extends AssignLeftSide {

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

@@ -12,13 +12,12 @@ import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.unify.model.*;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 import java.util.*;
 import java.util.stream.Collectors;
 
-import org.antlr.v4.runtime.Token;
-
 public class FCGenerator {
     /**
      * Baut die FiniteClosure aus availableClasses.

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

@@ -1,9 +1,7 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
-import de.dhbwstuttgart.syntaxtree.Constructor;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 
 import java.util.List;

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

@@ -14,12 +14,7 @@ import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;

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

@@ -2,7 +2,10 @@ package de.dhbwstuttgart.parser.scope;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  * Speichert die Klassen f<>r einen bestimmten Projektscope

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

@@ -0,0 +1,143 @@
+package de.dhbwstuttgart.server;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import de.dhbwstuttgart.server.packet.ErrorPacket;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.InvalidPacket;
+import de.dhbwstuttgart.server.packet.MessagePacket;
+import de.dhbwstuttgart.server.packet.PacketContainer;
+import de.dhbwstuttgart.server.packet.UnifyRequestPacket;
+import de.dhbwstuttgart.server.packet.UnifyResultPacket;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import java.net.URI;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.java_websocket.client.WebSocketClient;
+import org.java_websocket.enums.ReadyState;
+import org.java_websocket.handshake.ServerHandshake;
+
+
+/**
+ * The Client-side of the websocket
+ */
+public class SocketClient extends WebSocketClient {
+
+  // use a latch to wait until the connection is closed by the remote host
+  private final CountDownLatch closeLatch = new CountDownLatch(1);
+  // temporarily: The received unify result packet
+  private UnifyResultPacket unifyResultPacket = null;
+
+  public SocketClient(String url) {
+    super(URI.create(url));
+    // make sure, the url is in a valid format
+    final String regex = "^wss?://(\\w+(\\.\\w+)?)*:(\\d+)$";
+    final Matcher matcher = Pattern.compile(regex).matcher(url);
+    if (!matcher.find()) {
+      throw new RuntimeException("Provided string \"" + url + "\" is not a valid server URL! Use pattern ws(s?)://<host.name>:<port>");
+    }
+  }
+
+  public SocketClient(String host, int port, boolean secure) {
+    super(URI.create(String.format("%s://%s:%d/", secure ? "wss" : "ws", host, port)));
+  }
+
+  /**
+   * The main method for connecting, requesting and waiting for the server to unify.
+   * This is synchronized to prevent multiple webSockets connections at the moment, but it is not called from any
+   * thread except the main thread right now and is not necessary at all, probably. Maybe remove it later
+   */
+  synchronized public List<ResultSet> execute(
+    IFiniteClosure finiteClosure,
+    ConstraintSet<Pair> constraints,
+    ConstraintSet<UnifyPair> unifyConstraints
+  ) {
+    try {
+      // wait for the connection to be set up
+      this.connectBlocking();
+      // make sure the connection has been established successfully
+      if (this.getReadyState() != ReadyState.OPEN) {
+        throw new RuntimeException("WebSocket Client could not connect to remote host at " + this.uri);
+      }
+
+      // send the unify task request
+      UnifyRequestPacket packet = UnifyRequestPacket.create(finiteClosure, constraints, unifyConstraints);
+      String json = PacketContainer.serialize(packet);
+      this.send(json);
+
+      // block the thread, until the connection is closed by the remote host (usually after sending the results)
+      this.waitUntilClosed();
+      // wait for the connection to fully close
+      this.closeBlocking();
+    } catch (InterruptedException exception) {
+      System.err.println("Interrupted: " + exception);
+      this.notifyAll();
+      throw new RuntimeException("Remote unification failed: " + exception);
+    } catch (JsonProcessingException exception) {
+      System.err.println("JSON processing exception: " + exception);
+      this.notifyAll();
+      throw new RuntimeException("Remote unification failed: " + exception);
+    }
+
+    // detect error cases, in which no error was thrown, but also no result was sent back from the server
+    if (this.unifyResultPacket == null) {
+      throw new RuntimeException("Did not receive server response but closed connection already");
+    }
+
+    return unifyResultPacket.getResultSet();
+  }
+
+  /**
+   *  Specific client-side implementations to handle incomming packets
+   */
+  protected void handleReceivedPacket(IPacket packet) {
+    if (packet instanceof InvalidPacket) {
+      System.err.println("[socket] " + ((InvalidPacket) packet).error);
+    } else if (packet instanceof MessagePacket) {
+      System.out.println("[socket] " + ((MessagePacket) packet).message);
+    } else if (packet instanceof ErrorPacket) {
+      System.err.println("[socket] " + ((ErrorPacket) packet).error);
+    } else if (packet instanceof UnifyResultPacket) {
+      System.out.println("[socket] Received unify result");
+      unifyResultPacket = (UnifyResultPacket) packet;
+    }
+  }
+
+  @Override
+  public void onOpen(ServerHandshake handshakedata) {
+    System.out.println("Connected to server with status " + handshakedata.getHttpStatus());
+  }
+
+  @Override
+  public void onMessage(String message) {
+    // System.out.println("received: " + message);
+    IPacket packet = PacketContainer.deserialize(message);
+    this.handleReceivedPacket(packet);
+  }
+
+  @Override
+  public void onClose(int code, String reason, boolean remote) {
+    System.out.println(
+      "Disconnected from server " +
+        "with code " + code + " " +
+        (reason.isEmpty() ? "" : "and reason " + reason + " ") +
+        "(closed by remote: " + remote + ")"
+    );
+    this.closeLatch.countDown();
+  }
+
+  @Override
+  public void onError(Exception e) {
+    System.out.println("Error: " + e.getMessage());
+    e.printStackTrace();
+  }
+
+  public void waitUntilClosed() throws InterruptedException {
+    closeLatch.await();
+  }
+}

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

@@ -0,0 +1,17 @@
+package de.dhbwstuttgart.server;
+
+/**
+ * The data that is associated server-side with any connected client.
+ * This makes it possible to store information that can be mapped to any existing connection.
+ */
+public class SocketData {
+
+  public final String id;
+  // used for the timeout of 10 seconds, until an unused open connection is automatically closed
+  public boolean hasSentTask = false;
+
+  public SocketData(String id) {
+    this.id = id;
+  }
+
+}

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

@@ -0,0 +1,138 @@
+package de.dhbwstuttgart.server;
+
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.MessagePacket;
+import de.dhbwstuttgart.server.packet.PacketContainer;
+import de.dhbwstuttgart.server.packet.UnifyRequestPacket;
+import de.dhbwstuttgart.server.packet.UnifyResultPacket;
+import de.dhbwstuttgart.typeinference.TypeInference;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import java.net.InetSocketAddress;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import org.java_websocket.WebSocket;
+import org.java_websocket.handshake.ClientHandshake;
+import org.java_websocket.server.WebSocketServer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SocketServer extends WebSocketServer {
+
+  private static final Logger log = LoggerFactory.getLogger(SocketServer.class);
+
+  public SocketServer(int port) {
+    super(new InetSocketAddress(port));
+  }
+
+  @Override
+  public void onOpen(WebSocket webSocket, ClientHandshake clientHandshake) {
+    System.out.println("New connection: " + webSocket.getResourceDescriptor());
+    webSocket.setAttachment(new SocketData(UUID.randomUUID().toString()));
+
+    try {
+      sendMessage(webSocket, "Welcome to the server!");
+
+      // wait 10 seconds for the client to send a task and close the connection, if nothing has been received until then
+      ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
+      Runnable task = () -> {
+        if (webSocket.<SocketData>getAttachment().hasSentTask || !webSocket.isOpen()) {
+          return;
+        }
+        sendMessage(webSocket, "No task received after 10 seconds. Closing connection...");
+        webSocket.close();
+      };
+      executor.schedule(task, 10, TimeUnit.SECONDS);
+      executor.shutdown();
+
+      // and finally, when your program wants to exit
+    } catch (Exception e) {
+      log.error("e: ", e);
+      webSocket.close(1, e.getMessage());
+    }
+  }
+
+  @Override
+  public void onClose(WebSocket webSocket, int code, String reason, boolean remote) {
+    System.out.println("Connection closed: " + webSocket.getResourceDescriptor());
+    System.out.println(
+      "Disconnected client " + webSocket.getResourceDescriptor() + " " +
+        "with code " + code + " " +
+        (reason.isEmpty() ? "" : "and reason " + reason + " ") +
+        "(closed by client: " + remote + ")"
+    );
+
+  }
+
+  @Override
+  public void onMessage(WebSocket webSocket, String s) {
+    // System.out.println("Received: " + s.substring(0, 50));
+    IPacket reconstructedPacket = PacketContainer.deserialize(s);
+    this.onPacketReceived(webSocket, reconstructedPacket);
+  }
+
+  @Override
+  public void onError(WebSocket webSocket, Exception e) {
+    webSocket.close();
+  }
+
+  @Override
+  public void onStart() {
+    System.out.println("Websocket server started");
+  }
+
+  /**
+   * A shorthand method for sending informational messages to the client
+   */
+  public void sendMessage(WebSocket webSocket, String text) {
+    try {
+      MessagePacket message = new MessagePacket();
+      message.message = text;
+      webSocket.send(PacketContainer.serialize(message));
+    } catch (Exception e) {
+      System.err.println("Failed to send message: " + text);
+      System.err.println(e);
+    }
+  }
+
+  /**
+   *  The server-side implementation on how to handle certain packets when received
+   */
+  private void onPacketReceived(WebSocket webSocket, IPacket packet) {
+    if (packet instanceof UnifyRequestPacket unifyRequestPacket) {
+
+      // TODO: this static property will be a problem once we send more than one request per server and
+      //  should be replaced by a dynamic object property
+      PlaceholderType.EXISTING_PLACEHOLDERS.clear();
+      sendMessage(webSocket, "You requested a unify! Please wait until I calculated everything...");
+      System.out.println("Client " + webSocket.<SocketData>getAttachment().id + " requested a unification. Starting now...");
+      webSocket.<SocketData>getAttachment().hasSentTask = true;
+
+      try {
+        // start the unification algorithm from the received data
+        List<ResultSet> result = TypeInference.executeWithoutContext(
+          unifyRequestPacket.retrieveFiniteClosure(),
+          unifyRequestPacket.retrieveConstraints(),
+          unifyRequestPacket.retrieveUnifyConstraints()
+        );
+        System.out.println("Finished unification for client " + webSocket.<SocketData>getAttachment().id);
+        sendMessage(webSocket, "Unification finished. Found " + result.size() + " result sets");
+
+        if (webSocket.isOpen()) {
+          UnifyResultPacket resultPacket = UnifyResultPacket.create(result);
+          webSocket.send(PacketContainer.serialize(resultPacket));
+        }
+      } catch (Exception e) {
+        System.err.println(e);
+        log.error("e: ", e);
+      }
+
+      webSocket.close();
+    } else {
+      sendMessage(webSocket, "The package of type " + packet.getClass().getName() + " is not handled by the server!");
+    }
+  }
+}

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

@@ -0,0 +1,14 @@
+package de.dhbwstuttgart.server.packet;
+
+/**
+ * A packet to send simple error messages between the client and the server
+ */
+public class ErrorPacket implements IPacket {
+
+  /**
+   * The error endpoint for messages from the server, that should be logged out outputted
+   */
+  public String error;
+
+
+}

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

@@ -0,0 +1,18 @@
+package de.dhbwstuttgart.server.packet;
+
+/**
+ * The shared interface for all packet of the server connection.
+ * A packet must always:
+ * - Have a default / no-parameter constructor
+ * - Have only serializable public properties (or disable them via jackson annotations)
+ * A packet should have, for easy usage and consisteny:
+ * - a static create() method
+ *
+ */
+public interface IPacket {
+
+  interface IDataContainer<T> {
+    T toObject();
+  }
+
+}

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

@@ -0,0 +1,13 @@
+package de.dhbwstuttgart.server.packet;
+
+/**
+ * A fallback packet that is generated, if the received json could not be mapped to an existing package
+ */
+public class InvalidPacket implements IPacket {
+
+  /**
+   * If available, the error that caused this package to appear
+   */
+  public String error = "<unknown error>";
+
+}

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

@@ -0,0 +1,13 @@
+package de.dhbwstuttgart.server.packet;
+
+/**
+ * A packet to send simple informational messages between the client and the server
+ */
+public class MessagePacket implements IPacket {
+
+  /**
+   * The informational message from the server, that should be logged out outputted
+   */
+  public String message;
+
+}

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

@@ -0,0 +1,84 @@
+package de.dhbwstuttgart.server.packet;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * A wrapper for the packet to ensure correct serialization/deserialization and make it possible to detect the matching
+ * packet type for deserialization.
+ */
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class PacketContainer {
+
+  // The jackson serializer / deserializer tool
+  private static final ObjectMapper objectMapper = new ObjectMapper();
+
+  /*
+   * The available packet types. The one type that is represented in the JSON should always be the ONLY non-null value.
+   * They have to be private (for the moment) to let jackson fill them in while deserializing
+   */
+  public ErrorPacket errorPacket = null;
+  public MessagePacket messagePacket = null;
+  public InvalidPacket invalidPacket = null;
+  public UnifyRequestPacket unifyRequestPacket = null;
+  public UnifyResultPacket unifyResultPacket = null;
+
+
+  /**
+   * Generate the JSON string for the given packet
+   *
+   * @param packet The packet to serialize
+   * @return The json representation of the packet
+   */
+  public static String serialize(IPacket packet) throws JsonProcessingException {
+    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+    PacketContainer container = new PacketContainer();
+
+    if (packet instanceof ErrorPacket)
+      container.errorPacket = (ErrorPacket) packet;
+    else if (packet instanceof MessagePacket)
+      container.messagePacket = (MessagePacket) packet;
+    else if (packet instanceof UnifyRequestPacket)
+      container.unifyRequestPacket = (UnifyRequestPacket) packet;
+    else if (packet instanceof UnifyResultPacket)
+      container.unifyResultPacket = (UnifyResultPacket) packet;
+    // Add new packets here and in the deserialize method
+
+    return objectMapper.writeValueAsString(container);
+  }
+
+  /**
+   * Use the JSON string to generate the matching packet object
+   *
+   * @param json The serialized representation of a packet container
+   * @return The deserialized Packet object
+   */
+  public static IPacket deserialize(String json) {
+    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+
+    try {
+      PacketContainer container = objectMapper.readValue(json, PacketContainer.class);
+
+      if (container.errorPacket != null)
+        return container.errorPacket;
+      if (container.messagePacket != null)
+        return container.messagePacket;
+      if (container.invalidPacket != null)
+        return container.invalidPacket;
+      if (container.unifyRequestPacket != null)
+        return container.unifyRequestPacket;
+      if (container.unifyResultPacket != null)
+        return container.unifyResultPacket;
+      // Add new packets here and in the serialize method
+
+      throw new RuntimeException("Cannot map received json to any known packet class");
+    } catch (Exception e) {
+      InvalidPacket packet = new InvalidPacket();
+      packet.error = e.getMessage();
+      return packet;
+    }
+  }
+
+
+}

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

@@ -0,0 +1,48 @@
+package de.dhbwstuttgart.server.packet;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedFiniteClosure;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedPairConstraintSet;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedUnifyConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+
+/**
+ * A packet to send all required data for the unification algorithm to the server and request the unification
+ */
+public class UnifyRequestPacket implements IPacket {
+
+  public SerializedFiniteClosure finiteClosure;
+  public SerializedPairConstraintSet constraints;
+  public SerializedUnifyConstraintSet unifyConstraints;
+
+  public static UnifyRequestPacket create(
+    IFiniteClosure finiteClosure,
+    ConstraintSet<Pair> constraints,
+    ConstraintSet<UnifyPair> unifyConstraints
+  ) {
+    UnifyRequestPacket packet = new UnifyRequestPacket();
+    packet.finiteClosure = SerializedFiniteClosure.create(finiteClosure);
+    packet.constraints = SerializedPairConstraintSet.create(constraints);
+    packet.unifyConstraints = SerializedUnifyConstraintSet.create(unifyConstraints);
+    return packet;
+  }
+
+  @JsonIgnore
+  public IFiniteClosure retrieveFiniteClosure() {
+    return this.finiteClosure.toObject();
+  }
+
+  @JsonIgnore
+  public ConstraintSet<Pair> retrieveConstraints() {
+    return this.constraints.toObject();
+  }
+
+  @JsonIgnore
+  public ConstraintSet<UnifyPair> retrieveUnifyConstraints() {
+    return this.unifyConstraints.toObject();
+  }
+
+}

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

@@ -0,0 +1,27 @@
+package de.dhbwstuttgart.server.packet;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedResultSet;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * A packet to send all calculated data from the unification algorithm back to the client
+ */
+public class UnifyResultPacket implements IPacket {
+
+  public SerializedResultSet[] results;
+
+  public static UnifyResultPacket create(List<ResultSet> resultSets) {
+    UnifyResultPacket serialized = new UnifyResultPacket();
+    serialized.results = resultSets.stream().map(SerializedResultSet::create).toArray(SerializedResultSet[]::new);
+    return serialized;
+  }
+
+  @JsonIgnore
+  public List<ResultSet> getResultSet() {
+    return Arrays.stream(this.results).map(SerializedResultSet::toObject).toList();
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedFiniteClosure.java

@@ -0,0 +1,30 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
+import java.util.Arrays;
+import java.util.HashSet;
+
+/**
+ * Serializable container of
+ *
+ * @see IFiniteClosure
+ */
+public class SerializedFiniteClosure implements IPacket.IDataContainer<IFiniteClosure> {
+  public SerializedUnifyPair[] pairs;
+
+  public static SerializedFiniteClosure create(IFiniteClosure finiteClosure) {
+    SerializedFiniteClosure fc = new SerializedFiniteClosure();
+    fc.pairs = finiteClosure.getPairs().stream().map(SerializedUnifyPair::create).toArray(SerializedUnifyPair[]::new);
+    return fc;
+  }
+
+  @Override
+  public IFiniteClosure toObject() {
+    return new FiniteClosure(
+      new HashSet<>(Arrays.stream(pairs).map(SerializedUnifyPair::toObject).toList()),
+      null
+    );
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedPair.java

@@ -0,0 +1,37 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+
+/**
+ * Serializable container of
+ *
+ * @see Pair
+ */
+public class SerializedPair implements IPacket.IDataContainer<Pair> {
+
+  @JsonProperty("o")
+  public PairOperator operator;
+  public SerializedTokenWrapper ta1;
+  public SerializedTokenWrapper ta2;
+
+
+  public static SerializedPair create(Pair pair) {
+    SerializedPair sPair = new SerializedPair();
+    sPair.operator = pair.GetOperator();
+    sPair.ta1 = SerializedTokenWrapper.create(pair.TA1);
+    sPair.ta2 = SerializedTokenWrapper.create(pair.TA2);
+    return sPair;
+  }
+
+  @Override
+  public Pair toObject() {
+    return new Pair(
+      ta1.toObject(),
+      ta2.toObject(),
+      operator
+    );
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedPairConstraint.java

@@ -0,0 +1,82 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+
+/**
+ * Serializable container of
+ *
+ * @see Constraint<Pair>
+ */
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class SerializedPairConstraint implements IPacket.IDataContainer<Constraint<Pair>> {
+
+  // serialize recursive structure
+  public static final HashMap<Constraint<Pair>, String> UNIQUE_CONSTRAINT_KEY_MAP = new HashMap<>();
+  public static final HashMap<String, SerializedPairConstraint> UNIQUE_CONSTRAINT_MAP = new HashMap<>();
+  // deserialize recursive structure
+  private static final HashMap<String, Constraint<Pair>> UNIQUE_OBJECT_MAP = new HashMap<>();
+
+  @JsonProperty("i")
+  public boolean isInherited;
+  @JsonProperty("u")
+  public String uniqueKey;
+  @JsonProperty("e")
+  public String extendedConstraint = null;
+  @JsonProperty("m")
+  public SerializedPair[] methodSignatureConstraint;
+  @JsonProperty("c")
+  public SerializedPair[] constraintElements;
+
+
+  public static SerializedPairConstraint create(Constraint<Pair> constraint) {
+    final String uniqueKey = UNIQUE_CONSTRAINT_KEY_MAP.getOrDefault(constraint, "_" + UNIQUE_CONSTRAINT_MAP.size());
+
+    if (UNIQUE_CONSTRAINT_MAP.containsKey(uniqueKey)) {
+      return UNIQUE_CONSTRAINT_MAP.get(uniqueKey);
+    }
+
+    SerializedPairConstraint pairConstraint = new SerializedPairConstraint();
+    pairConstraint.uniqueKey = uniqueKey;
+    UNIQUE_CONSTRAINT_KEY_MAP.put(constraint, uniqueKey);
+    UNIQUE_CONSTRAINT_MAP.put(uniqueKey, pairConstraint);
+
+    pairConstraint.constraintElements = constraint.stream().map(SerializedPair::create).toArray(SerializedPair[]::new);
+    pairConstraint.isInherited = constraint.isInherited();
+    pairConstraint.methodSignatureConstraint = constraint.getmethodSignatureConstraint().stream().map(SerializedPair::create).toArray(SerializedPair[]::new);
+    if (constraint.getExtendConstraint() != null) {
+      pairConstraint.extendedConstraint = SerializedPairConstraint.create(constraint.getExtendConstraint()).uniqueKey;
+    }
+
+    return pairConstraint;
+  }
+
+  @Override
+  public Constraint<Pair> toObject() {
+    if (UNIQUE_OBJECT_MAP.containsKey(uniqueKey)) {
+      return UNIQUE_OBJECT_MAP.get(uniqueKey);
+    }
+
+    Constraint<Pair> constraint = new Constraint<>();
+    UNIQUE_OBJECT_MAP.put(uniqueKey, constraint);
+
+    constraint.addAll(Arrays.stream(constraintElements).map(SerializedPair::toObject).toList());
+    constraint.setIsInherited(isInherited);
+    constraint.setmethodSignatureConstraint(new HashSet<>(
+      Arrays.stream(methodSignatureConstraint).map(SerializedPair::toObject).toList()
+    ));
+    SerializedPairConstraint extendedConstraint = this.extendedConstraint == null ? null :
+      SerializedPairConstraint.UNIQUE_CONSTRAINT_MAP.get(this.extendedConstraint);
+    if (extendedConstraint != null) {
+      constraint.setExtendConstraint(extendedConstraint.toObject());
+    }
+
+    return constraint;
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedPairConstraintSet.java

@@ -0,0 +1,60 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Serializable container of
+ *
+ * @see ConstraintSet<Pair>
+ */
+public class SerializedPairConstraintSet implements IPacket.IDataContainer<ConstraintSet<Pair>> {
+
+  public SerializedPair[] undConstraints;
+  public SerializedPairConstraint[][] oderConstraints;
+  public Map<String, SerializedPairConstraint> uniqueConstraintMap = new HashMap<>();
+
+  public static SerializedPairConstraintSet create(ConstraintSet<Pair> constraints) {
+    SerializedPairConstraintSet constraintSet = new SerializedPairConstraintSet();
+
+    constraintSet.undConstraints = constraints.getUndConstraints().stream().map(SerializedPair::create).toArray(SerializedPair[]::new);
+    constraintSet.oderConstraints = constraints.getOderConstraints().stream().map(consSet ->
+      consSet.stream().map(SerializedPairConstraint::create).toArray(SerializedPairConstraint[]::new)
+    ).toArray(SerializedPairConstraint[][]::new);
+
+    // add all the gathered constraints to a serializable property
+    constraintSet.uniqueConstraintMap.putAll(SerializedPairConstraint.UNIQUE_CONSTRAINT_MAP);
+
+    return constraintSet;
+  }
+
+  @Override
+  public ConstraintSet<Pair> toObject() {
+    ConstraintSet<Pair> consSet = new ConstraintSet<>();
+
+    // read all the constraints from the serializable property
+    SerializedPairConstraint.UNIQUE_CONSTRAINT_MAP.putAll(this.uniqueConstraintMap);
+
+    Constraint<Pair> undCons = new Constraint<>();
+    undCons.addAll(Arrays.stream(undConstraints).map(SerializedPair::toObject).toList());
+    consSet.addAllUndConstraint(undCons);
+
+    List<Set<Constraint<Pair>>> oderCons = new ArrayList<>(Arrays.stream(oderConstraints).map(cons ->
+      new HashSet<>(
+        Arrays.stream(cons).map(SerializedPairConstraint::toObject).toList()
+      )
+    ).toList());
+    consSet.addAllOderConstraint(oderCons);
+
+    return consSet;
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedResultPairWrapper.java

@@ -0,0 +1,63 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.resultPairs.SerializedPairNoResult;
+import de.dhbwstuttgart.server.packet.dataContainers.resultPairs.SerializedPairTPHEqualTPH;
+import de.dhbwstuttgart.server.packet.dataContainers.resultPairs.SerializedPairTPHequalRefTypeOrWildcardType;
+import de.dhbwstuttgart.server.packet.dataContainers.resultPairs.SerializedPairTPHsmallerTPH;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.typeinference.result.PairNoResult;
+import de.dhbwstuttgart.typeinference.result.PairTPHEqualTPH;
+import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
+import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
+import de.dhbwstuttgart.typeinference.result.ResultPair;
+
+/**
+ * Serializable container of
+ *
+ * @see ResultPair
+ */
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class SerializedResultPairWrapper implements IPacket.IDataContainer<ResultPair<RefTypeOrTPHOrWildcardOrGeneric, RefTypeOrTPHOrWildcardOrGeneric>> {
+
+  @JsonProperty("nr")
+  public SerializedPairNoResult noResult = null;
+  @JsonProperty("teo")
+  public SerializedPairTPHequalRefTypeOrWildcardType tphEqualOther = null;
+  @JsonProperty("tet")
+  public SerializedPairTPHEqualTPH tphEqualTph = null;
+  @JsonProperty("tst")
+  public SerializedPairTPHsmallerTPH tphSmallerTPH = null;
+
+
+  public static <A extends RefTypeOrTPHOrWildcardOrGeneric, B extends RefTypeOrTPHOrWildcardOrGeneric> SerializedResultPairWrapper create(ResultPair<A, B> pair) {
+    SerializedResultPairWrapper serialized = new SerializedResultPairWrapper();
+
+    if (pair instanceof PairNoResult noResult)
+      serialized.noResult = SerializedPairNoResult.create(noResult);
+    else if (pair instanceof PairTPHequalRefTypeOrWildcardType tphEqualOther)
+      serialized.tphEqualOther = SerializedPairTPHequalRefTypeOrWildcardType.create(tphEqualOther);
+    else if (pair instanceof PairTPHEqualTPH tphEqualTph)
+      serialized.tphEqualTph = SerializedPairTPHEqualTPH.create(tphEqualTph);
+    else if (pair instanceof PairTPHsmallerTPH tphSmallerTPH)
+      serialized.tphSmallerTPH = SerializedPairTPHsmallerTPH.create(tphSmallerTPH);
+
+    return serialized;
+  }
+
+  @Override
+  @SuppressWarnings("rawtypes") // this is not optimal, but we have to conform to interface specifications
+  public ResultPair toObject() {
+    if (noResult != null)
+      return noResult.toObject();
+    else if (tphEqualOther != null)
+      return tphEqualOther.toObject();
+    else if (tphEqualTph != null)
+      return tphEqualTph.toObject();
+    else if (tphSmallerTPH != null)
+      return tphSmallerTPH.toObject();
+    return null;
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedResultSet.java

@@ -0,0 +1,31 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import java.util.Arrays;
+import java.util.HashSet;
+
+/**
+ * Serializable container of
+ *
+ * @see ResultSet
+ */
+public class SerializedResultSet implements IPacket.IDataContainer<ResultSet> {
+
+  public SerializedResultPairWrapper[] results;
+
+  public static SerializedResultSet create(ResultSet resultSet) {
+    SerializedResultSet serialized = new SerializedResultSet();
+    serialized.results = resultSet.results.stream().map(SerializedResultPairWrapper::create).toArray(SerializedResultPairWrapper[]::new);
+    return serialized;
+  }
+
+  public ResultSet toObject() {
+    return new ResultSet(
+      new HashSet<>(
+        Arrays.stream(this.results).map(SerializedResultPairWrapper::toObject).toList()
+      )
+    );
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedTokenWrapper.java

@@ -0,0 +1,72 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedExtendsWildcardType;
+import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedGenericRefType;
+import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedPlaceholderType;
+import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedRefType;
+import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedSuperWildcardType;
+import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedVoidType;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.type.Void;
+
+/**
+ * Serializable container of
+ *
+ * @see RefTypeOrTPHOrWildcardOrGeneric
+ */
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class SerializedTokenWrapper implements IPacket.IDataContainer<RefTypeOrTPHOrWildcardOrGeneric> {
+
+  @JsonProperty("ew")
+  public SerializedExtendsWildcardType extendsWildcardType = null;
+  @JsonProperty("gr")
+  public SerializedGenericRefType genericRefType = null;
+  @JsonProperty("p")
+  public SerializedPlaceholderType placeholderType = null;
+  @JsonProperty("r")
+  public SerializedRefType refType = null;
+  @JsonProperty("sw")
+  public SerializedSuperWildcardType superWildcardType = null;
+  @JsonProperty("v")
+  public SerializedVoidType voidType = null;
+
+
+  public static SerializedTokenWrapper create(RefTypeOrTPHOrWildcardOrGeneric type) {
+    SerializedTokenWrapper wrapper = new SerializedTokenWrapper();
+
+    if (type instanceof ExtendsWildcardType)
+      wrapper.extendsWildcardType = SerializedExtendsWildcardType.create((ExtendsWildcardType) type);
+    else if (type instanceof GenericRefType)
+      wrapper.genericRefType = SerializedGenericRefType.create((GenericRefType) type);
+    else if (type instanceof TypePlaceholder)
+      wrapper.placeholderType = SerializedPlaceholderType.create((TypePlaceholder) type);
+    else if (type instanceof Void)
+      wrapper.voidType = SerializedVoidType.create((Void) type);
+    else if (type instanceof RefType)
+      wrapper.refType = SerializedRefType.create((RefType) type);
+    else if (type instanceof SuperWildcardType)
+      wrapper.superWildcardType = SerializedSuperWildcardType.create((SuperWildcardType) type);
+
+    return wrapper;
+  }
+
+
+  @Override
+  public RefTypeOrTPHOrWildcardOrGeneric toObject() {
+    if (extendsWildcardType != null) return extendsWildcardType.toObject();
+    if (genericRefType != null) return genericRefType.toObject();
+    if (placeholderType != null) return placeholderType.toObject();
+    if (refType != null) return refType.toObject();
+    if (superWildcardType != null) return superWildcardType.toObject();
+    if (voidType != null) return voidType.toObject();
+    return null;
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedUnifyConstraintSet.java

@@ -0,0 +1,49 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Serializable container of
+ *
+ * @see ConstraintSet<UnifyPair>
+ */
+public class SerializedUnifyConstraintSet implements IPacket.IDataContainer<ConstraintSet<UnifyPair>> {
+
+  public SerializedUnifyPair[] undConstraints;
+  public SerializedUnifyPairConstraint[][] oderConstraints;
+
+  public static SerializedUnifyConstraintSet create(ConstraintSet<UnifyPair> unifyCons) {
+    SerializedUnifyConstraintSet constraintSet = new SerializedUnifyConstraintSet();
+    constraintSet.undConstraints = unifyCons.getUndConstraints().stream().map(SerializedUnifyPair::create).toArray(SerializedUnifyPair[]::new);
+    constraintSet.oderConstraints = unifyCons.getOderConstraints().stream().map(constraints ->
+      constraints.stream().map(SerializedUnifyPairConstraint::create).toArray(SerializedUnifyPairConstraint[]::new)
+    ).toArray(SerializedUnifyPairConstraint[][]::new);
+    return constraintSet;
+  }
+
+  @Override
+  public ConstraintSet<UnifyPair> toObject() {
+    ConstraintSet<UnifyPair> consSet = new ConstraintSet<>();
+
+    Constraint<UnifyPair> undCons = new Constraint<>();
+    undCons.addAll(Arrays.stream(undConstraints).map(SerializedUnifyPair::toObject).toList());
+    consSet.addAllUndConstraint(undCons);
+
+    List<Set<Constraint<UnifyPair>>> oderCons = new ArrayList<>(Arrays.stream(oderConstraints).map(oderConsSet ->
+      new HashSet<>(
+        Arrays.stream(oderConsSet).map(SerializedUnifyPairConstraint::toObject).toList()
+      )
+    ).toList());
+    consSet.addAllOderConstraint(oderCons);
+
+    return consSet;
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedUnifyPair.java

@@ -0,0 +1,32 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+
+/**
+ * Serializable container of
+ *
+ * @see UnifyPair
+ */
+public class SerializedUnifyPair implements IPacket.IDataContainer<UnifyPair> {
+
+  public SerializedUnifyTypeWrapper lhs;
+  public SerializedUnifyTypeWrapper rhs;
+  @JsonProperty("o")
+  public PairOperator operator;
+
+  public static SerializedUnifyPair create(UnifyPair unifyPair) {
+    SerializedUnifyPair pair = new SerializedUnifyPair();
+    pair.lhs = SerializedUnifyTypeWrapper.create(unifyPair.getLhsType());
+    pair.rhs = SerializedUnifyTypeWrapper.create(unifyPair.getRhsType());
+    pair.operator = unifyPair.getPairOp();
+    return pair;
+  }
+
+  @Override
+  public UnifyPair toObject() {
+    return new UnifyPair(lhs.toObject(), rhs.toObject(), operator);
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedUnifyPairConstraint.java

@@ -0,0 +1,52 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import java.util.Arrays;
+import java.util.HashSet;
+
+/**
+ * Serializable container of
+ *
+ * @see Constraint<UnifyPair>
+ */
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class SerializedUnifyPairConstraint implements IPacket.IDataContainer<Constraint<UnifyPair>> {
+
+  @JsonProperty("i")
+  public boolean isInherited;
+  @JsonProperty("ec")
+  public SerializedUnifyPairConstraint extendedConstraint = null;
+  @JsonProperty("p")
+  public SerializedUnifyPair[] methodSignatureConstraints;
+  @JsonProperty("c")
+  public SerializedUnifyPair[] constraintElements;
+
+
+  public static SerializedUnifyPairConstraint create(Constraint<UnifyPair> constraint) {
+    SerializedUnifyPairConstraint cons = new SerializedUnifyPairConstraint();
+    cons.constraintElements = constraint.stream().map(SerializedUnifyPair::create).toArray(SerializedUnifyPair[]::new);
+    cons.isInherited = constraint.isInherited();
+    if (constraint.getExtendConstraint() != null) {
+      cons.extendedConstraint = SerializedUnifyPairConstraint.create(constraint.getExtendConstraint());
+    }
+    cons.methodSignatureConstraints = constraint.getmethodSignatureConstraint().stream().map(SerializedUnifyPair::create).toArray(SerializedUnifyPair[]::new);
+    return cons;
+  }
+
+  @Override
+  public Constraint<UnifyPair> toObject() {
+    Constraint<UnifyPair> cons = new Constraint<>();
+
+    cons.addAll(Arrays.stream(constraintElements).map(SerializedUnifyPair::toObject).toList());
+    cons.setIsInherited(isInherited);
+    if (extendedConstraint != null) {
+      cons.setExtendConstraint(extendedConstraint.toObject());
+    }
+    cons.setmethodSignatureConstraint(new HashSet<>(Arrays.stream(methodSignatureConstraints).map(SerializedUnifyPair::toObject).toList()));
+    return cons;
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedUnifyTypeWrapper.java

@@ -0,0 +1,65 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.unifyType.SerializedExtendsType;
+import de.dhbwstuttgart.server.packet.dataContainers.unifyType.SerializedFunNType;
+import de.dhbwstuttgart.server.packet.dataContainers.unifyType.SerializedPlaceholderType;
+import de.dhbwstuttgart.server.packet.dataContainers.unifyType.SerializedReferenceType;
+import de.dhbwstuttgart.server.packet.dataContainers.unifyType.SerializedSuperType;
+import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
+import de.dhbwstuttgart.typeinference.unify.model.FunNType;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
+import de.dhbwstuttgart.typeinference.unify.model.SuperType;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+
+/**
+ * Serializable container of
+ *
+ * @see UnifyType
+ */
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class SerializedUnifyTypeWrapper implements IPacket.IDataContainer<UnifyType> {
+
+  @JsonProperty("e")
+  public SerializedExtendsType extendsType = null;
+  @JsonProperty("s")
+  public SerializedSuperType superType = null;
+  @JsonProperty("r")
+  public SerializedReferenceType referenceType = null;
+  @JsonProperty("f")
+  public SerializedFunNType funNType = null;
+  @JsonProperty("p")
+  public SerializedPlaceholderType placeholderType = null;
+
+
+  public static SerializedUnifyTypeWrapper create(UnifyType unifyType) {
+    SerializedUnifyTypeWrapper wrapper = new SerializedUnifyTypeWrapper();
+
+    if (unifyType instanceof ExtendsType)
+      wrapper.extendsType = SerializedExtendsType.create((ExtendsType) unifyType);
+    else if (unifyType instanceof SuperType)
+      wrapper.superType = SerializedSuperType.create((SuperType) unifyType);
+    else if (unifyType instanceof ReferenceType)
+      wrapper.referenceType = SerializedReferenceType.create((ReferenceType) unifyType);
+    else if (unifyType instanceof FunNType)
+      wrapper.funNType = SerializedFunNType.create((FunNType) unifyType);
+    else if (unifyType instanceof PlaceholderType)
+      wrapper.placeholderType = SerializedPlaceholderType.create((PlaceholderType) unifyType);
+
+    return wrapper;
+  }
+
+
+  @Override
+  public UnifyType toObject() {
+    if (extendsType != null) return extendsType.toObject();
+    if (superType != null) return superType.toObject();
+    if (referenceType != null) return referenceType.toObject();
+    if (funNType != null) return funNType.toObject();
+    if (placeholderType != null) return placeholderType.toObject();
+    return null;
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/resultPairs/SerializedPairNoResult.java

@@ -0,0 +1,38 @@
+package de.dhbwstuttgart.server.packet.dataContainers.resultPairs;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedTokenWrapper;
+import de.dhbwstuttgart.typeinference.result.PairNoResult;
+
+/**
+ * Serializable container of
+ *
+ * @see PairNoResult
+ */
+public class SerializedPairNoResult implements IPacket.IDataContainer<PairNoResult> {
+
+  @JsonProperty("l")
+  public SerializedTokenWrapper left;
+  @JsonProperty("r")
+  public SerializedTokenWrapper right;
+
+  /**
+   * Use a static create method to leave the default constructor and simplify list conversions
+   */
+  public static SerializedPairNoResult create(PairNoResult pair) {
+    SerializedPairNoResult serialized = new SerializedPairNoResult();
+    serialized.left = SerializedTokenWrapper.create(pair.getLeft());
+    serialized.right = SerializedTokenWrapper.create(pair.getRight());
+    return serialized;
+  }
+
+  @Override
+  public PairNoResult toObject() {
+    return new PairNoResult(
+      left.toObject(),
+      right.toObject()
+    );
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/resultPairs/SerializedPairTPHEqualTPH.java

@@ -0,0 +1,34 @@
+package de.dhbwstuttgart.server.packet.dataContainers.resultPairs;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedPlaceholderType;
+import de.dhbwstuttgart.typeinference.result.PairTPHEqualTPH;
+
+/**
+ * Serializable container of
+ *
+ * @see PairTPHEqualTPH
+ */
+public class SerializedPairTPHEqualTPH implements IPacket.IDataContainer<PairTPHEqualTPH> {
+
+  @JsonProperty("l")
+  public SerializedPlaceholderType left;
+  @JsonProperty("r")
+  public SerializedPlaceholderType right;
+
+  public static SerializedPairTPHEqualTPH create(PairTPHEqualTPH pair) {
+    SerializedPairTPHEqualTPH serialized = new SerializedPairTPHEqualTPH();
+    serialized.left = SerializedPlaceholderType.create(pair.getLeft());
+    serialized.right = SerializedPlaceholderType.create(pair.getRight());
+    return serialized;
+  }
+
+  @Override
+  public PairTPHEqualTPH toObject() {
+    return new PairTPHEqualTPH(
+      left.toObject(),
+      right.toObject()
+    );
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/resultPairs/SerializedPairTPHequalRefTypeOrWildcardType.java

@@ -0,0 +1,36 @@
+package de.dhbwstuttgart.server.packet.dataContainers.resultPairs;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedTokenWrapper;
+import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedPlaceholderType;
+import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
+
+/**
+ * Serializable container of
+ *
+ * @see PairTPHequalRefTypeOrWildcardType
+ */
+public class SerializedPairTPHequalRefTypeOrWildcardType implements IPacket.IDataContainer<PairTPHequalRefTypeOrWildcardType> {
+
+  @JsonProperty("l")
+  public SerializedPlaceholderType left;
+  @JsonProperty("r")
+  public SerializedTokenWrapper right;
+
+  public static SerializedPairTPHequalRefTypeOrWildcardType create(PairTPHequalRefTypeOrWildcardType pair) {
+    SerializedPairTPHequalRefTypeOrWildcardType serialized = new SerializedPairTPHequalRefTypeOrWildcardType();
+    serialized.left = SerializedPlaceholderType.create(pair.left);
+    serialized.right = SerializedTokenWrapper.create(pair.right);
+    return serialized;
+  }
+
+  @Override
+  public PairTPHequalRefTypeOrWildcardType toObject() {
+    return new PairTPHequalRefTypeOrWildcardType(
+      left.toObject(),
+      right.toObject()
+    );
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/resultPairs/SerializedPairTPHsmallerTPH.java

@@ -0,0 +1,34 @@
+package de.dhbwstuttgart.server.packet.dataContainers.resultPairs;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedPlaceholderType;
+import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
+
+/**
+ * Serializable container of
+ *
+ * @see PairTPHsmallerTPH
+ */
+public class SerializedPairTPHsmallerTPH implements IPacket.IDataContainer<PairTPHsmallerTPH> {
+
+  @JsonProperty("l")
+  public SerializedPlaceholderType left;
+  @JsonProperty("r")
+  public SerializedPlaceholderType right;
+
+  public static SerializedPairTPHsmallerTPH create(PairTPHsmallerTPH pair) {
+    SerializedPairTPHsmallerTPH serialized = new SerializedPairTPHsmallerTPH();
+    serialized.left = SerializedPlaceholderType.create(pair.left);
+    serialized.right = SerializedPlaceholderType.create(pair.right);
+    return serialized;
+  }
+
+  @Override
+  public PairTPHsmallerTPH toObject() {
+    return new PairTPHsmallerTPH(
+      left.toObject(),
+      right.toObject()
+    );
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedExtendsWildcardType.java

@@ -0,0 +1,29 @@
+package de.dhbwstuttgart.server.packet.dataContainers.token;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedTokenWrapper;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+
+/**
+ * Serializable container of
+ *
+ * @see ExtendsWildcardType
+ */
+public class SerializedExtendsWildcardType implements IPacket.IDataContainer<ExtendsWildcardType> {
+
+  @JsonProperty("e")
+  public SerializedTokenWrapper extendsType;
+
+  public static SerializedExtendsWildcardType create(ExtendsWildcardType extendsWildcardType) {
+    SerializedExtendsWildcardType type = new SerializedExtendsWildcardType();
+    type.extendsType = SerializedTokenWrapper.create(extendsWildcardType.getInnerType());
+    return type;
+  }
+
+  @Override
+  public ExtendsWildcardType toObject() {
+    return new ExtendsWildcardType(extendsType.toObject(), new NullToken());
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedGenericRefType.java

@@ -0,0 +1,28 @@
+package de.dhbwstuttgart.server.packet.dataContainers.token;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+
+/**
+ * Serializable container of
+ *
+ * @see GenericRefType
+ */
+public class SerializedGenericRefType implements IPacket.IDataContainer<GenericRefType> {
+
+  @JsonProperty("n")
+  public String name;
+
+  public static SerializedGenericRefType create(GenericRefType genericRefType) {
+    SerializedGenericRefType serialized = new SerializedGenericRefType();
+    serialized.name = genericRefType.getParsedName();
+    return serialized;
+  }
+
+  @Override
+  public GenericRefType toObject() {
+    return new GenericRefType(name, new NullToken());
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedPlaceholderType.java

@@ -0,0 +1,27 @@
+package de.dhbwstuttgart.server.packet.dataContainers.token;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
+/**
+ * Serializable container of
+ *
+ * @see TypePlaceholder
+ */
+public class SerializedPlaceholderType implements IPacket.IDataContainer<TypePlaceholder> {
+
+  @JsonProperty("n")
+  public String name;
+
+  public static SerializedPlaceholderType create(TypePlaceholder typePlaceholder) {
+    SerializedPlaceholderType serialized = new SerializedPlaceholderType();
+    serialized.name = typePlaceholder.getName();
+    return serialized;
+  }
+
+  @Override
+  public TypePlaceholder toObject() {
+    return (TypePlaceholder) TypePlaceholder.of(name);
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedRefType.java

@@ -0,0 +1,40 @@
+package de.dhbwstuttgart.server.packet.dataContainers.token;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedTokenWrapper;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import java.util.Arrays;
+
+/**
+ * Serializable container of
+ *
+ * @see RefType
+ */
+public class SerializedRefType implements IPacket.IDataContainer<RefType> {
+
+  @JsonProperty("n")
+  public String name;
+  @JsonProperty("p")
+  public SerializedTokenWrapper[] parameters;
+
+  public static SerializedRefType create(RefType refType) {
+    SerializedRefType serialized = new SerializedRefType();
+
+    serialized.name = refType.getName().toString();
+    serialized.parameters = refType.getParaList().stream().map(SerializedTokenWrapper::create).toArray(SerializedTokenWrapper[]::new);
+
+    return serialized;
+  }
+
+  @Override
+  public RefType toObject() {
+    return new RefType(
+      new JavaClassName(name),
+      Arrays.stream(parameters).map(SerializedTokenWrapper::toObject).toList(),
+      new NullToken()
+    );
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedSuperWildcardType.java

@@ -0,0 +1,30 @@
+package de.dhbwstuttgart.server.packet.dataContainers.token;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedTokenWrapper;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+
+/**
+ * Serializable container of
+ *
+ * @see SuperWildcardType
+ */
+public class SerializedSuperWildcardType implements IPacket.IDataContainer<SuperWildcardType> {
+
+  @JsonProperty("s")
+  public SerializedTokenWrapper superType;
+
+  public static SerializedSuperWildcardType create(SuperWildcardType superWildcardType) {
+    SerializedSuperWildcardType type = new SerializedSuperWildcardType();
+    type.superType = SerializedTokenWrapper.create(superWildcardType.getInnerType());
+    type.superType = SerializedTokenWrapper.create(superWildcardType.getInnerType());
+    return type;
+  }
+
+  @Override
+  public SuperWildcardType toObject() {
+    return new SuperWildcardType(superType.toObject(), new NullToken());
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedVoidType.java

@@ -0,0 +1,24 @@
+package de.dhbwstuttgart.server.packet.dataContainers.token;
+
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.syntaxtree.type.Void;
+
+/**
+ * Serializable container of
+ *
+ * @see Void
+ */
+public class SerializedVoidType implements IPacket.IDataContainer<Void> {
+
+  public int i = 0;
+
+  public static SerializedVoidType create(Void voidType) {
+    return new SerializedVoidType();
+  }
+
+  @Override
+  public Void toObject() {
+    return new Void(new NullToken());
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedExtendsType.java

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
+
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
+
+/**
+ * Serializable container of
+ *
+ * @see ExtendsType
+ */
+public class SerializedExtendsType extends SerializedWildcardType implements IPacket.IDataContainer<ExtendsType> {
+
+  public static SerializedExtendsType create(ExtendsType extendsType) {
+    SerializedExtendsType type = new SerializedExtendsType();
+    type.readWildcardTypeValues(extendsType);
+    return type;
+  }
+
+  @Override
+  public ExtendsType toObject() {
+    return new ExtendsType(
+      this.wildcardedType.toObject()
+    );
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedFunNType.java

@@ -0,0 +1,32 @@
+package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
+
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedUnifyTypeWrapper;
+import de.dhbwstuttgart.typeinference.unify.model.FunNType;
+import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
+import java.util.Arrays;
+
+/**
+ * Serializable container of
+ *
+ * @see FunNType
+ */
+public class SerializedFunNType extends SerializedUnifyType implements IPacket.IDataContainer<FunNType> {
+
+
+  public static SerializedFunNType create(FunNType funN) {
+    SerializedFunNType type = new SerializedFunNType();
+    type.readUnifyTypeValues(funN);
+    return type;
+  }
+
+  @Override
+  public FunNType toObject() {
+    return FunNType.getFunNType(
+      new TypeParams(
+        Arrays.stream(this.params).map(SerializedUnifyTypeWrapper::toObject).toList()
+      )
+    );
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedPlaceholderType.java

@@ -0,0 +1,38 @@
+package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
+
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+
+/**
+ * Serializable container of
+ *
+ * @see PlaceholderType
+ */
+public class SerializedPlaceholderType extends SerializedUnifyType implements IPacket.IDataContainer<PlaceholderType> {
+
+  public boolean isGenerated;
+  public boolean isInnerType;
+  public int variance;
+  public byte orCons;
+
+
+  public static SerializedPlaceholderType create(PlaceholderType placeholder) {
+    SerializedPlaceholderType type = new SerializedPlaceholderType();
+    type.readUnifyTypeValues(placeholder);
+    type.isGenerated = placeholder.isGenerated();
+    type.isInnerType = placeholder.isInnerType();
+    type.variance = placeholder.getVariance();
+    type.orCons = placeholder.getOrCons();
+    return type;
+  }
+
+  @Override
+  public PlaceholderType toObject() {
+    PlaceholderType placeholderType = new PlaceholderType(this.name, this.isGenerated);
+    placeholderType.setInnerType(this.isInnerType);
+    placeholderType.setVariance(this.variance);
+    placeholderType.setOrCons(this.orCons);
+    return placeholderType;
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedReferenceType.java

@@ -0,0 +1,37 @@
+package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedUnifyTypeWrapper;
+import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
+import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
+import java.util.Arrays;
+
+/**
+ * Serializable container of
+ *
+ * @see ReferenceType
+ */
+public class SerializedReferenceType extends SerializedUnifyType implements IPacket.IDataContainer<ReferenceType> {
+
+  @JsonProperty("gt")
+  public boolean genericTypeVar;
+
+  public static SerializedReferenceType create(ReferenceType referenceType) {
+    SerializedReferenceType type = new SerializedReferenceType();
+    type.readUnifyTypeValues(referenceType);
+    type.genericTypeVar = referenceType.isGenTypeVar();
+    return type;
+  }
+
+  @Override
+  public ReferenceType toObject() {
+    ReferenceType referenceType = new ReferenceType(this.name, this.genericTypeVar);
+    return (ReferenceType) referenceType.setTypeParams(
+      new TypeParams(
+        Arrays.stream(this.params).map(SerializedUnifyTypeWrapper::toObject).toList()
+      )
+    );
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedSuperType.java

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
+
+import de.dhbwstuttgart.server.packet.IPacket;
+import de.dhbwstuttgart.typeinference.unify.model.SuperType;
+
+/**
+ * Serializable container of
+ *
+ * @see SuperType
+ */
+public class SerializedSuperType extends SerializedWildcardType implements IPacket.IDataContainer<SuperType> {
+
+  public static SerializedSuperType create(SuperType superType) {
+    SerializedSuperType type = new SerializedSuperType();
+    type.readWildcardTypeValues(superType);
+    return type;
+  }
+
+  @Override
+  public SuperType toObject() {
+    return new SuperType(
+      this.wildcardedType.toObject()
+    );
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedUnifyType.java

@@ -0,0 +1,24 @@
+package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedUnifyTypeWrapper;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+import java.util.Arrays;
+
+/**
+ * Serializable abstract container of
+ *
+ * @see UnifyType
+ */
+abstract class SerializedUnifyType {
+
+  @JsonProperty("n")
+  public String name;
+  @JsonProperty("p")
+  public SerializedUnifyTypeWrapper[] params = new SerializedUnifyTypeWrapper[]{};
+
+  public void readUnifyTypeValues(UnifyType unifyType) {
+    name = unifyType.getName();
+    params = Arrays.stream(unifyType.getTypeParams().get()).map(SerializedUnifyTypeWrapper::create).toArray(SerializedUnifyTypeWrapper[]::new);
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedWildcardType.java

@@ -0,0 +1,20 @@
+package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
+
+import de.dhbwstuttgart.server.packet.dataContainers.SerializedUnifyTypeWrapper;
+import de.dhbwstuttgart.typeinference.unify.model.WildcardType;
+
+/**
+ * Serializable abstract container of
+ *
+ * @see WildcardType
+ */
+abstract class SerializedWildcardType extends SerializedUnifyType {
+
+  public SerializedUnifyTypeWrapper wildcardedType;
+
+  public void readWildcardTypeValues(WildcardType wildcardType) {
+    this.readUnifyTypeValues(wildcardType);
+    wildcardedType = SerializedUnifyTypeWrapper.create(wildcardType.getWildcardedType());
+  }
+
+}

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

@@ -4,7 +4,6 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
 import de.dhbwstuttgart.syntaxtree.statement.Super;
 import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import org.antlr.v4.runtime.Token;

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

@@ -1,9 +1,8 @@
 package de.dhbwstuttgart.syntaxtree;
 
 import de.dhbwstuttgart.syntaxtree.statement.Expression;
-import org.antlr.v4.runtime.Token;
-
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import org.antlr.v4.runtime.Token;
 
 /**
  * Eine Feldinitialisation steht für eine Felddeklaration mit gleichzeitiger Wertzuweisung

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

@@ -1,12 +1,12 @@
 package de.dhbwstuttgart.syntaxtree;
 
+import com.google.common.collect.Lists;
 import org.antlr.v4.runtime.Token;
 
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
-
+import java.util.Iterator;
-import de.dhbwstuttgart.parser.NullToken;
+import java.util.List;
-
+import java.util.Objects;
-import java.util.*;
 
 
 /**

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

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.syntaxtree;
 
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;

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

@@ -3,17 +3,14 @@ package de.dhbwstuttgart.syntaxtree;
 import java.util.ArrayList;
 import java.util.Objects;
 
+import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
-import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
-import de.dhbwstuttgart.typeinference.typeAlgo.TYPEStmt;
 import org.antlr.v4.runtime.Token;
 
-import de.dhbwstuttgart.core.IItemWithOffset;
+import java.util.ArrayList;
-import de.dhbwstuttgart.syntaxtree.statement.Block;
 
 /**
  * Stellt eine Methode dar. Problem: Parser kann nicht zwischen Methode und

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

@@ -5,8 +5,11 @@ import java.util.*;
 
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 //import sun.security.x509.X509CertInfo;
 
 public class SourceFile extends SyntaxTreeNode {

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

@@ -1,10 +1,6 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import de.dhbwstuttgart.core.IItemWithOffset;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
 //import org.antlr.v4.runtime.misc.Pair;
 

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

@@ -2,8 +2,6 @@ package de.dhbwstuttgart.syntaxtree;
 
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 
-import java.util.Collection;
-
 
 public interface TypeScope {
     Iterable<? extends GenericTypeVar> getGenerics();

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

@@ -26,6 +26,10 @@ import org.objectweb.asm.*;
 import org.objectweb.asm.signature.SignatureReader;
 import org.objectweb.asm.signature.SignatureVisitor;
 
+import java.lang.reflect.Constructor;
+import java.lang.reflect.*;
+import java.util.*;
+
 /**
  * Anmerkung: Die ASTFactory Methoden, welche ASTBäume aus java.lang.Class Objekten generieren, können davon ausgehen, dass alle Imports und Typnamen korrekt sind und müssen diese nicht überprüfen.
  */

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

@@ -21,19 +21,25 @@ import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.syntaxtree.type.WildcardType;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.result.PairNoResult;
+import de.dhbwstuttgart.typeinference.result.*;
-import de.dhbwstuttgart.typeinference.result.PairTPHEqualTPH;
-import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
-import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
-import de.dhbwstuttgart.typeinference.result.ResultPair;
 import de.dhbwstuttgart.typeinference.unify.model.*;
+import de.dhbwstuttgart.util.Logger;
 import org.antlr.v4.runtime.Token;
 
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
 public class UnifyTypeFactory {
 	
 	private static ArrayList<PlaceholderType> PLACEHOLDERS = new ArrayList<>(); 
 
-    public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses, Writer logFile, ClassLoader classLoader, JavaTXCompiler compiler) throws ClassNotFoundException {
+    public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses, Logger logger, ClassLoader classLoader, JavaTXCompiler compiler) throws ClassNotFoundException {
         /*
         Die transitive Hülle muss funktionieren.
         Man darf schreiben List<A> extends AL<A>
@@ -44,7 +50,7 @@ public class UnifyTypeFactory {
         Generell dürfen sie immer die gleichen Namen haben.
         TODO: die transitive Hülle bilden
          */
-        return new FiniteClosure(FCGenerator.toUnifyFC(compiler, fromClasses, classLoader), logFile, compiler);
+        return new FiniteClosure(FCGenerator.toUnifyFC(compiler, fromClasses, classLoader), logger, compiler);
     }
 
     public static UnifyPair generateSmallerPair(UnifyType tl, UnifyType tr, SourceLoc location){

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

@@ -2,9 +2,6 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import org.antlr.v4.runtime.Token;
 
 /*

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
-import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import org.antlr.v4.runtime.Token;
 

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

@@ -1,10 +1,7 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import org.antlr.v4.runtime.Token;
 
 

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

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import org.antlr.v4.runtime.Token;
 
 public class DoStmt extends WhileStmt

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

@@ -2,9 +2,6 @@ package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.Void;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
 
 

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

@@ -1,12 +1,7 @@
 
 package de.dhbwstuttgart.syntaxtree.statement;
 
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
-import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import org.antlr.v4.runtime.Token;
 
 public abstract class Expression extends TypableStatement {

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

@@ -1,8 +1,6 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import org.antlr.v4.runtime.Token;
 
 public class ExpressionReceiver extends Receiver
 {

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

@@ -1,18 +1,9 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
-import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import org.antlr.v4.runtime.Token;
 
-import java.util.HashSet;
-import java.util.Set;
-
 public class FieldVar extends Expression {
 
     public final String fieldVarName;

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

@@ -2,9 +2,6 @@ package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
 
 public class IfStmt extends Statement {

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

@@ -3,8 +3,6 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import org.antlr.v4.runtime.Token;
 
-import java.nio.charset.StandardCharsets;
-
 public abstract class JavaInternalExpression extends Statement{
     public JavaInternalExpression(RefTypeOrTPHOrWildcardOrGeneric retType, Token offset){
         super(retType, offset);

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

@@ -1,14 +1,11 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
-import de.dhbwstuttgart.syntaxtree.*;
+import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
+import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.syntaxtree.TypeScope;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
 import org.antlr.v4.runtime.Token;
-//import sun.reflect.generics.reflectiveObjects.NotImplementedException;
 
 import java.util.ArrayList;
 

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

@@ -2,10 +2,7 @@ package de.dhbwstuttgart.syntaxtree.statement;
 
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.statement.Expression;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import org.antlr.v4.runtime.Token;
 
 public class Literal extends Expression

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

@@ -1,11 +1,8 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
 
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import org.antlr.v4.runtime.Token;
 
 

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

@@ -1,20 +1,12 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
-import de.dhbwstuttgart.exceptions.TypeinferenceException;
+import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.*;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import org.antlr.v4.runtime.Token;
 
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import java.util.ArrayList;
-
+import java.util.List;
-import java.util.*;
 
 
 public class MethodCall extends Statement

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

@@ -1,11 +1,9 @@
 package de.dhbwstuttgart.syntaxtree.statement;
-import java.util.List;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
+
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import java.util.List;
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 
 
 public class NewArray extends Expression

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

@@ -1,13 +1,5 @@
 package de.dhbwstuttgart.syntaxtree.statement;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
 
-import de.dhbwstuttgart.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
@@ -19,7 +11,8 @@ import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import org.antlr.v4.runtime.Token;
-import de.dhbwstuttgart.exceptions.NotImplementedException;
+
+import java.util.ArrayList;
 
 
 public class NewClass extends MethodCall

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

@@ -9,7 +9,6 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 
 public class Super extends Expression {
 

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

@@ -2,14 +2,11 @@ package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import org.antlr.v4.runtime.Token;
 
-import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
-
 import java.util.ArrayList;
 import java.util.List;
 

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

@@ -1,10 +1,8 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import org.antlr.v4.runtime.Token;
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 
 public class This extends Expression
 {

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

@@ -21,5 +21,3 @@ public class ThisCall extends MethodCall
         visitor.visit(this);
     }
 }
-
-

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

@@ -2,8 +2,6 @@ package de.dhbwstuttgart.syntaxtree.statement;
 
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.statement.Expression;
-import de.dhbwstuttgart.syntaxtree.statement.JavaInternalExpression;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import org.antlr.v4.runtime.Token;
 

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

@@ -3,10 +3,6 @@ package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 import org.antlr.v4.runtime.Token;
 
 public class WhileStmt extends Statement

src/main/java/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java

@@ -15,7 +15,7 @@ import java.util.Objects;
  * 
  */
 
-public class ExtendsWildcardType extends WildcardType{
+public class ExtendsWildcardType extends WildcardType {
 	
 	/**
 	* Author: Arne Lüdtke<br/>

src/main/java/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java

@@ -1,9 +1,7 @@
 package de.dhbwstuttgart.syntaxtree.type;
-import java.util.Hashtable;
 
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.ASTVisitor;
-import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
 import org.antlr.v4.runtime.Token;

src/main/java/de/dhbwstuttgart/syntaxtree/type/Void.java

@@ -1,8 +1,7 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import org.antlr.v4.runtime.Token;
-
 import de.dhbwstuttgart.parser.scope.JavaClassName;
+import org.antlr.v4.runtime.Token;
 
 
 public class Void extends RefType
@@ -11,4 +10,3 @@ public class Void extends RefType
         super(JavaClassName.Void, offset);
     }
 }
-

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

@@ -1,6 +1,6 @@
 package de.dhbwstuttgart.syntaxtree.visual;
 
-import de.dhbwstuttgart.syntaxtree.*;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 
 public class ASTPrinter {