added unifyTest

pom.xml

@@ -44,23 +44,6 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<artifactId>asm</artifactId>
 			<version>7.0</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>

server-tests/.gitignore

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

server-tests/Lambda.jav

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

server-tests/Matrix.jav

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

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

@@ -1,21 +0,0 @@
-#!/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 -us ws://localhost:5000 $JAV_FILE

server-tests/_runServer.sh

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

@@ -9,14 +9,11 @@ import java.lang.invoke.CallSite;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
+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 TargetClass clazz;
@@ -1072,4 +1069,4 @@ public class Codegen {
         cw.visitEnd();
         return cw.toByteArray();
     }
-}
+}

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

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.bytecode;
 
+import de.dhbwstuttgart.target.tree.TargetGeneric;
 import de.dhbwstuttgart.target.tree.type.TargetGenericType;
 import de.dhbwstuttgart.target.tree.type.TargetRefType;
 import de.dhbwstuttgart.target.tree.type.TargetType;
@@ -119,4 +120,4 @@ public class FunNGenerator {
             throw new IndexOutOfBoundsException();
         return list.get(list.size() - 1);
     }
-}
+}

src/main/java/de/dhbwstuttgart/bytecode/constraint/TPHConstraint.java

@@ -1,8 +1,9 @@
 package de.dhbwstuttgart.bytecode.constraint;
 
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
 public class TPHConstraint {
 	protected String left;
@@ -86,4 +87,4 @@ public class TPHConstraint {
 			return left + " = " + right;
 		}
 	}
-}
+}

src/main/java/de/dhbwstuttgart/bytecode/genericsGeneratorTypes/ConstraintsWithSameLeftSide.java

@@ -1,9 +1,9 @@
 package de.dhbwstuttgart.bytecode.genericsGeneratorTypes;
 
-import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
-
 import java.util.List;
 
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+
 public class ConstraintsWithSameLeftSide {
 	private List<TPHConstraint> constraints;
 
@@ -32,4 +32,4 @@ public class ConstraintsWithSameLeftSide {
 	public String toString() {
 		return "[" + constraints.toString() + "]";
 	}
-}
+}

src/main/java/de/dhbwstuttgart/bytecode/genericsGeneratorTypes/GenericGenratorResultForSourceFile.java

@@ -7,6 +7,7 @@ import de.dhbwstuttgart.parser.scope.JavaClassName;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.NoSuchElementException;
 
 /**
  * The simplify results of a source file (package)
@@ -48,4 +49,4 @@ public class GenericGenratorResultForSourceFile {
 		}
 		return new GenericsGeneratorResultForClass(name);
 	}
-}
+}

src/main/java/de/dhbwstuttgart/bytecode/genericsGeneratorTypes/GenericsGeneratorResult.java

@@ -3,10 +3,10 @@
  */
 package de.dhbwstuttgart.bytecode.genericsGeneratorTypes;
 
-import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
-
 import java.util.Set;
 
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+
 /**
  * @author fayez
  *
@@ -56,4 +56,4 @@ public class GenericsGeneratorResult {
 	public String toString() {
 		return constraint.toString() + " EqualsTPS: " + equalsTPHs.toString();
 	}
-}
+}

src/main/java/de/dhbwstuttgart/bytecode/genericsGeneratorTypes/GenericsGeneratorResultForClass.java

@@ -9,6 +9,8 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 
+import com.google.common.collect.Lists;
+
 /**
  * @author fayez
  *
@@ -79,4 +81,4 @@ public class GenericsGeneratorResultForClass {
 		ret = ret + "\n" + methodsAndTheirConstraints.toString(); 
 		return ret;
 	}
-}
+}

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

@@ -2,73 +2,43 @@ package de.dhbwstuttgart.core;
 
 import java.io.File;
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
-
+import java.util.*;
 public class ConsoleInterface {
-    private static final String directory = System.getProperty("user.dir");
+	private static final String directory = System.getProperty("user.dir");
 
-    public static void main(String[] args) throws IOException, ClassNotFoundException {
-        List<File> input = new ArrayList<>();
-        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;
-        int runAsServerWithPort = -1;
-        String unificationServer = null;
-
-        Iterator<String> it = Arrays.asList(args).iterator();
-        if (args.length == 0) {
+		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\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"
-            );
+                    "\t-d\tSet destination directory");
             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 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 {
+            }else{
                 input.add(new File(arg));
             }
         }
-
-        if (runAsServerWithPort != -1) {
-            JavaTXServer server = new JavaTXServer(runAsServerWithPort);
-        }
-        else {
-            JavaTXCompiler compiler = new JavaTXCompiler(input, classpath, unificationServer);
-            //compiler.typeInference();
-            compiler.generateBytecode(outputPath);
-        }
-    }
+		JavaTXCompiler compiler = new JavaTXCompiler(input, classpath);
+		//compiler.typeInference();
+		compiler.generateBytecode(outputPath);
+	}
 
 
 }

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

@@ -9,42 +9,71 @@ import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.JavaTXParser;
 import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.antlr.Java8Parser.CompilationUnitContext;
-import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.server.SocketClient;
-import de.dhbwstuttgart.syntaxtree.*;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
+import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
+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.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.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.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.util.BiRelation;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
 import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultModelParallel;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
+import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
+
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
-import org.apache.commons.io.output.NullOutputStream;
+import java.sql.Timestamp;
 import java.util.*;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import org.apache.commons.io.output.NullOutputStream;
+
 
 public class JavaTXCompiler {
 
 	//public static JavaTXCompiler INSTANCE;
     final CompilationEnvironment environment;
-  	Boolean useResultModel = true;
-	  Optional<String> unificationServer = Optional.empty();
+	Boolean resultmodel = true;
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
     Boolean log = false; //gibt an ob ein Log-File nach System.getProperty("user.dir")+""/logFiles/"" geschrieben werden soll?
+    public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
     private final DirectoryClassLoader classLoader;
     static Writer statistics;
    
@@ -60,8 +89,8 @@ public class JavaTXCompiler {
 	}
     public JavaTXCompiler(List<File> sources, List<File> contextPath) throws IOException, ClassNotFoundException {
     	//statistics = new FileWriter(new File(System.getProperty("user.dir") + "/" + sources.get(0).getName() + "_"+ new Timestamp(System.currentTimeMillis())));
-		statistics = new OutputStreamWriter(new NullOutputStream());
-    	statistics.write("test");
+    	statistics = new OutputStreamWriter(new NullOutputStream());
+		statistics.write("test");
         if(contextPath == null || contextPath.isEmpty()){
         	//When no contextPaths are given, the working directory is the sources root
 			contextPath = Lists.newArrayList(new File(System.getProperty("user.dir")));
@@ -73,10 +102,6 @@ public class JavaTXCompiler {
         }
         //INSTANCE = this;
     }
-	public JavaTXCompiler(List<File> source, List<File> contextPath, String unificationServer) throws IOException, ClassNotFoundException {
-		this(source, contextPath);
-		this.unificationServer = unificationServer == null ? Optional.empty() : Optional.of(unificationServer);
-	}
 
     public ConstraintSet<Pair> getConstraints() throws ClassNotFoundException, IOException {
         List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
@@ -351,22 +376,10 @@ public class JavaTXCompiler {
 	 * }
 	 */
 
-	/**
-	 * TODO: can this be removed?
-	 *
-	 * @param resultListener
-	 * @param logFile
-	 * @return
-	 * @throws ClassNotFoundException
-	 * @throws IOException
-	 */
-	public UnifyResultModelParallel typeInferenceAsync(UnifyResultListener resultListener, Writer logFile)
+	public UnifyResultModel typeInferenceAsync(UnifyResultListener resultListener, Writer logFile)
 			throws ClassNotFoundException, IOException {
-
-		/*
-		 * Gather all available (imported) classes from all parsed source files for putting them into the finite closure
-		 */
 		List<ClassOrInterface> allClasses = new ArrayList<>();// environment.getAllAvailableClasses();
+		// Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
 		for (File f : this.sourceFiles.keySet()) {
 			SourceFile sf = sourceFiles.get(f);
 			allClasses.addAll(getAvailableClasses(sf));
@@ -374,68 +387,459 @@ public class JavaTXCompiler {
 			allClasses.addAll(CompilationEnvironment.loadDefaultPackageClasses(f,classLoader).stream().map(ASTFactory::createClass).collect(Collectors.toList()));
 		}
 
-		/*
-		 * Run the actual type inference process
-		 */
-		TypeInference typeInference = new TypeInference(
-				getConstraints(),
-				allClasses,
-				classLoader,
-      useResultModel,
-				log,
-				logFile,
-				statistics
-		);
-		return typeInference.executeAsync(resultListener);
+		final ConstraintSet<Pair> cons = getConstraints();
+		Set<Set<UnifyPair>> results = new HashSet<>();
+		UnifyResultModel urm = null;
+		// urm.addUnifyResultListener(resultListener);
+		try {
+			logFile = logFile == null
+					? new FileWriter(new File("log_" + sourceFiles.keySet().iterator().next().getName()))
+					: logFile;
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile, classLoader);
+			System.out.println(finiteClosure);
+			urm = new UnifyResultModel(cons, finiteClosure);
+			urm.addUnifyResultListener(resultListener);
+			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
+
+			Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
+				UnifyType lhs, rhs;
+				if (((lhs = x.getLhsType()) instanceof PlaceholderType)
+						&& ((rhs = x.getRhsType()) instanceof PlaceholderType)
+						&& (((PlaceholderType) lhs).isInnerType() || ((PlaceholderType) rhs).isInnerType())) {
+					((PlaceholderType) lhs).setInnerType(true);
+					((PlaceholderType) rhs).setInnerType(true);
+				}
+				return x;
+
+			};
+			logFile.write(unifyCons.toString());
+			unifyCons = unifyCons.map(distributeInnerVars);
+			logFile.write(unifyCons.toString());
+			TypeUnify unify = new TypeUnify();
+			// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
+			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
+			for (SourceFile sf : this.sourceFiles.values()) {
+				logFile.write(ASTTypePrinter.print(sf));
+			}
+			logFile.flush();
+
+			Set<String> methodParaTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream()
+					.map(y -> y.getParameterList().getFormalparalist().stream()
+							.filter(z -> z.getType() instanceof TypePlaceholder)
+							.map(z -> ((TypePlaceholder) z.getType()).getName())
+							.collect(Collectors.toCollection(HashSet::new)))
+					.reduce(new HashSet<String>(), (a, b) -> {
+						a.addAll(b);
+						return a;
+					}, (a, b) -> {
+						a.addAll(b);
+						return a;
+					})).reduce(new HashSet<String>(), (a, b) -> {
+						a.addAll(b);
+						return a;
+					});
+
+			Set<String> constructorParaTypeVarNames = allClasses.stream().map(x -> x.getConstructors().stream()
+					.map(y -> y.getParameterList().getFormalparalist().stream()
+							.filter(z -> z.getType() instanceof TypePlaceholder)
+							.map(z -> ((TypePlaceholder) z.getType()).getName())
+							.collect(Collectors.toCollection(HashSet::new)))
+					.reduce(new HashSet<String>(), (a, b) -> {
+						a.addAll(b);
+						return a;
+					}, (a, b) -> {
+						a.addAll(b);
+						return a;
+					})).reduce(new HashSet<String>(), (a, b) -> {
+						a.addAll(b);
+						return a;
+					});
+
+			Set<String> paraTypeVarNames = methodParaTypeVarNames;
+			paraTypeVarNames.addAll(constructorParaTypeVarNames);
+
+			Set<String> returnTypeVarNames = allClasses.stream()
+					.map(x -> x.getMethods().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
+							.map(z -> ((TypePlaceholder) z.getReturnType()).getName())
+							.collect(Collectors.toCollection(HashSet::new)))
+					.reduce((a, b) -> {
+						a.addAll(b);
+						return a;
+					}).get();
+
+			Set<String> fieldTypeVarNames = allClasses.stream()
+					.map(x -> x.getFieldDecl().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
+							.map(z -> ((TypePlaceholder) z.getReturnType()).getName())
+							.collect(Collectors.toCollection(HashSet::new)))
+					.reduce((a, b) -> {
+						a.addAll(b);
+						return a;
+					}).get();
+
+			returnTypeVarNames.addAll(fieldTypeVarNames);
+
+			unifyCons = unifyCons.map(x -> {
+				// Hier muss ueberlegt werden, ob
+				// 1. alle Argument- und Retuntyp-Variablen in allen UnifyPairs
+				// mit disableWildcardtable() werden.
+				// 2. alle Typvariablen mit Argument- oder Retuntyp-Variablen
+				// in Beziehung auch auf disableWildcardtable() gesetzt werden muessen
+				// PL 2018-04-23
+				if ((x.getLhsType() instanceof PlaceholderType)) {
+					if (paraTypeVarNames.contains(x.getLhsType().getName())) {
+						((PlaceholderType) x.getLhsType()).setVariance((byte) 1);
+						((PlaceholderType) x.getLhsType()).disableWildcardtable();
+					}
+					if (returnTypeVarNames.contains(x.getLhsType().getName())) {
+						((PlaceholderType) x.getLhsType()).setVariance((byte) -1);
+						((PlaceholderType) x.getLhsType()).disableWildcardtable();
+					}
+				}
+				if ((x.getRhsType() instanceof PlaceholderType)) {
+					if (paraTypeVarNames.contains(x.getRhsType().getName())) {
+						((PlaceholderType) x.getRhsType()).setVariance((byte) 1);
+						((PlaceholderType) x.getRhsType()).disableWildcardtable();
+					}
+					if (returnTypeVarNames.contains(x.getRhsType().getName())) {
+						((PlaceholderType) x.getRhsType()).setVariance((byte) -1);
+						((PlaceholderType) x.getRhsType()).disableWildcardtable();
+					}
+				}
+				return x;// HIER DIE JEWEILS RECHT BZW. LINKE SEITE AUF GLEICHE VARIANZ SETZEN WIE DIE
+							// JEWEILS ANDERE SEITE
+			});
+			Set<PlaceholderType> varianceTPHold;
+			Set<PlaceholderType> varianceTPH = new HashSet<>();
+			varianceTPH = varianceInheritanceConstraintSet(unifyCons);
+
+			/*
+			 * PL 2018-11-07 wird in varianceInheritanceConstraintSet erledigt do { //PL
+			 * 2018-11-05 Huellenbildung Variance auf alle TPHs der Terme auf der jeweiligen
+			 * //anderen Seite übertragen varianceTPHold = new HashSet<>(varianceTPH);
+			 * varianceTPH = varianceInheritanceConstraintSet(unifyCons); unifyCons.map( y
+			 * -> { if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType()
+			 * instanceof PlaceholderType)) { if
+			 * (((PlaceholderType)y.getLhsType()).getVariance() != 0 &&
+			 * ((PlaceholderType)y.getRhsType()).getVariance() == 0) {
+			 * ((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType(
+			 * )).getVariance()); } if (((PlaceholderType)y.getLhsType()).getVariance() == 0
+			 * && ((PlaceholderType)y.getRhsType()).getVariance() != 0) {
+			 * ((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType(
+			 * )).getVariance()); } } return y; } ); } while
+			 * (!varianceTPHold.equals(varianceTPH));
+			 */
+
+			// Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
+			// logFile, log);
+			// Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
+			List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints()/*.stream().map(x -> {
+				Set<Set<UnifyPair>> ret = new HashSet<>();
+				for (Constraint<UnifyPair> y : x) {
+					ret.add(new HashSet<>(y));
+				}
+				return ret;
+			}).collect(Collectors.toCollection(ArrayList::new))*/;
+			unify.unifyAsync(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm,
+					usedTasks);
+		} catch (IOException e) {
+			System.err.println("kein LogFile");
+		}
+		return urm;
 	}
 
 	public List<ResultSet> typeInference() throws ClassNotFoundException, IOException {
-
-		/*
-		 * Gather all available (imported) classes from all parsed source files for putting them into the finite closure
-		 */
 		List<ClassOrInterface> allClasses = new ArrayList<>();// environment.getAllAvailableClasses();
+		// Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
 		for (File f : this.sourceFiles.keySet()) {
 			SourceFile sf = sourceFiles.get(f);
 			allClasses.addAll(getAvailableClasses(sf));
 			allClasses.addAll(sf.getClasses());
-			allClasses.addAll(CompilationEnvironment.loadDefaultPackageClasses(f,classLoader).stream().map(ASTFactory::createClass).toList());
+			allClasses.addAll(CompilationEnvironment.loadDefaultPackageClasses(f,classLoader).stream().map(ASTFactory::createClass).collect(Collectors.toList()));
 		}
 
-		/*
-		 * Generate log file writer
-		 */
-		Writer logFile;
+		final ConstraintSet<Pair> cons = getConstraints();
+		Set<Set<UnifyPair>> results = new HashSet<>();
 		try {
-			// TODO: check if this makes sense and does not only always use the first source file key...
-			logFile = log ? new FileWriter(System.getProperty("user.dir") + "/logFiles/" + "log_" + sourceFiles.keySet().iterator().next().getName())
-					: new OutputStreamWriter(new NullOutputStream());
-		}
-		catch (IOException ioException) {
-			System.err.println("IO Exception: " + ioException.getMessage());
-			logFile = new OutputStreamWriter(new NullOutputStream());
-		}
+			Writer logFile = log ? new FileWriter(new File(System.getProperty("user.dir") + "/logFiles/" + "log_" + sourceFiles.keySet().iterator().next().getName()))
+					             : new OutputStreamWriter(new NullOutputStream());
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile, classLoader);
+			System.out.println(finiteClosure);
+			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(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;
 
-		/*
-		 * Run the actual type inference process
-		 */
-		TypeInference typeInference = new TypeInference(
-				getConstraints(),
-				allClasses,
-				classLoader,
-        useResultModel,
-				log,
-				logFile,
-				statistics
-		);
-    return typeInference.execute(this.unificationServer);
+			};
+			
+			logFile.write("Unify:" + unifyCons.toString());
+			System.out.println("Unify:" + unifyCons.toString());
+			unifyCons = unifyCons.map(distributeInnerVars);
+			logFile.write("\nUnify_distributeInnerVars: " + unifyCons.toString());
+			TypeUnify unify = new TypeUnify();
+			unify.statistics = statistics;
+			// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
+			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
+			for (SourceFile sf : this.sourceFiles.values()) {
+				logFile.write(ASTTypePrinter.print(sf));
+				System.out.println(ASTTypePrinter.print(sf));
+			}
+			logFile.flush();
+
+			Set<String> methodParaTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream()
+					.map(y -> y.getParameterList().getFormalparalist().stream()
+							.filter(z -> z.getType() instanceof TypePlaceholder)
+							.map(z -> ((TypePlaceholder) z.getType()).getName())
+							.collect(Collectors.toCollection(HashSet::new)))
+					.reduce(new HashSet<String>(), (a, b) -> {
+						a.addAll(b);
+						return a;
+					}, (a, b) -> {
+						a.addAll(b);
+						return a;
+					})).reduce(new HashSet<String>(), (a, b) -> {
+						a.addAll(b);
+						return a;
+					});
+
+			Set<String> constructorParaTypeVarNames = allClasses.stream().map(x -> x.getConstructors().stream()
+					.map(y -> y.getParameterList().getFormalparalist().stream()
+							.filter(z -> z.getType() instanceof TypePlaceholder)
+							.map(z -> ((TypePlaceholder) z.getType()).getName())
+							.collect(Collectors.toCollection(HashSet::new)))
+					.reduce(new HashSet<String>(), (a, b) -> {
+						a.addAll(b);
+						return a;
+					}, (a, b) -> {
+						a.addAll(b);
+						return a;
+					})).reduce(new HashSet<String>(), (a, b) -> {
+						a.addAll(b);
+						return a;
+					});
+
+			Set<String> paraTypeVarNames = methodParaTypeVarNames;
+			paraTypeVarNames.addAll(constructorParaTypeVarNames);
+
+			Set<String> returnTypeVarNames = allClasses.stream()
+					.map(x -> x.getMethods().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
+							.map(z -> ((TypePlaceholder) z.getReturnType()).getName())
+							.collect(Collectors.toCollection(HashSet::new)))
+					.reduce((a, b) -> {
+						a.addAll(b);
+						return a;
+					}).get();
+
+			Set<String> fieldTypeVarNames = allClasses.stream()
+					.map(x -> x.getFieldDecl().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
+							.map(z -> ((TypePlaceholder) z.getReturnType()).getName())
+							.collect(Collectors.toCollection(HashSet::new)))
+					.reduce((a, b) -> {
+						a.addAll(b);
+						return a;
+					}).get();
+
+			returnTypeVarNames.addAll(fieldTypeVarNames);
+
+			unifyCons = unifyCons.map(x -> {
+				// Hier muss ueberlegt werden, ob
+				// 1. alle Argument- und Retuntyp-Variablen in allen UnifyPairs
+				// mit disableWildcardtable() werden.
+				// 2. alle Typvariablen mit Argument- oder Retuntyp-Variablen
+				// in Beziehung auch auf disableWildcardtable() gesetzt werden muessen
+				// PL 2018-04-23
+				if ((x.getLhsType() instanceof PlaceholderType)) {
+					if (paraTypeVarNames.contains(x.getLhsType().getName())) {
+						((PlaceholderType) x.getLhsType()).setVariance((byte) 1);
+						((PlaceholderType) x.getLhsType()).disableWildcardtable();
+					}
+					if (returnTypeVarNames.contains(x.getLhsType().getName())) {
+						((PlaceholderType) x.getLhsType()).setVariance((byte) -1);
+						((PlaceholderType) x.getLhsType()).disableWildcardtable();
+					}
+				}
+				if ((x.getRhsType() instanceof PlaceholderType)) {
+					if (paraTypeVarNames.contains(x.getRhsType().getName())) {
+						((PlaceholderType) x.getRhsType()).setVariance((byte) 1);
+						((PlaceholderType) x.getRhsType()).disableWildcardtable();
+					}
+					if (returnTypeVarNames.contains(x.getRhsType().getName())) {
+						((PlaceholderType) x.getRhsType()).setVariance((byte) -1);
+						((PlaceholderType) x.getRhsType()).disableWildcardtable();
+					}
+				}
+				return x;// HIER DIE JEWEILS RECHT BZW. LINKE SEITE AUF GLEICHE VARIANZ SETZEN WIE DIE
+							// JEWEILS ANDERE SEITE
+			});
+			
+			//PL 2020-02-05 alle Oder-Constraints Receiver und Parameter werden auf variance 1 gesetzt
+			//Es wird davon ausgegangen, dass in OderConstraints in Bedingungen für Parameter die Typen der Argumente links stehen
+			//und die Typen der Rückgabewerte immer rechts stehen
+			
+			/*
+			unifyCons.getOderConstraints().forEach(z -> z.forEach(y -> y.forEach(x -> {
+				if ((x.getLhsType() instanceof PlaceholderType) && x.getPairOp().compareTo(PairOperator.SMALLERDOT) == 0) {
+					((PlaceholderType) x.getLhsType()).setVariance((byte)1);
+				}
+				else if ((x.getRhsType() instanceof PlaceholderType) && x.getPairOp().compareTo(PairOperator.EQUALSDOT) == 0) {
+					((PlaceholderType) x.getRhsType()).setVariance((byte)-1);
+				}
+				})));
+			*/
+			
+			System.out.println("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
+			Set<PlaceholderType> varianceTPHold;
+			Set<PlaceholderType> varianceTPH = new HashSet<>();
+			varianceTPH = varianceInheritanceConstraintSet(unifyCons);
+
+			/*
+			 * PL 2018-11-07 wird in varianceInheritanceConstraintSet erledigt do { //PL
+			 * 2018-11-05 Huellenbildung Variance auf alle TPHs der Terme auf der jeweiligen
+			 * //anderen Seite übertragen varianceTPHold = new HashSet<>(varianceTPH);
+			 * varianceTPH = varianceInheritanceConstraintSet(unifyCons); unifyCons.map( y
+			 * -> { if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType()
+			 * instanceof PlaceholderType)) { if
+			 * (((PlaceholderType)y.getLhsType()).getVariance() != 0 &&
+			 * ((PlaceholderType)y.getRhsType()).getVariance() == 0) {
+			 * ((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType(
+			 * )).getVariance()); } if (((PlaceholderType)y.getLhsType()).getVariance() == 0
+			 * && ((PlaceholderType)y.getRhsType()).getVariance() != 0) {
+			 * ((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType(
+			 * )).getVariance()); } } return y; } ); } while
+			 * (!varianceTPHold.equals(varianceTPH));
+			 */
+
+			// Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
+			// logFile, log);
+			// Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
+			List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints()//.stream().map(x -> {
+				/*Set<Set<UnifyPair>> ret = new HashSet<>();
+				for (Constraint<UnifyPair> y : x) {
+					ret.add(new HashSet<>(y));
+				}
+				return ret;
+			}).collect(Collectors.toCollection(ArrayList::new))*/;
+			if (resultmodel) {
+				/* UnifyResultModel Anfang */
+				UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
+				UnifyResultListenerImpl li = new UnifyResultListenerImpl();
+				urm.addUnifyResultListener(li);
+				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm,
+						usedTasks);
+				System.out.println("RESULT Final: " + li.getResults());
+				System.out.println("Constraints for Generated Generics: " + " ???");
+				logFile.write("RES_FINAL: " + li.getResults().toString() + "\n");
+				logFile.flush();
+				statistics.close();
+				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");
+		}
+		statistics.close();
+		return results.stream()
+				.map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons)))))
+				.collect(Collectors.toList());
+	}
+
+	/**
+	 * Vererbt alle Variancen bei Paaren (a <. theta) oder (Theta <. a) wenn a eine
+	 * Variance !=0 hat auf alle Typvariablen in Theta.
+	 * 
+	 *
+	 */
+	private Set<PlaceholderType> varianceInheritanceConstraintSet(ConstraintSet<UnifyPair> cons) {
+		Set<UnifyPair> eq = cons.getAll();
+		Set<PlaceholderType> usedTPH = new HashSet<>();
+		Set<PlaceholderType> phSet = eq.stream().map(x -> {
+			Set<PlaceholderType> pair = new HashSet<>();
+			if (x.getLhsType() instanceof PlaceholderType)
+				pair.add((PlaceholderType) x.getLhsType());
+			if (x.getRhsType() instanceof PlaceholderType)
+				pair.add((PlaceholderType) x.getRhsType());
+			return pair;
+		}).reduce(new HashSet<>(), (a, b) -> {
+			a.addAll(b);
+			return a;
+		}, (c, d) -> {
+			c.addAll(d);
+			return c;
+		});
+
+		ArrayList<PlaceholderType> phSetVariance = new ArrayList<>(phSet);
+		phSetVariance.removeIf(x -> (x.getVariance() == 0));
+		while (!phSetVariance.isEmpty()) {
+			PlaceholderType a = phSetVariance.remove(0);
+			usedTPH.add(a);
+			// HashMap<PlaceholderType,Integer> ht = new HashMap<>();
+			// ht.put(a, a.getVariance());
+			// ConstraintSet<UnifyPair> eq1 = cons;
+			// eq1.removeIf(x -> !(x.getLhsType() instanceof PlaceholderType &&
+			// ((PlaceholderType)x.getLhsType()).equals(a)));
+			// durch if-Abfrage im foreach geloest
+			cons.forEach(x -> {
+				if (x.getLhsType() instanceof PlaceholderType && ((PlaceholderType) x.getLhsType()).equals(a)) {
+					x.getRhsType().accept(new distributeVariance(), a.getVariance());
+				}
+			});
+			// ` eq1 = new HashSet<>(eq);
+			// eq1.removeIf(x -> !(x.getRhsType() instanceof PlaceholderType &&
+			// ((PlaceholderType)x.getRhsType()).equals(a)));
+			// durch if-Abfrage im foreach geloest
+			cons.forEach(x -> {
+				if (x.getRhsType() instanceof PlaceholderType && ((PlaceholderType) x.getRhsType()).equals(a)) {
+					x.getLhsType().accept(new distributeVariance(), a.getVariance());
+				}
+			});
+			phSetVariance = new ArrayList<>(phSet); // macht vermutlich keinen Sinn PL 2018-10-18, doch, es koennen neue
+													// TPHs mit Variancen dazugekommen sein PL 2018-11-07
+			phSetVariance.removeIf(x -> (x.getVariance() == 0 || usedTPH.contains(x)));
+		}
+		return usedTPH;
 	}
 
 	private SourceFile parse(File sourceFile) throws IOException, java.lang.ClassNotFoundException {
 		CompilationUnitContext tree = JavaTXParser.parse(sourceFile);
 		SyntaxTreeGenerator generator = new SyntaxTreeGenerator(environment.getRegistry(sourceFile, classLoader),
 				new GenericsRegistry(null));
-        return generator.convert(tree, environment.packageCrawler, classLoader);
+		SourceFile ret = generator.convert(tree, environment.packageCrawler, classLoader);
+		return ret;
 	}
 
 

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

@@ -1,15 +0,0 @@
-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,22 +1,21 @@
 package de.dhbwstuttgart.environment;
 
-import com.google.common.collect.Lists;
-import de.dhbwstuttgart.exceptions.DebugException;
-import de.dhbwstuttgart.parser.JavaTXParser;
-import de.dhbwstuttgart.parser.antlr.Java8Parser.CompilationUnitContext;
-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;
+import java.util.*;
+
+import com.google.common.collect.Lists;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+import de.dhbwstuttgart.exceptions.DebugException;
+import de.dhbwstuttgart.parser.JavaTXParser;
+import de.dhbwstuttgart.parser.antlr.Java8Parser.CompilationUnitContext;
+import de.dhbwstuttgart.parser.scope.GatherNames;
+import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 
 /**
  * Stellt die Java-Environment dar und speichert alle Binarys, Librarys und Sourcefiles im zu kompilierenden Projekt
@@ -107,4 +106,4 @@ public class CompilationEnvironment {
 		return ret;
 	}
 
-}
+}

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

@@ -1,9 +1,12 @@
 package de.dhbwstuttgart.environment;
 
 import java.io.File;
+import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -33,4 +36,4 @@ public class DirectoryClassLoader extends URLClassLoader implements IByteArrayCl
     public Class _defineClass(String name, byte[] code, int i, int length) throws ClassFormatError {
         return defineClass(name, code, i, length);
     }
-}
+}

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

@@ -1,16 +1,16 @@
 package de.dhbwstuttgart.environment;
 
+import java.net.URL;
+import java.util.*;
+
 import org.reflections.Reflections;
 import org.reflections.scanners.ResourcesScanner;
 import org.reflections.scanners.SubTypesScanner;
 import org.reflections.util.ConfigurationBuilder;
 import org.reflections.util.FilterBuilder;
 
-import java.net.URL;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import org.reflections.vfs.SystemDir;
 
 /**
  * Hilft beim Durchsuchen von Packages
@@ -74,4 +74,4 @@ public class PackageCrawler {
     }
     return nameList;
   }
-}
+}

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

@@ -1,14 +1,19 @@
 package de.dhbwstuttgart.parser;
 
+import de.dhbwstuttgart.environment.CompilationEnvironment;
+import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.antlr.Java8Lexer;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
+import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+
 import org.antlr.v4.runtime.ANTLRInputStream;
 import org.antlr.v4.runtime.CommonTokenStream;
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
 
 public class JavaTXParser {	
     public static Java8Parser.CompilationUnitContext parse(File source) throws IOException, java.lang.ClassNotFoundException {
@@ -29,4 +34,4 @@ public class JavaTXParser {
         return this.parse(new ByteArrayInputStream(fileContent.getBytes(StandardCharsets.UTF_8)));
     }
     */
-}
+}

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

@@ -2,6 +2,7 @@ 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 {
@@ -16,4 +17,4 @@ public class AssignToLocal extends AssignLeftSide {
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -8,12 +8,13 @@ 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.PairOperator;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import de.dhbwstuttgart.typeinference.unify.model.*;
 
 import java.util.*;
 import java.util.stream.Collectors;
 
+import org.antlr.v4.runtime.Token;
+
 public class FCGenerator {
     /**
      * Baut die FiniteClosure aus availableClasses.
@@ -173,4 +174,4 @@ public class FCGenerator {
         }
 
     }
-}
+}

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

@@ -5,12 +5,14 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
-import de.dhbwstuttgart.syntaxtree.ParameterList;
+import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
+import de.dhbwstuttgart.syntaxtree.statement.UnaryExpr.Operation;
 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 org.antlr.v4.runtime.tree.TerminalNode;
 
@@ -974,4 +976,4 @@ public class StatementGenerator {
         		//funNParams, name.getStart());
         return new LambdaExpression(lambdaType, params, block, expression.getStart());
     }
-}
+}

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

@@ -1,11 +1,10 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
-import de.dhbwstuttgart.syntaxtree.statement.Block;
-import de.dhbwstuttgart.syntaxtree.statement.Return;
-import de.dhbwstuttgart.syntaxtree.statement.ReturnVoid;
-import de.dhbwstuttgart.syntaxtree.statement.Statement;
+import de.dhbwstuttgart.syntaxtree.Constructor;
+import de.dhbwstuttgart.syntaxtree.statement.*;
 
 import java.util.List;
 
@@ -41,4 +40,4 @@ public class SyntacticSugar {
         return false;
     }
 
-}
+}

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

@@ -2,7 +2,10 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
 import de.dhbwstuttgart.environment.PackageCrawler;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
+import java.lang.ClassNotFoundException;
+
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
+import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
 import de.dhbwstuttgart.parser.scope.GatherNames;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
@@ -10,19 +13,22 @@ import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import de.dhbwstuttgart.syntaxtree.statement.Block;
-import de.dhbwstuttgart.syntaxtree.statement.Statement;
+import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
+import java.lang.reflect.Modifier;
+import java.net.URL;
+import java.sql.Ref;
+import java.util.*;
+import java.util.stream.Collectors;
+
+//import jdk.internal.dynalink.support.TypeConverterFactory;
 import org.antlr.v4.runtime.CommonToken;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.tree.TerminalNode;
 
-import java.lang.reflect.Modifier;
-import java.util.*;
-import java.util.stream.Collectors;
-
 public class SyntaxTreeGenerator{
   private JavaClassRegistry reg;
   private final GenericsRegistry globalGenerics;
@@ -507,4 +513,4 @@ public class SyntaxTreeGenerator{
   }
 
 
-}
+}

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

@@ -2,14 +2,21 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
+import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
+import de.dhbwstuttgart.parser.antlr.Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 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.*;
+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 org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;
@@ -213,4 +220,4 @@ public class TypeGenerator {
         if(ctx.classOrInterfaceType() != null)throw new NotImplementedException();
         return convertTypeName(ctx.Identifier().getText(), ctx.typeArguments(), ctx.getStart(), reg, generics);
     }
-}
+}

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

@@ -1,11 +1,17 @@
 package de.dhbwstuttgart.parser.scope;
 
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.*;
+
+import de.dhbwstuttgart.parser.antlr.Java8BaseListener;
+import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
+import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
 import de.dhbwstuttgart.environment.PackageCrawler;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
-import org.antlr.v4.runtime.tree.TerminalNode;
-
-import java.util.HashMap;
-import java.util.Map;
 
 public class GatherNames {
 

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

@@ -2,10 +2,7 @@ package de.dhbwstuttgart.parser.scope;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 /**
  * Speichert die Klassen f<>r einen bestimmten Projektscope
@@ -49,4 +46,4 @@ public class JavaClassRegistry {
     public int getNumberOfGenerics(String name) {
         return existingClasses.get(new JavaClassName(name));
     }
-}
+}

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

@@ -1,138 +0,0 @@
-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
-  ) throws JsonProcessingException {
-    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();
-    }
-
-    // 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2,6 +2,7 @@ package de.dhbwstuttgart.syntaxtree;
 
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.statement.*;
+import de.dhbwstuttgart.syntaxtree.statement.Literal;
 import de.dhbwstuttgart.syntaxtree.type.*;
 
 import java.util.Iterator;
@@ -265,4 +266,4 @@ public abstract class AbstractASTWalker implements ASTVisitor{
     public void visit(SuperCall superCall) {
         this.visit((MethodCall)superCall);
     }
-}
+}

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

@@ -1,11 +1,18 @@
 package de.dhbwstuttgart.syntaxtree;
 
+import de.dhbwstuttgart.core.IItemWithOffset;
+import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
 
 import java.lang.reflect.Modifier;
@@ -157,4 +164,4 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
   public String toString() {
 	  return this.name.toString() + this.genericClassParameters.toString();
   }
-}
+}

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

@@ -1,11 +1,13 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
 import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import org.antlr.v4.runtime.Token;
 
+import de.dhbwstuttgart.syntaxtree.statement.Block;
+
 import java.util.List;
 
 public class Constructor extends Method {
@@ -34,4 +36,4 @@ public class Constructor extends Method {
 	public void accept(ASTVisitor visitor) {
 		visitor.visit(this);
 	}
-}
+}

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

@@ -1,9 +1,10 @@
 package de.dhbwstuttgart.syntaxtree;
 
 import de.dhbwstuttgart.syntaxtree.statement.Expression;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import org.antlr.v4.runtime.Token;
 
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+
 /**
  * Eine Feldinitialisation steht für eine Felddeklaration mit gleichzeitiger Wertzuweisung
  * Beispiel: 'public Feld FeldVar = FeldWert;'
@@ -24,4 +25,4 @@ public class FieldDeclaration extends Field{
     }
 
 
-}
+}

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

@@ -1,11 +1,12 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import com.google.common.collect.Lists;
 import org.antlr.v4.runtime.Token;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
+import com.google.common.collect.Lists;
+
+import de.dhbwstuttgart.parser.NullToken;
+
+import java.util.*;
 
 
 /**
@@ -48,4 +49,4 @@ public class GenericDeclarationList extends SyntaxTreeNode implements Iterable<G
 	public String toString() {
 		return this.gtvs.toString();
 	}
-}
+}

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

@@ -1,6 +1,7 @@
 package de.dhbwstuttgart.syntaxtree;
 
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;
@@ -60,4 +61,4 @@ public class GenericTypeVar extends SyntaxTreeNode
     public void accept(ASTVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -1,13 +1,18 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import de.dhbwstuttgart.core.IItemWithOffset;
+import java.util.ArrayList;
+
 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 java.util.ArrayList;
+import de.dhbwstuttgart.core.IItemWithOffset;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
 
 /**
  * Stellt eine Methode dar. Problem: Parser kann nicht zwischen Methode und
@@ -88,4 +93,4 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 	public String getName() {
 		return name;
 	}
-}
+}

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

@@ -1,12 +1,11 @@
 package de.dhbwstuttgart.syntaxtree;
+import java.io.File;
+import java.util.*;
 
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 //import sun.security.x509.X509CertInfo;
 
 
@@ -57,4 +56,4 @@ public class SourceFile extends SyntaxTreeNode{
   public void accept(ASTVisitor visitor) {
     visitor.visit(this);
   }
-}
+}

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

@@ -1,6 +1,10 @@
 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;
 
@@ -16,4 +20,4 @@ public abstract class SyntaxTreeNode implements IItemWithOffset{
     }
 
     public abstract void accept(ASTVisitor visitor);
-}
+}

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

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

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

@@ -1,20 +1,29 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
+import java.lang.reflect.*;
+import java.lang.reflect.Constructor;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.Field;
 import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
-import de.dhbwstuttgart.syntaxtree.type.Void;
-import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.syntaxtree.type.WildcardType;
 import org.antlr.v4.runtime.Token;
 
-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,

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

@@ -1,27 +1,30 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
+import java.io.FileWriter;
+import java.io.Writer;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.syntaxtree.type.WildcardType;
-import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.result.*;
+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;
 import de.dhbwstuttgart.typeinference.unify.model.*;
 
-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<>(); 
@@ -280,4 +283,4 @@ public class UnifyTypeFactory {
         return ret;
     }
 
-}
+}

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

@@ -2,6 +2,9 @@
 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;
 
 /*
@@ -23,4 +26,4 @@ public class Assign extends Statement
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
+import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import org.antlr.v4.runtime.Token;
 
@@ -8,4 +9,4 @@ public abstract class AssignLeftSide extends TypableStatement{
     public AssignLeftSide(RefTypeOrTPHOrWildcardOrGeneric type, Token offset) {
         super(type, offset);
     }
-}
+}

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

@@ -1,12 +1,12 @@
 package de.dhbwstuttgart.syntaxtree.statement;
+import java.util.*;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import org.antlr.v4.runtime.Token;
 
-import java.util.ArrayList;
-import java.util.List;
-
 
 public class Block extends Statement
 {
@@ -28,4 +28,6 @@ public class Block extends Statement
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}
+
+

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

@@ -1,7 +1,10 @@
 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;
 
 
@@ -19,4 +22,4 @@ public class CastExpr extends Expression
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -1,6 +1,7 @@
 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
@@ -14,4 +15,4 @@ public class DoStmt extends WhileStmt
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -2,6 +2,9 @@ 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;
 
 
@@ -16,4 +19,4 @@ public class EmptyStmt extends Statement
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -1,7 +1,12 @@
 
 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
@@ -9,4 +14,4 @@ public abstract class Expression extends TypableStatement
     public Expression(RefTypeOrTPHOrWildcardOrGeneric type, Token offset){
         super(type, offset);
     }
-}
+}

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

@@ -1,6 +1,8 @@
 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
 {
@@ -16,4 +18,4 @@ public class ExpressionReceiver extends Receiver
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -1,9 +1,18 @@
 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;
@@ -19,4 +28,4 @@ public class FieldVar extends Expression {
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -1,7 +1,10 @@
 
 package de.dhbwstuttgart.syntaxtree.statement;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 
 public class ForStmt extends Statement
 {

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

@@ -2,6 +2,9 @@ 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;
 
 
@@ -24,4 +27,4 @@ public class IfStmt extends Statement
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -3,8 +3,10 @@ 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,11 +1,14 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
-import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.ParameterList;
-import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.TypeScope;
+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.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;
 
@@ -36,4 +39,4 @@ public class LambdaExpression extends Expression implements TypeScope {
 		//return type.getParaList().get(0);
 		return methodBody.getType();
 	}
-}
+}

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

@@ -2,7 +2,10 @@ 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
@@ -18,4 +21,4 @@ public class Literal extends Expression
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -1,8 +1,11 @@
 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;
 
 
@@ -25,4 +28,4 @@ public class LocalVarDecl extends Statement
     public String getName() {
         return name;
     }
-}
+}

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

@@ -1,10 +1,20 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
-import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.exceptions.TypeinferenceException;
+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.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 java.util.ArrayList;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
+import java.util.*;
 
 
 public class MethodCall extends Statement
@@ -38,4 +48,4 @@ public class MethodCall extends Statement
     public ArgumentList getArgumentList() {
         return arglist;
     }
-}
+}

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

@@ -1,9 +1,11 @@
 package de.dhbwstuttgart.syntaxtree.statement;
+import java.util.List;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-
-import java.util.List;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 
 
 public class NewArray extends Expression
@@ -19,4 +21,4 @@ public class NewArray extends Expression
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -1,11 +1,24 @@
 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;
+import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
+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 de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import org.antlr.v4.runtime.Token;
-
-import java.util.ArrayList;
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 
 
 public class NewClass extends MethodCall
@@ -26,4 +39,4 @@ public class NewClass extends MethodCall
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -3,6 +3,9 @@ package de.dhbwstuttgart.syntaxtree.statement;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
+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 StaticClassName extends Receiver {
@@ -14,4 +17,4 @@ public class StaticClassName extends Receiver {
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -1,7 +1,11 @@
 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.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 
 public class Super extends Expression
 {
@@ -14,4 +18,4 @@ public class Super extends Expression
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

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

@@ -1,10 +1,13 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import org.antlr.v4.runtime.Token;
 
+import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
+
 import java.util.ArrayList;
 
 
@@ -25,4 +28,4 @@ public class SuperCall extends MethodCall
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}