Implement first version of Unify2 with simple test

.gitignore

@@ -29,4 +29,3 @@ logFiles/**
 
 src/main/java/de/dhbwstuttgart/parser/antlr/
 src/main/java/de/dhbwstuttgart/sat/asp/parser/antlr/
-/pull.sh

pom.xml

@@ -118,7 +118,15 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 					</descriptorRefs>
 				</configuration>
 			</plugin>
-		</plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>9</source>
+                    <target>9</target>
+                </configuration>
+            </plugin>
+        </plugins>
 	</build>
 	<repositories>
 		<repository>

src/main/java/de/dhbwstuttgart/bytecode/insertGenerics/FamilyOfGeneratedGenerics.java

@@ -5,7 +5,6 @@ import de.dhbwstuttgart.bytecode.TPHExtractor;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
 import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -17,15 +16,13 @@ public class FamilyOfGeneratedGenerics {
     public HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTPHs = new HashMap<>();
     public List<ClassConstraint> classConstraints = new ArrayList<>();
     public List<MethodConstraint> methodConstraints = new ArrayList<>();
-    public HashMap<MethodConstraint, String> methodsWithPosition = new HashMap<>();
 
 
     public FamilyOfGeneratedGenerics(TPHExtractor tphExtractor) {
         this.allConstraints = tphExtractor.allCons;
         this.posOfTPHs = positionConverter(tphExtractor.allTPHS, tphExtractor.ListOfMethodsAndTph);
         this.classConstraints = getClassConstraints(allConstraints,posOfTPHs);
-//        this.methodConstraints = getMethodConstraints(allConstraints,classConstraints,posOfTPHs);
-
+//        this.methodConstraints =
     }
 
     public static List<ClassConstraint> getClassConstraints(List<TPHConstraint> cs, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) { //Inputparameter List<TPHConstraint> constraintsSet weg
@@ -51,44 +48,38 @@ public class FamilyOfGeneratedGenerics {
         return cs_cl;
     }
 
-//    public static List<MethodConstraint> getMethodConstraints(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
-//        //TODO: Regeln
-//        List<MethodConstraint> cs_m = new ArrayList<>();
-//        List<MethodConstraint> methodConstraints1 = typeOfTheMethodInClSigma(cs, posOfTphs);
-//        for (MethodConstraint cons: methodConstraints1) {
-//            if (!checkForDuplicates(cons, cs_m)) {
-//                cs_m.add(cons);
-//            }
-//        }
-//        List<MethodConstraint> methodConstraints2 = firstTransitiveSubtypeForMethodTypes(cs, cs_m);
-//        for (MethodConstraint cons: methodConstraints2) {
-//            if (!checkForDuplicates(cons, cs_m)) {
-//                cs_m.add(cons);
-//            }
-//        }
-//        List<MethodConstraint> methodConstraints3 = secondTransitiveSubtypeForMethodTypes(cs, cs_cl, cs_m);
-//        for (MethodConstraint cons: methodConstraints3) {
-//            if (!checkForDuplicates(cons, cs_m)) {
-//                cs_m.add(cons);
-//            }
-//        }
-//        List<MethodConstraint> methodConstraints4 = hasNoSupertypeForMethodTypes(cs, posOfTphs);
-//        for (MethodConstraint cons: methodConstraints4) {
-//            if (!checkForDuplicates(cons, cs_m)) {
-//                cs_m.add(cons);
-//            }
-//        }
-//        List<MethodConstraint> methodConstraints5 = methodTypesWithoutClassTypes(cs_cl, cs_m);
-//        cs_m = methodConstraints5;
-//        return cs_m;
-//    }
-
-    public static HashMap<MethodConstraint, String> getMethodConstraints(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
-        throw new NotImplementedException();
+    public static List<MethodConstraint> getMethodConstraints(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
+        //TODO: Regeln
+        List<MethodConstraint> cs_m = new ArrayList<>();
+        List<MethodConstraint> methodConstraints1 = typeOfTheMethodInClSigma(cs, posOfTphs);
+        for (MethodConstraint cons: methodConstraints1) {
+            if (!checkForDuplicates(cons, cs_m)) {
+                cs_m.add(cons);
+            }
+        }
+        List<MethodConstraint> methodConstraints2 = firstTransitiveSubtypeForMethodTypes(cs, cs_m);
+        for (MethodConstraint cons: methodConstraints2) {
+            if (!checkForDuplicates(cons, cs_m)) {
+                cs_m.add(cons);
+            }
+        }
+        List<MethodConstraint> methodConstraints3 = secondTransitiveSubtypeForMethodTypes(cs, cs_cl, cs_m);
+        for (MethodConstraint cons: methodConstraints3) {
+            if (!checkForDuplicates(cons, cs_m)) {
+                cs_m.add(cons);
+            }
+        }
+        List<MethodConstraint> methodConstraints4 = hasNoSupertypeForMethodTypes(cs, posOfTphs);
+        for (MethodConstraint cons: methodConstraints4) {
+            if (!checkForDuplicates(cons, cs_m)) {
+                cs_m.add(cons);
+            }
+        }
+        List<MethodConstraint> methodConstraints5 = methodTypesWithoutClassTypes(cs_cl, cs_m);
+        cs_m = methodConstraints5;
+        return cs_m;
     }
 
-
-
     /**
      * Def. FGG: erste Zeile von cs_cl
      * {T < .T' | T is a type variable in a type of a node of a field}
@@ -164,16 +155,16 @@ public class FamilyOfGeneratedGenerics {
      * Def. FGG: erste Zeile von cs_m
      * {T < .T' | T is a type variable in a type of the method/constructor m in cl_\sigma, (T <. T') \in cs}
      */
-    public static HashMap<MethodConstraint, String> typeOfTheMethodInClSigma(List<TPHConstraint> allConstraints, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) { // cl_\sigma??
+    public static List<MethodConstraint> typeOfTheMethodInClSigma(List<TPHConstraint> allConstraints, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) { // cl_\sigma??
         //TODO:
-        HashMap<MethodConstraint, String> tempMC= new HashMap<>();
+        List<MethodConstraint> tempMC= new ArrayList<>();
         for(TPHConstraint allCons: allConstraints){
             if(posOfTphs.containsKey(allCons.getLeft()) && allCons.getRight()!=null && allCons.getRel()==Relation.EXTENDS) {
                 for(String tph: posOfTphs.keySet()) {
                     if(tph == allCons.getLeft() && (posOfTphs.get(tph).fst == PositionFinder.Position.METHOD || posOfTphs.get(tph).fst == PositionFinder.Position.CONSTRUCTOR)) {
                         MethodConstraint consToAdd = new MethodConstraint(allCons.getLeft(), allCons.getRight(), allCons.getRel());
-                        if (!checkForDuplicatesInMethods(consToAdd, tempMC, posOfTphs)) {
-                            tempMC.put(consToAdd, posOfTphs.get(tph).snd);
+                        if (!checkForDuplicates(consToAdd, tempMC)) {
+                            tempMC.add(consToAdd);
                         }
                     }
                 }
@@ -183,6 +174,112 @@ public class FamilyOfGeneratedGenerics {
     }
 
 
+    /**
+     * Def. FGG: zweite Zeile von cs_m
+     * {R' <. S | (R <. R'), (S <. S') \in cs_m and (R',S) is in the transitive closure of cs}
+     */
+    public static List<MethodConstraint> firstTransitiveSubtypeForMethodTypes(List<TPHConstraint> allConstraints, List<MethodConstraint> cs_m) { //transitive closure of cs
+        //TODO:
+        List<MethodConstraint> tempMC= new ArrayList<>();
+        List<TPHConstraint> tcOfCs =  buildTransitiveClosure(allConstraints);
+        for(MethodConstraint mC1 : cs_m) {          //(R <. R')
+            for(MethodConstraint mC2 : cs_m) {      //(S <. S')
+                String lSide = mC1.getRight();      //R'
+                String rSide = mC2.getLeft();       //S
+                for(TPHConstraint tphC : tcOfCs) {
+                    if(tphC.getLeft().equals(lSide)&&tphC.getRight().equals(rSide)) { //is it (R',S)
+                        MethodConstraint consToAdd = new MethodConstraint(lSide, rSide, tphC.getRel()); //create (R'<.S)
+                        if (!checkForDuplicates(consToAdd, tempMC)) {
+                            tempMC.add(consToAdd);
+                        }
+                    }
+                }
+            }
+        }
+        return tempMC;
+    }
+
+    /**
+     * Def. FGG: dritte Zeile von cs_m
+     * {R' <. S | (R <. R') \in cs_m, (S <. S') \in cs_cl and (R',S) is in the transitive closure of cs}
+     */
+    public static List<MethodConstraint> secondTransitiveSubtypeForMethodTypes(List<TPHConstraint> allConstraints, List<ClassConstraint> cs_cl, List<MethodConstraint> cs_m) {
+        //TODO:
+        List<MethodConstraint> tempMC= new ArrayList<>();
+        List<TPHConstraint> tcOfCs =  buildTransitiveClosure(allConstraints);
+        for(ClassConstraint cC : cs_cl) {
+            for(MethodConstraint mC : cs_m) {
+                String leftSide = mC.getRight();
+                String rightSide = cC.getLeft();
+                for(TPHConstraint tphC : tcOfCs) {
+                    if(tphC.getLeft().equals(leftSide)&&tphC.getRight().equals(rightSide)) {
+                        MethodConstraint consToAdd = new MethodConstraint(tphC.getLeft(), tphC.getRight(), tphC.getRel());
+                        if (!checkForDuplicates(consToAdd, tempMC)) {
+                            tempMC.add(consToAdd);
+                            System.out.println(consToAdd);
+                        }
+
+                    }
+                }
+            }
+        }
+        return tempMC;
+    }
+
+/**
+     * Def. FGG: vierte Zeile von cs_m
+     * {T <. Object | (T is a type variable in a type of a node of the method/constructor m in cl_\sigma),
+     *                  (\existsnot T': T <. T') \in cs)}
+     */
+    public static List<MethodConstraint> hasNoSupertypeForMethodTypes(List<TPHConstraint> allConstraints, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
+        //TODO:
+        List<MethodConstraint> tempMC= new ArrayList<>();
+        for(String tph: posOfTphs.keySet()) {
+            for(TPHConstraint allCons: allConstraints) {
+                if((posOfTphs.get(tph).fst.equals(PositionFinder.Position.METHOD) || posOfTphs.get(tph).fst.equals(PositionFinder.Position.CONSTRUCTOR)) && checkUpperBound(allConstraints,tph)) {
+                    MethodConstraint consToAdd = new MethodConstraint(tph, "Object", Relation.EXTENDS);
+                    if (!checkForDuplicates(consToAdd, tempMC)) {
+                        tempMC.add(consToAdd);
+                        System.out.println(consToAdd);
+                    }
+                }
+            }
+        }
+        return tempMC;
+    }
+
+/**
+     * nimm die Menge cs_cl aus cs_m raus
+     */
+    public static List<MethodConstraint> methodTypesWithoutClassTypes(List<ClassConstraint> cs_cl, List<MethodConstraint> cs_m) {
+        //TODO:
+        List<TPHConstraint> tempCC = new ArrayList<>();
+        for(ClassConstraint cc: cs_cl) {
+            TPHConstraint tphC = new TPHConstraint(cc.getLeft(), cc.getRight(), cc.getRel());
+            tempCC.add(tphC);
+        }
+        List<TPHConstraint> tempMC = new ArrayList<>();
+        for(MethodConstraint mc: cs_m) {
+            TPHConstraint tphC = new TPHConstraint(mc.getLeft(), mc.getRight(), mc.getRel());
+            tempMC.add(tphC);
+        }
+        List<TPHConstraint> tempMC2 = new ArrayList<>();
+        tempMC2.addAll(tempMC);
+        List<MethodConstraint> tempMCToReturn = new ArrayList<>();
+
+        for(TPHConstraint cc: tempCC) {
+            for(TPHConstraint mc: tempMC) {
+                if(cc.getLeft().equals(mc.getLeft()) && cc.getRight().equals(mc.getRight())) {
+                    tempMC2.remove(mc);
+                }
+            }
+        }
+        for(TPHConstraint tphC: tempMC2) {
+            MethodConstraint mCons = new MethodConstraint(tphC.getLeft(), tphC.getRight(), tphC.getRel());
+            tempMCToReturn.add(mCons);
+        }
+        return tempMCToReturn;
+    }
 
     public static boolean checkForDuplicates(TPHConstraint constraint, List list) {
         List<TPHConstraint> tempList = list;
@@ -197,10 +294,6 @@ public class FamilyOfGeneratedGenerics {
         return false;
     }
 
-    public static boolean checkForDuplicatesInMethods(TPHConstraint constraint, HashMap<MethodConstraint, String> hashMap, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
-        throw new NotImplementedException();
-    }
-
     public static List<TPHConstraint> buildTransitiveClosure(List list) {
         List<TPHConstraint> iterList = new ArrayList<>(list);
         List<TPHConstraint> runList = new ArrayList<>(list);

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

@@ -1,25 +1,7 @@
 //PL 2018-12-19: typeInferenceOld nach typeInference uebertragen
 package de.dhbwstuttgart.core;
 
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.Writer;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
 import com.google.common.collect.Lists;
-
 import de.dhbwstuttgart.bytecode.BytecodeGen;
 import de.dhbwstuttgart.bytecode.Exception.BytecodeGeneratorError;
 import de.dhbwstuttgart.bytecode.genericsGenerator.GeneratedGenericsFinder;
@@ -29,19 +11,21 @@ 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.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
-import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.TypeScope;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
+import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
@@ -57,17 +41,32 @@ 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.TypeUnifyTask;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
-import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
 import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
+import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+import java.io.OutputStreamWriter;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import org.antlr.v4.runtime.Token;
+import org.apache.commons.io.output.NullOutputStream;
 
 
 public class JavaTXCompiler {
@@ -75,13 +74,12 @@ public class JavaTXCompiler {
 	//public static JavaTXCompiler INSTANCE;
     final CompilationEnvironment environment;
 	Boolean resultmodel = true;
-	// TODO change the AST for replace generics with TPH
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
     Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"src/test/java/logFiles" geschrieben werden soll?
     public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
     private final ClassLoader classLoader;
 
-	public JavaTXCompiler (File... sourceFile) throws IOException, ClassNotFoundException {
+	public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
 		this(Arrays.asList(sourceFile), null);
 	}
     public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
@@ -104,10 +102,6 @@ public class JavaTXCompiler {
         //INSTANCE = this;
     }
 
-	public Map<File, SourceFile> getSourceFiles () {
-		return sourceFiles;
-	}
-
     public ConstraintSet<Pair> getConstraints() throws ClassNotFoundException, IOException {
         List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
         List<ClassOrInterface> importedClasses = new ArrayList<>();
@@ -126,11 +120,11 @@ public class JavaTXCompiler {
 				importedClasses.add(importedClass);
 			}
         }
-		for (File f : this.sourceFiles.keySet()) {
+        for (File f : this.sourceFiles.keySet()) {
 			SourceFile sf = sourceFiles.get(f);
 			sf = new SourceFile(sf.getPkgName(),
 					       sf.KlassenVektor.stream()
-							.map(ClassOrInterface::new)
+										   .map(cl -> new ClassOrInterface(cl))
 							               .collect(Collectors.toCollection(ArrayList::new)),
 						   sf.imports);
 			//sf enthaelt neues Source-File, neue Klassen-Objekte und neue 
@@ -615,7 +609,7 @@ public class JavaTXCompiler {
 					});
 
 			Set<String> constructorParaTypeVarNames = allClasses.stream().map(x -> x.getConstructors().stream()
-					.filter(y -> y != null).map(y -> y.getParameterList().getFormalparalist().stream()
+					.map(y -> y.getParameterList().getFormalparalist().stream()
 							.filter(z -> z.getType() instanceof TypePlaceholder)
 							.map(z -> ((TypePlaceholder) z.getType()).getName())
 							.collect(Collectors.toCollection(HashSet::new)))

src/main/java/de/dhbwstuttgart/inferWildcards/ConstraintsGenerationUtils.java

@@ -1,132 +0,0 @@
-package de.dhbwstuttgart.inferWildcards;
-
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-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;
-
-/**
- * Utilities to generate the constraints for the infer wildcards algorithm.
- * 
- * @author Till Schnell
- * @version 1.0
- */
-public final class ConstraintsGenerationUtils
-{
-
-	private ConstraintsGenerationUtils () {
-		throw new AssertionError("No ConstraintsGenerationUtils instance for you");
-	}
-
-	/**
-	 * Generate the constraints for a map of type placeholder and RefType and merge
-	 * these to the already provided constraints.
-	 * 
-	 * @param tphMap      {@link Map} of {@link TypePlaceholder} and
-	 *                    {@link RefTypeOrTPHOrWildcardOrGeneric}
-	 * @param constraints {@link ConstraintSet} over {@link Pair} to merge to
-	 * @return The same instance {@code constraints} provided including the merged
-	 *         constraints
-	 */
-	public static ConstraintSet<Pair> generateAndMergeConstraints (
-			Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap,
-			ConstraintSet<Pair> constraints) {
-		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
-		constraints.addAll(generateConstraints);
-		return constraints;
-	}
-
-	/**
-	 * Generate the constraints for a map of type placeholder and RefType.
-	 * 
-	 * @param tphMap {@link Map} of {@link TypePlaceholder} and
-	 *               {@link RefTypeOrTPHOrWildcardOrGeneric}
-	 * @return {@link ConstraintSet} of {@link Pair} containing the constraints to
-	 *         infer the matching wildcard type.
-	 */
-	public static ConstraintSet<Pair> generateConstraints (
-			Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap) {
-		return tphMap.entrySet().stream().map(ConstraintsGenerationUtils::generateConstraints)
-				.reduce(
-				new ConstraintSet<>(),
-				(cs, c) -> {
-					cs.addAll(c);
-					return cs;
-						});
-	}
-
-	/**
-	 * Generate the constraints for a single RefType type placeholder pair to infer
-	 * the wildcards for the generic parameter type.
-	 * 
-	 * @param tphEntry {@link Entry} of {@link TypePlaceholder} and
-	 *                 {@link RefTypeOrTPHOrWildcardOrGeneric}
-	 * @return {@link ConstraintSet} of {@link Pair} generated containing the
-	 *         constraints.
-	 */
-	private static ConstraintSet<Pair> generateConstraints (
-			Map.Entry<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphEntry) {
-		return generateConstraints(tphEntry.getValue(), tphEntry.getKey());
-	}
-
-	/**
-	 * Generate the constraints for a single RefType type placeholder pair to infer
-	 * the wildcards for the generic parameter type.
-	 * 
-	 * @param refType {@link RefTypeOrTPHOrWildcardOrGeneric}
-	 * @param tph     {@link TypePlaceholder}
-	 * @return {@link ConstraintSet} of {@link Pair} generated containing the
-	 *         constraints.
-	 */
-	public static ConstraintSet<Pair> generateConstraints (RefTypeOrTPHOrWildcardOrGeneric refType,
-			TypePlaceholder tph) {
-		ConstraintSet<Pair> constraintSet = new ConstraintSet<>();
-		Set<Constraint<Pair>> oderConstraints = new HashSet<>();
-		constraintSet.addOderConstraint(oderConstraints);
-
-		// single type
-		ConstraintsGenerationUtils.addToOderConstraint(oderConstraints, tph, refType);
-
-		// extends type
-		ExtendsWildcardType extendsWildcardType = new ExtendsWildcardType(refType, new NullToken());
-		ConstraintsGenerationUtils.addToOderConstraint(oderConstraints, tph, extendsWildcardType);
-
-		// super type
-		SuperWildcardType superWildcardType = new SuperWildcardType(refType, new NullToken());
-		ConstraintsGenerationUtils.addToOderConstraint(oderConstraints, tph, superWildcardType);
-
-		return constraintSet;
-	}
-
-	private static void addToOderConstraint (Set<Constraint<Pair>> oderConstraints, TypePlaceholder tph,
-			RefTypeOrTPHOrWildcardOrGeneric refType) {
-		Constraint<Pair> c = new Constraint<>();
-		oderConstraints.add(c);
-
-		ConstraintsGenerationUtils.addToConstraint(c, tph, refType);
-	}
-
-	/**
-	 * Generate a pair and adds it to a constraint.
-	 * 
-	 * @param c    {@link Constraint} of {@link Pair}
-	 * @param tph  {@link TypePlaceholder}
-	 * @param type {@link RefTypeOrTPHOrWildcardOrGeneric}
-	 */
-	private static void addToConstraint (Constraint<Pair> c, TypePlaceholder tph,
-			RefTypeOrTPHOrWildcardOrGeneric type) {
-		Pair pair = new Pair(tph, type, PairOperator.EQUALSDOT);
-		c.add(pair);
-	}
-
-}

src/main/java/de/dhbwstuttgart/inferWildcards/JavaTXCompilerWildcards.java

@@ -1,159 +0,0 @@
-package de.dhbwstuttgart.inferWildcards;
-
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-import org.antlr.v4.runtime.Token;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.result.ResolvedType;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-
-/**
- * Extension of the JavaTX Compiler providing the capabilities to inference
- * wildcard types.
- * <p>
- * <code>
- * <ul>
- * <li>? super Type</li>
- * <li>? extends Type</li>
- * <li>Type</li>
- * </ul>
- * </code>
- * 
- * @author Till Schnell
- * @version 1.0
- */
-public class JavaTXCompilerWildcards
-	extends JavaTXCompiler
-{
-
-	/**
-	 * Generated Type placeholder and the implementation type represented.
-	 */
-	private final Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap;
-
-	public JavaTXCompilerWildcards (File... sourceFile) throws IOException, ClassNotFoundException {
-		super(sourceFile);
-		this.tphMap = TypePlaceholderReplaceUtils.generateTypePlaceholder(this);
-	}
-
-	public JavaTXCompilerWildcards (File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
-		super(sourceFile, log);
-		this.tphMap = TypePlaceholderReplaceUtils.generateTypePlaceholder(this);
-	}
-
-	public JavaTXCompilerWildcards (List<File> sourceFiles) throws IOException, ClassNotFoundException {
-		super(sourceFiles);
-		this.tphMap = TypePlaceholderReplaceUtils.generateTypePlaceholder(this);
-	}
-
-	public JavaTXCompilerWildcards (List<File> sources, List<File> contextPath)
-			throws IOException, ClassNotFoundException {
-		super(sources, contextPath);
-		this.tphMap = TypePlaceholderReplaceUtils.generateTypePlaceholder(this);
-	}
-
-	/**
-	 * Return the Type Placeholder generated.
-	 * 
-	 * @return {@link Map} over {@link TypePlaceholder} and
-	 *         {@link RefTypeOrTPHOrWildcardOrGeneric}
-	 */
-	public Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> getTphMap () {
-		return tphMap;
-	}
-
-	@Override
-	public ConstraintSet<Pair> getConstraints () throws ClassNotFoundException, IOException {
-		ConstraintSet<Pair> constraints = super.getConstraints();
-		return ConstraintsGenerationUtils.generateAndMergeConstraints(tphMap, constraints);
-	}
-
-	public void generateSourceCode (File outputDir) throws IOException, ClassNotFoundException {
-		if (!outputDir.exists() && outputDir.isDirectory()) {
-			boolean mkdirs = outputDir.mkdirs();
-			if (!mkdirs)
-				throw new IOException("Could not create output directory at: " + outputDir.getAbsolutePath());
-		}
-
-		// TODO for all result sets
-		List<ResultSet> typeInference = typeInference();
-		ResultSet resultSet = typeInference.get(0);
-
-		for (Map.Entry<File, SourceFile> e : sourceFiles.entrySet())
-			generateSourceCode(e.getKey(), outputDir, resultSet);
-
-	}
-
-	private void generateSourceCode (File inputFile, File outputDir, ResultSet results)
-			throws IOException {
-	
-		File outputFile = new File(outputDir, inputFile.getName());
-		
-		Files.deleteIfExists(outputFile.toPath());
-
-		if(!outputFile.createNewFile()) 
-			throw new IOException("File could not be created at: " + outputFile.getAbsolutePath());
-		
-		try(BufferedReader reader = new BufferedReader(new FileReader(inputFile));
-		BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile))){
-			List<Map.Entry<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric>> list = tphMap.entrySet().stream().sorted( (c1, c2) -> Integer.compare(c1.getValue().getOffset().getStartIndex(),
-					c2.getValue().getOffset().getStartIndex())).collect(Collectors.toList());
-			
-			int readIdx = 0;
-			
-			for (Map.Entry<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> e : list) {
-				Token token = e.getValue().getOffset();
-				
-				// read the characters before the token
-				int startIndex = token.getStartIndex();
-				char[] read = new char[startIndex - readIdx];
-
-				int i = reader.read(read);
-				if (i != read.length)
-					throw new IOException("Could not read the assumed number of character, read " + i
-							+ " assumed " + read.length);
-
-				readIdx += read.length;
-
-				// Write to output file
-				writer.write(read);
-
-				// Write the new type
-				ResolvedType resolveType = results.resolveType(e.getKey());
-				String string = resolveType.resolvedType.toString();
-				writer.write(string);
-
-				// Read the replaced type and count the read counter
-				int length = token.getStopIndex() - token.getStartIndex() + 1;
-				reader.read(new char[length]);
-				readIdx += length;
-			}
-			
-			// Read the rest of the file.
-			while (true) {
-				char[] tmp = new char[1024];
-				int read = reader.read(tmp);
-				if (read == -1)
-					break;
-
-				writer.write(tmp, 0, read);
-			}
-		}
-		
-	}
-}

src/main/java/de/dhbwstuttgart/inferWildcards/ReplaceTypeparamVisitor.java

@@ -1,171 +0,0 @@
-package de.dhbwstuttgart.inferWildcards;
-
-import java.util.HashMap;
-import java.util.ListIterator;
-import java.util.Map;
-
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
-import de.dhbwstuttgart.syntaxtree.Field;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
-import de.dhbwstuttgart.syntaxtree.Method;
-import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl;
-import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-
-/**
- * Visitor replace type parameter of the type RefType by Type Placeholder in a
- * AST.
- * 
- * @author Till Schnell
- * @version 1.0
- */
-public class ReplaceTypeparamVisitor
-	extends AbstractASTWalker
-{
-
-	/**
-	 * Containing the replaced RefType and the mapping TPH
-	 */
-	private final Map<TypePlaceholder, RefTypeOrTPHOrWildcardOrGeneric> tphMap;
-	
-	/**
-	 * Constructor for a {@code ReplaceTypeparamVisitor}.
-	 */
-	public ReplaceTypeparamVisitor () {
-		this.tphMap = new HashMap<>();
-	}
-
-	@Override
-	public void visit (Field field) {
-		System.out.println("Field: " + field.getName());
-
-		field.accept(new ReplaceRefTypeVisitor());
-
-		super.visit(field);
-	}
-
-	@Override
-	public void visit (FormalParameter formalParameter) {
-		System.out.println("FormalParameter: " + formalParameter.getName());
-
-		formalParameter.accept(new ReplaceRefTypeVisitor());
-
-		super.visit(formalParameter);
-	}
-
-	@Override
-	public void visit (LocalVarDecl localVarDecl) {
-		System.out.println("LocalVarDecl: " + localVarDecl.getName());
-
-		localVarDecl.accept(new ReplaceRefTypeVisitor());
-
-		super.visit(localVarDecl);
-	}
-
-	@Override
-	public void visit (Method method) {
-		System.out.println("Method: " + method.getName());
-
-		RefTypeOrTPHOrWildcardOrGeneric returnType = method.getReturnType();
-		if (returnType != null)
-			returnType.accept(new ReplaceRefTypeVisitor());
-		
-		super.visit(method);
-	}
-
-	/**
-	 * Return the mapping of the replaced {@link RefType} and the inserted
-	 * {@link TypePlaceholder}.
-	 * 
-	 * @return {@link Map} of {@link TypePlaceholder} and {@link RefType}
-	 */
-	public Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> getTphMap () {
-		return tphMap;
-	}
-
-	/**
-	 * Visitor replace each RefType occurs.
-	 * 
-	 * @author Till Schnell
-	 * @version 1.0
-	 */
-	private class ReplaceRefTypeVisitor
-		extends AbstractASTWalker
-	{
-		@Override
-		public void visit (RefType refType) {
-
-			// check if RefType has Parameter Types
-			if (!refType.getParaList().isEmpty()) {
-				System.out.print("Visit Type: " + refType + " -> ");
-
-				// Iterate over all Parameter Types
-				for (ListIterator<RefTypeOrTPHOrWildcardOrGeneric> listIterator = refType.getParaList()
-						.listIterator(); listIterator.hasNext();) {
-					RefTypeOrTPHOrWildcardOrGeneric next = listIterator.next();
-
-					// If Parameter type is RefType replace with TPH
-					if (next instanceof RefType) {
-						RefType nextRefType = (RefType) next;
-
-						// Visit replaced RefType to get all nested type parameters
-						// Should be done before generating parents TPH to include child TPH in the
-						// parent TPH mapping
-						this.visit(nextRefType);
-
-						generateTphAndReplaceInTree(listIterator, next);
-					}
-					else if (next instanceof GenericRefType) {
-
-						// Visit of nested type arguments not necessary as Generic Types cannot contain
-						// type parameters
-
-						generateTphAndReplaceInTree(listIterator, next);
-					}
-				}
-
-				System.out.println(refType);
-			}
-
-			// Let the parent care about all the other stuff
-			super.visit(refType);
-		}
-
-		/**
-		 * Generate the TPH for a {@link RefTypeOrTPHOrWildcardOrGeneric} and saves the
-		 * mapping.
-		 * 
-		 * @param t {@link RefTypeOrTPHOrWildcardOrGeneric}
-		 * @return {@link TypePlaceholder} generated
-		 */
-		private TypePlaceholder generateTypePlaceholder (RefTypeOrTPHOrWildcardOrGeneric t) {
-			TypePlaceholder tph = TypePlaceholder.fresh(new NullToken());
-			tphMap.put(tph, t);
-			return tph;
-		}
-
-		/**
-		 * Generate the TPH for a {@link RefTypeOrTPHOrWildcardOrGeneric}, saves the
-		 * mapping and replaces the type by the type placeholder in the tree.
-		 * 
-		 * @param listIterator {@link ListIterator} over
-		 *                     {@link RefTypeOrTPHOrWildcardOrGeneric} representing the
-		 *                     tree to replace in
-		 * @param refType      {@link RefTypeOrTPHOrWildcardOrGeneric} to generate type
-		 *                     placeholder for and replace
-		 */
-		private void generateTphAndReplaceInTree (ListIterator<RefTypeOrTPHOrWildcardOrGeneric> listIterator,
-				RefTypeOrTPHOrWildcardOrGeneric refType) {
-			// Generate TPH
-			TypePlaceholder tph = generateTypePlaceholder(refType);
-
-			// Replace in AST
-			listIterator.set(tph);
-		}
-
-	}
-
-}

src/main/java/de/dhbwstuttgart/inferWildcards/TypePlaceholderReplaceUtils.java

@@ -1,42 +0,0 @@
-package de.dhbwstuttgart.inferWildcards;
-
-import java.io.File;
-import java.util.Map;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-
-/**
- * Class providing utilities to generate the Type placeholder for parameter
- * types which shall be inferred.
- * 
- * @author Till Schnell
- * @version 1.0
- */
-public final class TypePlaceholderReplaceUtils
-{
-
-	private TypePlaceholderReplaceUtils () {
-		throw new AssertionError("No TypePlaceholderReplaceUtils instance for you");
-	}
-
-	/**
-	 * Return the map of the generated type placeholder for the associate parameter
-	 * type
-	 * 
-	 * @param compiler {@link JavaTXCompiler} to get the source file from
-	 * @return {@link Map} over {@link TypePlaceholder} and the {@link RefType}
-	 *         replaced
-	 */
-	public static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTypePlaceholder (
-			JavaTXCompiler compiler) {
-		Map<File, SourceFile> sourceFiles = compiler.getSourceFiles();
-		ReplaceTypeparamVisitor visitor = new ReplaceTypeparamVisitor();
-		sourceFiles.forEach( (k, v) -> v.accept(visitor));
-		return visitor.getTphMap();
-	}
-
-}

src/main/java/de/dhbwstuttgart/parser/antlr/Java8BaseListener.java

@@ -1,4 +1,4 @@
-// Generated from Java8.g4 by ANTLR 4.8
+// Generated from Java8.g4 by ANTLR 4.7
 package de.dhbwstuttgart.parser.antlr;
 
 import org.antlr.v4.runtime.ParserRuleContext;

src/main/java/de/dhbwstuttgart/parser/antlr/Java8Lexer.java

@@ -1,4 +1,4 @@
-// Generated from Java8.g4 by ANTLR 4.8
+// Generated from Java8.g4 by ANTLR 4.7
 package de.dhbwstuttgart.parser.antlr;
 import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.CharStream;
@@ -11,7 +11,7 @@ import org.antlr.v4.runtime.misc.*;
 
 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
 public class Java8Lexer extends Lexer {
-	static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); }
+	static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
 
 	protected static final DFA[] _decisionToDFA;
 	protected static final PredictionContextCache _sharedContextCache =
@@ -42,79 +42,68 @@ public class Java8Lexer extends Lexer {
 		"DEFAULT_MODE"
 	};
 
-	private static String[] makeRuleNames() {
-		return new String[] {
-			"T__0", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", 
-			"CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", 
-			"ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", 
-			"IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", 
-			"NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", 
-			"STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", 
-			"THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", 
-			"DecimalIntegerLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", 
-			"BinaryIntegerLiteral", "IntegerTypeSuffix", "DecimalNumeral", "Digits", 
-			"Digit", "NonZeroDigit", "DigitsAndUnderscores", "DigitOrUnderscore", 
-			"Underscores", "HexNumeral", "HexDigits", "HexDigit", "HexDigitsAndUnderscores", 
-			"HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", "OctalDigit", 
-			"OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", 
-			"BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", 
-			"FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", 
-			"ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", 
-			"HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", 
-			"CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", 
-			"StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", 
-			"NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
-			"SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", 
-			"COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", 
-			"ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", 
-			"COLONCOLON", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", 
-			"AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", 
-			"RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", 
-			"AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
-		};
-	}
-	public static final String[] ruleNames = makeRuleNames();
+	public static final String[] ruleNames = {
+		"T__0", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", 
+		"CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", 
+		"ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", 
+		"IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", 
+		"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", 
+		"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", 
+		"TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "DecimalIntegerLiteral", 
+		"HexIntegerLiteral", "OctalIntegerLiteral", "BinaryIntegerLiteral", "IntegerTypeSuffix", 
+		"DecimalNumeral", "Digits", "Digit", "NonZeroDigit", "DigitsAndUnderscores", 
+		"DigitOrUnderscore", "Underscores", "HexNumeral", "HexDigits", "HexDigit", 
+		"HexDigitsAndUnderscores", "HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", 
+		"OctalDigit", "OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", 
+		"BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", 
+		"FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", 
+		"ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", 
+		"HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", 
+		"CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", 
+		"StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", 
+		"NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
+		"SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", 
+		"COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", 
+		"SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", 
+		"ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", 
+		"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", 
+		"URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", "AT", 
+		"ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
+	};
 
-	private static String[] makeLiteralNames() {
-		return new String[] {
-			null, "'var'", "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", 
-			"'case'", "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", 
-			"'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", 
-			"'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", 
-			"'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", 
-			"'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", 
-			"'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", 
-			"'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, 
-			null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", 
-			"';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", 
-			"'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", 
-			"'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", 
-			"'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", 
-			"'>>>='", null, "'@'", "'...'"
-		};
-	}
-	private static final String[] _LITERAL_NAMES = makeLiteralNames();
-	private static String[] makeSymbolicNames() {
-		return new String[] {
-			null, null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", 
-			"CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", 
-			"ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", 
-			"GOTO", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", 
-			"NATIVE", "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", 
-			"SHORT", "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", 
-			"THROW", "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", 
-			"FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", 
-			"NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
-			"SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", 
-			"COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", 
-			"ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", 
-			"COLONCOLON", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", 
-			"AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", 
-			"RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", "AT", "ELLIPSIS", "WS", 
-			"COMMENT", "LINE_COMMENT"
-		};
-	}
-	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
+	private static final String[] _LITERAL_NAMES = {
+		null, "'var'", "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", 
+		"'case'", "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", 
+		"'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", 
+		"'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", 
+		"'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", 
+		"'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", 
+		"'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", 
+		"'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, 
+		null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", 
+		"';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", 
+		"'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", 
+		"'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", 
+		"'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", 
+		"'>>>='", null, "'@'", "'...'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", 
+		"CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", 
+		"ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", 
+		"IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", 
+		"NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", 
+		"STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", 
+		"THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", 
+		"FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", 
+		"NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
+		"SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", 
+		"COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", 
+		"SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", 
+		"ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", 
+		"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", 
+		"URSHIFT_ASSIGN", "Identifier", "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
+	};
 	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
 
 	/**

src/main/java/de/dhbwstuttgart/parser/antlr/Java8Listener.java

@@ -1,4 +1,4 @@
-// Generated from Java8.g4 by ANTLR 4.8
+// Generated from Java8.g4 by ANTLR 4.7
 package de.dhbwstuttgart.parser.antlr;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 

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

@@ -154,7 +154,7 @@ public class UnifyTypeFactory {
     public static Constraint<UnifyPair> convert(Constraint<Pair> constraint){
     	Constraint<UnifyPair> unifyPairConstraint = constraint.stream()
     			.map(UnifyTypeFactory::convert)
-    			.collect(Collectors.toCollection( () -> new Constraint<UnifyPair> (constraint.isInherited(), convert(constraint.getExtendConstraint()))));
+    			.collect(Collectors.toCollection( () -> new Constraint<UnifyPair>(convert(constraint.getExtendConstraint()))));
     	return unifyPairConstraint;
     }
 

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

@@ -17,15 +17,13 @@ public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;
     private RefTypeOrTPHOrWildcardOrGeneric retType;
     List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
-    private final Boolean isInherited;
 
     public MethodAssumption(ClassOrInterface receiver, RefTypeOrTPHOrWildcardOrGeneric retType,
-                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope, Boolean isInherited){
+                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
         super(scope);
         this.receiver = receiver;
         this.retType = retType;
         this.params = params;
-        this.isInherited = isInherited;
     }
 
     /*
@@ -72,8 +70,4 @@ public class MethodAssumption extends Assumption{
 
         return receiverType;
     }
-    
-    public Boolean isInherited() {
-    	return isInherited;
-    }
 }

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

@@ -6,32 +6,17 @@ import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 
+//TODO: Remove this class
 public class Constraint<A> extends HashSet<A> {
 	private static final long serialVersionUID = 1L;
-	private Boolean isInherited = false;//wird nur für die Method-Constraints benoetigt
 	private Constraint<A> extendConstraint = null;
+
+	public Constraint(){}
 	
-	public Constraint() {
-		super();
-	}
-	
-	public Constraint(Boolean isInherited) {
-		this.isInherited = isInherited;
-	}
-	
-	public Constraint(Boolean isInherited, Constraint<A> extendConstraint) {
-		this.isInherited = isInherited;
+	public Constraint(Constraint<A> extendConstraint) {
 		this.extendConstraint = extendConstraint;
 	}
 	
-	public void setIsInherited(Boolean isInherited) {
-		this.isInherited = isInherited;
-	}
-	
-	public Boolean isInherited() {
-		return isInherited;
-	}
-	
 	public Constraint<A> getExtendConstraint() {
 		return extendConstraint;
 	}
@@ -41,7 +26,7 @@ public class Constraint<A> extends HashSet<A> {
 	}
 
 	public String toString() {
-		return super.toString() + " isInherited = " + isInherited 
+		return super.toString()
 				//" + extendsContraint: "  + (extendConstraint != null ? extendConstraint.toStringBase() : "null" ) 
 				+ "\n" ;
 	}

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

@@ -68,9 +68,8 @@ public class ConstraintSet<A> {
                     	Constraint<B> newConst = as.stream()
                     			.map(o)
                     			.collect(Collectors.toCollection((as.getExtendConstraint() != null)
-                    					? () -> new Constraint<B> (as.isInherited(),
-                    							                   as.getExtendConstraint().stream().map(o).collect(Collectors.toCollection(Constraint::new))) 
-                    					: () -> new Constraint<B> (as.isInherited())
+                    					? () -> new Constraint<B> (as.getExtendConstraint().stream().map(o).collect(Collectors.toCollection(Constraint::new)))
+                    					: () -> new Constraint<B> ()
                     			));                    							
                     	
                     	//CSA2CSB.put(as, newConst);

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

@@ -0,0 +1,107 @@
+package de.dhbwstuttgart.typeinference.constraints;
+
+
+import java.util.*;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+public class ConstraintSet2 {
+    Set<OderConstraint> oderConstraints = new HashSet<>();
+
+    public ConstraintSet2(Set<OderConstraint> constraints){
+        if(constraints.isEmpty())throw new RuntimeException("Empty constraint set");
+        this.oderConstraints = constraints;
+    }
+
+    @Override
+    public String toString(){
+    	BinaryOperator<String> b = (x,y) -> x+y;
+        return "ODER:" + this.oderConstraints.stream().reduce("", (x,y) -> x.toString()+ "\n"  +y, b);
+    }
+
+    private class ConstraintSpliterator implements Spliterator<Set<Pair>> {
+        private List<OderConstraint> constraints;
+        private long i = 0;
+        private long max = 0;
+        private List<Integer> sizes;
+        private List<Long> bases = new ArrayList<>();
+
+        ConstraintSpliterator(List<OderConstraint> constraints){
+            this.constraints = constraints;
+            sizes = constraints.stream().map(OderConstraint::getSize).collect(Collectors.toList());
+            long base = 1;
+            for(int size : sizes){
+                bases.add(base);
+                base *= size;
+            }
+            i = 0;
+            max = estimateSize() - 1;
+        }
+
+        ConstraintSpliterator(List<OderConstraint> constraints, long start, long end){
+            this(constraints);
+            i = start;
+            max = end;
+        }
+
+        @Override
+        public boolean tryAdvance(Consumer<? super Set<Pair>> consumer) {
+            if(i > max) return false;
+            consumer.accept(get(i));
+            i++;
+            return true;
+        }
+
+        private Set<Pair> get(long num){
+            Set<Pair> ret = new HashSet<>();
+            Iterator<Long> baseIt = bases.iterator();
+            for(OderConstraint constraint : constraints){
+                ret.addAll(constraint.get((int) ((num/baseIt.next())%constraint.getSize())));
+            }
+            return ret;
+        }
+
+        @Override
+        public Spliterator<Set<Pair>> trySplit() {
+            if(max - i < 2) return null;
+            long middle = i + ((max- i) / 2);
+            long maxOld = max;
+            max = middle - 1;
+            return new ConstraintSpliterator(constraints, middle, maxOld);
+        }
+
+        @Override
+        public long estimateSize() {
+            long ret = 1;
+            for (int size : sizes)ret*=size;
+            return ret;
+        }
+
+        @Override
+        public int characteristics() {
+            return ORDERED | SIZED | IMMUTABLE | NONNULL;
+        }
+    }
+
+    public Stream<Set<Pair>> cartesianProductParallel(){
+        return StreamSupport.stream(new ConstraintSpliterator(oderConstraints.stream().collect(Collectors.toList())), true);
+    }
+/*
+    public Map<String, TypePlaceholder> generateTPHMap() {
+        HashMap<String, TypePlaceholder> ret = new HashMap<>();
+        constraints.map((Pair p) -> {
+            if (p.TA1 instanceof TypePlaceholder) {
+                ret.put(((TypePlaceholder) p.TA1).getName(), (TypePlaceholder) p.TA1);
+            }
+            if (p.TA2 instanceof TypePlaceholder) {
+                ret.put(((TypePlaceholder) p.TA2).getName(), (TypePlaceholder) p.TA2);
+            }
+            return null;
+        });
+        return ret;
+    }
+*/
+}

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

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.typeinference.constraints;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class ConstraintSetBuilder {
+    private Set<Pair> undConstraints = new HashSet<>();
+    private Set<OderConstraint> oderConstraints = new HashSet<>();
+    private boolean done = false;
+
+    public void addUndConstraint(Pair p){
+        undConstraints.add(p);
+    }
+
+    public void addOderConstraint(OderConstraint orConstraint) {
+        oderConstraints.add(orConstraint);
+    }
+
+    public ConstraintSet2 build(){
+        if(done)throw new RuntimeException("Trying to build cartesian product twice");
+        this.done = true;
+        if(!undConstraints.isEmpty())
+            oderConstraints.add(new OderConstraint(Set.of(undConstraints)));
+        return new ConstraintSet2(oderConstraints);
+    }
+}

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

@@ -0,0 +1,24 @@
+package de.dhbwstuttgart.typeinference.constraints;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class OderConstraint {
+    private final List<Set<Pair>> cons;
+    public OderConstraint(Set<Set<Pair>> orCons){
+        if(orCons.isEmpty())throw new RuntimeException("Empty constraint set");
+        for(Set<Pair> c : orCons){
+            if(c.isEmpty())throw new RuntimeException("Empty constraint set");
+        }
+        this.cons = orCons.stream().collect(Collectors.toList());
+    }
+
+    public int getSize(){
+        return cons.size();
+    }
+
+    public Set<Pair> get(int l) {
+        return cons.get(l);
+    }
+}

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

@@ -179,7 +179,7 @@ public class TYPEStmt implements StatementVisitor{
 					           !(x.TA2 instanceof TypePlaceholder))
 					        		   ? new Pair(x.TA1, new ExtendsWildcardType(x.TA2, x.TA2.getOffset()), PairOperator.EQUALSDOT)
 					        		   : x)
-            		.collect(Collectors.toCollection(() -> new Constraint<Pair>(oneMethodConstraint.isInherited())));
+            		.collect(Collectors.toCollection(() -> new Constraint<Pair>()));
             oneMethodConstraint.setExtendConstraint(extendsOneMethodConstraint);
             extendsOneMethodConstraint.setExtendConstraint(oneMethodConstraint);
             methodConstraints.add(extendsOneMethodConstraint);
@@ -574,7 +574,7 @@ public class TYPEStmt implements StatementVisitor{
 
     protected Constraint<Pair> generateConstraint(MethodCall forMethod, MethodAssumption assumption,
                                                   TypeInferenceBlockInformation info, GenericsResolver resolver){
-        Constraint<Pair> methodConstraint = new Constraint<>(assumption.isInherited());
+        Constraint<Pair> methodConstraint = new Constraint<>();
         ClassOrInterface receiverCl = assumption.getReceiver();
         /*
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
@@ -636,7 +636,7 @@ public class TYPEStmt implements StatementVisitor{
                         public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
                             throw new NotImplementedException();
                         }
-                    }, false));
+                    }));
         }
         for(ClassOrInterface cl : info.getAvailableClasses()){
             for(Method m : cl.getMethods()){
@@ -645,7 +645,7 @@ public class TYPEStmt implements StatementVisitor{
                     RefTypeOrTPHOrWildcardOrGeneric retType = m.getReturnType();//info.checkGTV(m.getReturnType());
 
                     ret.add(new MethodAssumption(cl, retType, convertParams(m.getParameterList(),info),
-                           createTypeScope(cl, m), m.isInherited));
+                           createTypeScope(cl, m)));
                 }
             }
         }
@@ -680,7 +680,7 @@ public class TYPEStmt implements StatementVisitor{
                 for(Method m : cl.getConstructors()){
                     if(m.getParameterList().getFormalparalist().size() == argList.getArguments().size()){
                         ret.add(new MethodAssumption(cl, ofType, convertParams(m.getParameterList(),
-                                info), createTypeScope(cl, m), m.isInherited));
+                                info), createTypeScope(cl, m)));
                     }
                 }
             }

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

@@ -682,9 +682,8 @@ public class RuleSet implements IRuleSet{
 				Function<? super Constraint<UnifyPair>,? extends Constraint<UnifyPair>> applyUni = b -> b.stream().map(
 						x -> uni.apply(pair,x)).collect(Collectors.toCollection((b.getExtendConstraint() != null)
 								? () -> new Constraint<UnifyPair>(
-										  b.isInherited(),
 										  b.getExtendConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(Constraint::new)))
-								: () -> new Constraint<UnifyPair>(b.isInherited())
+								: () -> new Constraint<UnifyPair>()
 									));
 				oderConstraints.replaceAll(oc -> oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new)));
 				/*

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

@@ -1304,7 +1304,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 							Set<UnifyPair> a_new = aParDefIt.next();
 							List<Set<UnifyPair>> smallerSetasList = oup.smallerThan(a_new, nextSetasList);
 							List<Set<UnifyPair>> notInherited = smallerSetasList.stream()
-								.filter(x -> !((Constraint<UnifyPair>)x).isInherited())
 								.collect(Collectors.toCollection(ArrayList::new));
 							List<Set<UnifyPair>> notErased = new ArrayList<>();
 							notInherited.stream().forEach(x -> { notErased.addAll(oup.smallerEqThan(x, smallerSetasList)); });
@@ -1346,11 +1345,10 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 							List<Set<UnifyPair>> greaterSetasList = oup.greaterThan(a_new, nextSetasList); 
 							
 							//a_new muss hingefuegt werden, wenn es nicht vererbt ist, dann wird es spaeter wieder geloescht
-							if (!((Constraint<UnifyPair>)a_new).isInherited()) {
-								greaterSetasList.add(a_new); 
-							}
+
+							greaterSetasList.add(a_new);
+
 							List<Set<UnifyPair>> notInherited = greaterSetasList.stream()
-								.filter(x -> !((Constraint<UnifyPair>)x).isInherited())
 								.collect(Collectors.toCollection(ArrayList::new));
 							List<Set<UnifyPair>> notErased = new ArrayList<>();
 							
@@ -1401,7 +1399,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 						writeLog("Removed: " + nextSetasListOderConstraints);
 					    List<Set<UnifyPair>> smallerSetasList = oup.smallerThan(a, nextSetasList);
 						List<Set<UnifyPair>> notInherited = smallerSetasList.stream()
-							.filter(x -> !((Constraint<UnifyPair>)x).isInherited())
 							.collect(Collectors.toCollection(ArrayList::new));
 						List<Set<UnifyPair>> notErased = new ArrayList<>();
 						notInherited.stream().forEach(x -> { notErased.addAll(oup.smallerEqThan(x, smallerSetasList)); });

src/main/java/de/dhbwstuttgart/unify2/MartelliMontanariUnify.java

@@ -0,0 +1,108 @@
+package de.dhbwstuttgart.unify2;
+
+import de.dhbwstuttgart.typeinference.unify.interfaces.IUnify;
+import de.dhbwstuttgart.typeinference.unify.model.*;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Implementation of the Martelli-Montanari unification algorithm.
+ * @author Florian Steurer
+ */
+public class MartelliMontanariUnify {
+
+	/**
+	 * Finds the most general unifier sigma of the set {t1 =. t1',...,tn =. tn'} so that
+	 * sigma(t1) = sigma(t1') , ... sigma(tn) = sigma(tn').
+	 * @param terms The set of terms to be unified
+	 * @return An optional of the most general unifier if it exists or an empty optional if there is no unifier.
+	 */
+	public static Optional<Unifier> unify(UnifyType... terms) {
+		return unify(Arrays.stream(terms).collect(Collectors.toSet()));
+	}
+
+	public static Optional<Unifier> unify(Set<UnifyType> terms) {
+		// Sets with less than 2 terms are trivially unified
+		if(terms.size() < 2)
+			return Optional.of(Unifier.identity());
+		
+		// For the the set of terms {t1,...,tn},
+		// build a list of equations {(t1 = t2), (t2 = t3), (t3 = t4), ....}
+		ArrayList<UnifyPair> termsList = new ArrayList<UnifyPair>();
+		Iterator<UnifyType> iter = terms.iterator();
+		UnifyType prev = iter.next();
+		while(iter.hasNext()) {
+			UnifyType next = iter.next();
+			termsList.add(new UnifyPair(prev, next, PairOperator.EQUALSDOT));
+			prev = next;
+		}
+		
+		// Start with the identity unifier. Substitutions will be added later.
+		Unifier mgu = Unifier.identity();
+		
+		// Apply rules while possible
+		int idx = 0;
+		while(idx < termsList.size()) {
+			UnifyPair pair = termsList.get(idx);
+			UnifyType rhsType = pair.getRhsType();
+			UnifyType lhsType = pair.getLhsType();
+			TypeParams rhsTypeParams = rhsType.getTypeParams();
+			TypeParams lhsTypeParams = lhsType.getTypeParams();
+			
+			// REDUCE - Rule
+			if(!(rhsType instanceof PlaceholderType) && !(lhsType instanceof PlaceholderType)) {
+				Set<UnifyPair> result = new HashSet<>();
+				
+				// f<...> = g<...> with f != g are not unifiable
+				if(!rhsType.getName().equals(lhsType.getName()))
+					return Optional.empty(); // conflict
+				// f<t1,...,tn> = f<s1,...,sm> are not unifiable
+				if(rhsTypeParams.size() != lhsTypeParams.size())
+					return Optional.empty(); // conflict
+				// f = g is not unifiable (cannot be f = f because erase rule would have been applied)
+				//if(rhsTypeParams.size() == 0)
+					//return Optional.empty();
+					
+				// Unpack the arguments
+				for(int i = 0; i < rhsTypeParams.size(); i++)
+					result.add(new UnifyPair(rhsTypeParams.get(i), lhsTypeParams.get(i), PairOperator.EQUALSDOT));
+				
+				termsList.remove(idx);
+				termsList.addAll(result);
+				continue;
+			}
+			
+			// DELETE - Rule
+			if(pair.getRhsType().equals(pair.getLhsType())) {
+				termsList.remove(idx);
+				continue; 
+			}
+
+			// SWAP - Rule
+			if(!(lhsType instanceof PlaceholderType) && (rhsType instanceof PlaceholderType)) {
+				termsList.remove(idx);
+				termsList.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT));
+				continue;
+			}
+			
+			// OCCURS-CHECK
+			if(pair.getLhsType() instanceof PlaceholderType
+					&& pair.getRhsType().getTypeParams().occurs((PlaceholderType) pair.getLhsType())) 
+				return Optional.empty();
+			
+			// SUBST - Rule
+			if(lhsType instanceof PlaceholderType) {
+				mgu.add((PlaceholderType) lhsType, rhsType);
+				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen. 
+				termsList = termsList.stream().map(x -> mgu.apply(x)).collect(Collectors.toCollection(ArrayList::new));
+				idx = idx+1 == termsList.size() ? 0 : idx+1;
+				continue;
+			}
+			
+			idx++;
+		}
+		
+		return Optional.of(mgu);
+	}
+}

src/main/java/de/dhbwstuttgart/unify2/RuleSet.java

@@ -0,0 +1,922 @@
+package de.dhbwstuttgart.unify2;
+
+import de.dhbwstuttgart.exceptions.DebugException;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.unify.distributeVariance;
+import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.interfaces.IRuleSet;
+import de.dhbwstuttgart.typeinference.unify.model.*;
+import org.antlr.v4.tool.Rule;
+import org.apache.commons.io.output.NullOutputStream;
+
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * Implementation of the type inference rules.
+ * @author Florian Steurer
+ *
+ */
+public class RuleSet {
+
+	/**
+	 * Repeatedly applies type unification rules to a set of equations.
+	 * This is step one of the unification algorithm.
+	 * @return The set of pairs that results from repeated application of the inference rules.
+	 */
+	public static Set<UnifyPair> applyTypeUnificationRules(Set<UnifyPair> eq, IFiniteClosure fc) {
+
+		/*
+		 * Rule Application Strategy:
+		 *
+		 * 1. 	Swap all pairs and erase all erasable pairs
+		 * 2. 	Apply all possible rules to a single pair, then move it to the result set.
+		 *    	Iterating over pairs first, then iterating over rules prevents the application
+		 *    	of rules to a "finished" pair over and over.
+		 * 2.1 	Apply all rules repeatedly except for erase rules. If
+		 * 		the application of a rule creates new pairs, check immediately
+		 * 		against the erase rules.
+		 */
+
+
+		LinkedHashSet<UnifyPair> targetSet = new LinkedHashSet<UnifyPair>();
+		LinkedList<UnifyPair> eqQueue = new LinkedList<>();
+
+		/*
+		 * Swap all pairs and erase all erasable pairs
+		 */
+		eq.forEach(x -> swapAddOrErase(x, fc, eqQueue));
+
+		/*
+		 * Apply rules until the queue is empty
+		 */
+		while(!eqQueue.isEmpty()) {
+			UnifyPair pair = eqQueue.pollFirst();
+
+			// ReduceUp, ReduceLow, ReduceUpLow
+			Optional<UnifyPair> opt = RuleSet.reduceUpLow(pair);
+			opt = opt.isPresent() ? opt : RuleSet.reduceLow(pair);
+			opt = opt.isPresent() ? opt : RuleSet.reduceUp(pair);
+			opt = opt.isPresent() ? opt : RuleSet.reduceWildcardLow(pair);
+			opt = opt.isPresent() ? opt : RuleSet.reduceWildcardLowRight(pair);
+			opt = opt.isPresent() ? opt : RuleSet.reduceWildcardUp(pair);
+			opt = opt.isPresent() ? opt : RuleSet.reduceWildcardUpRight(pair);
+			//PL 2018-03-06 auskommentiert muesste falsch sein vgl. JAVA_BSP/Wildcard6.java
+			//opt = opt.isPresent() ? opt : rules.reduceWildcardLowUp(pair);
+			//opt = opt.isPresent() ? opt : rules.reduceWildcardUpLow(pair);
+			//opt = opt.isPresent() ? opt : rules.reduceWildcardLeft(pair);
+
+			// Reduce TPH
+			opt = opt.isPresent() ? opt : RuleSet.reduceTph(pair);
+
+			// One of the rules has been applied
+			if(opt.isPresent()) {
+				swapAddOrErase(opt.get(), fc, eqQueue);
+				continue;
+			}
+
+			// Reduce1, Reduce2, ReduceExt, ReduceSup, ReduceEq
+			//try {
+			//	logFile.write("PAIR1 " + pair + "\n");
+			//	logFile.flush();
+			//}
+			//catch (IOException e) { }
+
+			Optional<Set<UnifyPair>> optSet = RuleSet.reduce1(pair, fc);
+			optSet = optSet.isPresent() ? optSet : RuleSet.reduce2(pair);
+			optSet = optSet.isPresent() ? optSet : RuleSet.reduceExt(pair, fc);
+			optSet = optSet.isPresent() ? optSet : RuleSet.reduceSup(pair, fc);
+			optSet = optSet.isPresent() ? optSet : RuleSet.reduceEq(pair);
+
+			// ReduceTphExt, ReduceTphSup
+			optSet = optSet.isPresent() ? optSet : RuleSet.reduceTphExt(pair);
+			optSet = optSet.isPresent() ? optSet : RuleSet.reduceTphSup(pair);
+
+
+			// FunN Rules
+			optSet = optSet.isPresent() ? optSet : RuleSet.reduceFunN(pair);
+			optSet = optSet.isPresent() ? optSet : RuleSet.greaterFunN(pair);
+			optSet = optSet.isPresent() ? optSet : RuleSet.smallerFunN(pair);
+
+			// One of the rules has been applied
+			if(optSet.isPresent()) {
+				optSet.get().forEach(x -> swapAddOrErase(x, fc, eqQueue));
+				continue;
+			}
+
+			// Adapt, AdaptExt, AdaptSup
+			//try {
+			//	logFile.write("PAIR2 " + pair + "\n");
+			//	logFile.flush();
+			//}
+			//catch (IOException e) { }
+			opt = RuleSet.adapt(pair, fc);
+			opt = opt.isPresent() ? opt : RuleSet.adaptExt(pair,  fc);
+			opt = opt.isPresent() ? opt : RuleSet.adaptSup(pair, fc);
+
+			// One of the rules has been applied
+			if(opt.isPresent()) {
+				swapAddOrErase(opt.get(), fc, eqQueue);
+				continue;
+			}
+
+			// None of the rules has been applied
+			targetSet.add(pair);
+		}
+
+		return targetSet;
+	}
+
+	/**
+	 * Applies the rule swap to a pair if possible. Then adds the pair to the set if no erase rule applies.
+	 * If an erase rule applies, the pair is not added (erased).
+	 * @param pair The pair to swap and add or erase.
+	 * @param collection The collection to which the pairs are added.
+	 */
+	static void swapAddOrErase(UnifyPair pair, IFiniteClosure fc, Collection<UnifyPair> collection) {
+		Optional<UnifyPair> opt = RuleSet.swap(pair);
+		UnifyPair pair2 = opt.isPresent() ? opt.get() : pair;
+
+		if(RuleSet.erase1(pair2, fc) || RuleSet.erase3(pair2) || RuleSet.erase2(pair2, fc))
+			return;
+
+		collection.add(pair2);
+	}
+
+	static Optional<UnifyPair> reduceUp(UnifyPair pair) {
+		// Check if reduce up is applicable 
+		if(pair.getPairOp() != PairOperator.SMALLERDOT)
+			return Optional.empty();
+		
+		UnifyType rhsType = pair.getRhsType();
+		if(!(rhsType instanceof SuperType))
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		if(!(lhsType instanceof ReferenceType) && !(lhsType instanceof PlaceholderType))
+			return Optional.empty();
+		
+		// Rule is applicable, unpack the SuperType 
+		return Optional.of(new UnifyPair(lhsType, ((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	static Optional<UnifyPair> reduceLow(UnifyPair pair) {
+		// Check if rule is applicable
+		if(pair.getPairOp() != PairOperator.SMALLERDOT)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		if(!(lhsType instanceof ExtendsType))
+			return Optional.empty();
+		
+		UnifyType rhsType = pair.getRhsType();
+		if(!(rhsType instanceof ReferenceType) && !(rhsType instanceof PlaceholderType))
+			return Optional.empty();
+
+		// Rule is applicable, unpack the ExtendsType
+		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), rhsType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	static Optional<UnifyPair> reduceUpLow(UnifyPair pair) {
+		// Check if rule is applicable
+		if(pair.getPairOp() != PairOperator.SMALLERDOT)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		if(!(lhsType instanceof ExtendsType))
+			return Optional.empty();
+		
+		UnifyType rhsType = pair.getRhsType();
+		if(!(rhsType instanceof SuperType))
+			return Optional.empty();
+		
+		// Rule is applicable, unpack both sides
+		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(),((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	static Optional<Set<UnifyPair>> reduceExt(UnifyPair pair, IFiniteClosure fc) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+
+		UnifyType x = pair.getLhsType();
+		UnifyType sTypeX;
+		
+		if(x instanceof ReferenceType)
+			sTypeX = x;
+		else if(x instanceof ExtendsType)
+			sTypeX = ((ExtendsType) x).getExtendedType();
+		else 
+			return Optional.empty();
+
+		UnifyType extY = pair.getRhsType();
+
+		if(!(extY instanceof ExtendsType))
+			return Optional.empty();
+
+		if(x.getTypeParams().empty() || extY.getTypeParams().size() != x.getTypeParams().size())
+			return Optional.empty();
+		
+		UnifyType xFromFc = fc.getLeftHandedType(sTypeX.getName()).orElse(null);
+		
+		if(xFromFc == null || !xFromFc.getTypeParams().arePlaceholders())
+			return Optional.empty();
+		
+		if(x instanceof ExtendsType)
+			xFromFc = new ExtendsType(xFromFc);
+		
+		UnifyType extYFromFc = fc.grArg(xFromFc, new HashSet<>()).stream().filter(t -> t.getName().equals(extY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
+		
+		if(extYFromFc == null || extYFromFc.getTypeParams() != xFromFc.getTypeParams())
+			return Optional.empty();
+
+		TypeParams extYParams = extY.getTypeParams();
+		TypeParams xParams = x.getTypeParams();
+		
+		int[] pi = pi(xParams, extYParams);
+		
+		if(pi.length == 0)
+			return Optional.empty();
+		
+		Set<UnifyPair> result = new HashSet<>();
+		
+		for(int rhsIdx = 0; rhsIdx < extYParams.size(); rhsIdx++)
+			result.add(new UnifyPair(xParams.get(pi[rhsIdx]), extYParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
+		
+		return Optional.of(result);
+	}
+
+	static Optional<Set<UnifyPair>> reduceSup(UnifyPair pair, IFiniteClosure fc) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType x = pair.getLhsType();
+		UnifyType sTypeX;
+		
+		if(x instanceof ReferenceType)
+			sTypeX = x;
+		else if(x instanceof SuperType)
+			sTypeX = ((SuperType) x).getSuperedType();
+		else
+			return Optional.empty();
+		
+		UnifyType supY = pair.getRhsType();
+		
+		if(!(supY instanceof SuperType))
+			return Optional.empty();
+
+		if(x.getTypeParams().empty() || supY.getTypeParams().size() != x.getTypeParams().size())
+			return Optional.empty();
+		
+		UnifyType xFromFc = fc.getLeftHandedType(sTypeX.getName()).orElse(null);
+		
+		if(xFromFc == null || !xFromFc.getTypeParams().arePlaceholders())
+			return Optional.empty();
+		
+		if(x instanceof SuperType)
+			xFromFc = new SuperType(xFromFc);
+		
+		UnifyType supYFromFc = fc.grArg(xFromFc, new HashSet<>()).stream().filter(t -> t.getName().equals(supY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
+		
+		if(supYFromFc == null || supYFromFc.getTypeParams() != xFromFc.getTypeParams())
+			return Optional.empty();
+		
+		TypeParams supYParams = supY.getTypeParams();
+		TypeParams xParams = x.getTypeParams();
+		Set<UnifyPair> result = new HashSet<>();
+		
+		int[] pi = pi(xParams, supYParams);
+		
+		if(pi.length == 0)
+			return Optional.empty();
+		
+		for(int rhsIdx = 0; rhsIdx < supYParams.size(); rhsIdx++)
+			result.add(new UnifyPair(supYParams.get(rhsIdx), xParams.get(pi[rhsIdx]), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
+		
+		return Optional.of(result);
+	}
+
+	static Optional<Set<UnifyPair>> reduceEq(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		if(lhsType instanceof PlaceholderType || lhsType.getTypeParams().empty())
+			return Optional.empty();
+		
+		UnifyType rhsType = pair.getRhsType();
+		
+		if(!rhsType.getName().equals(lhsType.getName()))
+			return Optional.empty();
+		
+		if(rhsType instanceof PlaceholderType || lhsType instanceof PlaceholderType || rhsType.getTypeParams().empty())
+			return Optional.empty();
+		
+		if(rhsType.getTypeParams().size() != lhsType.getTypeParams().size())
+			return Optional.empty();
+		
+		// Keine Permutation wie im Paper nötig
+		Set<UnifyPair> result = new HashSet<>();
+		TypeParams lhsTypeParams = lhsType.getTypeParams();
+		TypeParams rhsTypeParams = rhsType.getTypeParams();
+		
+		for(int i = 0; i < lhsTypeParams.size(); i++)
+			result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+		
+		return Optional.of(result);
+	}
+
+	static Optional<Set<UnifyPair>> reduce1(UnifyPair pair, IFiniteClosure fc) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOT)
+			return Optional.empty();
+		
+		UnifyType c = pair.getLhsType();
+		if(!(c instanceof ReferenceType))
+			return Optional.empty();
+		
+		UnifyType d = pair.getRhsType();
+		if(!(d instanceof ReferenceType))
+			return Optional.empty();
+		
+		ReferenceType lhsSType = (ReferenceType) c;
+		ReferenceType rhsSType = (ReferenceType) d;
+		
+		//try {
+		//	logFile.write("PAIR Rules: " + pair + "\n");
+		//	logFile.flush();
+		//}
+		//catch (IOException e) { }
+		
+		if(lhsSType.getTypeParams().empty() || lhsSType.getTypeParams().size() != rhsSType.getTypeParams().size())
+			return Optional.empty();
+		
+		UnifyType cFromFc = fc.getLeftHandedType(c.getName()).orElse(null);
+		//2018-02-23: liefert Vector<Vector<Integer>>: Das kann nicht sein.
+		
+		//NOCHMAL UEBERPRUEFEN
+		//PL 18-02-09 Eingfuegt Anfang
+		//C und D koennen auch gleich sein.
+		if (c.getName().equals(d.getName())) {
+			Set<UnifyPair> result = new HashSet<>();
+			TypeParams rhsTypeParams = d.getTypeParams();
+			TypeParams lhsTypeParams = c.getTypeParams();
+			for(int rhsIdx = 0; rhsIdx < c.getTypeParams().size(); rhsIdx++)
+				result.add(new UnifyPair(lhsTypeParams.get(rhsIdx), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
+		
+			return Optional.of(result);
+		}
+		//PL 18-02-09 Eingfuegt ENDE
+		
+		//try {
+		//	logFile.write("cFromFc: " + cFromFc);
+		//	logFile.flush();
+		//}
+		//catch (IOException e) { }
+		
+		if(cFromFc == null || !cFromFc.getTypeParams().arePlaceholders())
+			return Optional.empty();
+		
+		UnifyType dFromFc = fc.getAncestors(cFromFc).stream().filter(x -> x.getName().equals(d.getName())).findAny().orElse(null);
+		
+		//try {
+		//	logFile.write("cFromFc: " + cFromFc);
+		//	logFile.flush();
+		//}
+		//catch (IOException e) { }
+		
+		if(dFromFc == null || !dFromFc.getTypeParams().arePlaceholders() || dFromFc.getTypeParams().size() != cFromFc.getTypeParams().size())
+			return Optional.empty();
+		//System.out.println("cFromFc: " + cFromFc);
+		//System.out.println("dFromFc: " + dFromFc);
+		int[] pi = pi(cFromFc.getTypeParams(), dFromFc.getTypeParams());
+		
+		if(pi.length == 0)
+			return Optional.empty();
+		
+		TypeParams rhsTypeParams = d.getTypeParams();
+		TypeParams lhsTypeParams = c.getTypeParams();
+		Set<UnifyPair> result = new HashSet<>();
+		
+		for(int rhsIdx = 0; rhsIdx < rhsTypeParams.size(); rhsIdx++)
+			result.add(new UnifyPair(lhsTypeParams.get(pi[rhsIdx]), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
+		
+		return Optional.of(result);
+	}
+
+	static Optional<Set<UnifyPair>> reduce2(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.EQUALSDOT)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		ReferenceType lhsSType;
+		UnifyType rhsType = pair.getRhsType();
+		ReferenceType rhsSType;
+		
+		if ((lhsType instanceof ReferenceType) && (rhsType instanceof ReferenceType)) {
+			lhsSType = (ReferenceType) lhsType;
+			rhsSType = (ReferenceType) rhsType;
+		}
+		else if (((lhsType instanceof ExtendsType) && (rhsType instanceof ExtendsType)) 
+				|| ((lhsType instanceof SuperType) && (rhsType instanceof SuperType))) {
+			UnifyType lhsSTypeRaw = ((WildcardType) lhsType).getWildcardedType();
+			UnifyType rhsSTypeRaw = ((WildcardType) rhsType).getWildcardedType();
+			if ((lhsSTypeRaw instanceof ReferenceType) && (rhsSTypeRaw instanceof ReferenceType)) {
+				lhsSType = (ReferenceType) lhsSTypeRaw;
+				rhsSType = (ReferenceType) rhsSTypeRaw;
+			}
+			else
+				return Optional.empty();
+		}
+		else
+			return Optional.empty();
+		
+		if(lhsSType.getTypeParams().empty())
+			return Optional.empty();
+
+		if(!rhsSType.getName().equals(lhsSType.getName()))
+			return Optional.empty();
+		
+		if(!(lhsSType.getTypeParams().size()==rhsSType.getTypeParams().size()))throw new DebugException("Fehler in Unifizierung"+ " " + lhsSType.toString() + " " + rhsSType.toString());
+		//if(rhsSType.getTypeParams().size() != lhsSType.getTypeParams().size())
+		//	return Optional.empty();
+		
+		Set<UnifyPair> result = new HashSet<>();
+		
+		TypeParams rhsTypeParams = rhsSType.getTypeParams();
+		TypeParams lhsTypeParams = lhsSType.getTypeParams();
+		for(int i = 0; i < rhsTypeParams.size(); i++)
+			result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+		
+		return Optional.of(result);
+	}
+
+	static boolean erase1(UnifyPair pair, IFiniteClosure fc) {
+		if((pair.getPairOp() != PairOperator.SMALLERDOT) && (pair.getPairOp() != PairOperator.SMALLERNEQDOT))
+			return false;
+		
+		if (pair.getPairOp() == PairOperator.SMALLERNEQDOT) {
+			UnifyType lhs = pair.getLhsType();
+			UnifyType rhs = pair.getRhsType();
+			if (lhs instanceof WildcardType) {
+				lhs = ((WildcardType)lhs).getWildcardedType();
+			}
+			if (rhs instanceof WildcardType) {
+				rhs = ((WildcardType)rhs).getWildcardedType();
+			}
+		
+			if	(lhs.equals(rhs)){
+				return false;
+			}
+		}
+		
+		UnifyType lhsType = pair.getLhsType();
+		if(!(lhsType instanceof ReferenceType) && !(lhsType instanceof PlaceholderType))
+			return false;
+		
+		UnifyType rhsType = pair.getRhsType();
+		if(!(rhsType instanceof ReferenceType) && !(rhsType instanceof PlaceholderType))
+			return false;
+		
+		return fc.greater(lhsType, new HashSet<>()).contains(rhsType);
+	}
+
+	static boolean erase2(UnifyPair pair, IFiniteClosure fc) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return false;
+		
+		UnifyType lhsType = pair.getLhsType();		
+		UnifyType rhsType = pair.getRhsType();
+		
+		return fc.grArg(lhsType, new HashSet<>()).contains(rhsType);
+	}
+
+	static boolean erase3(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.EQUALSDOT)
+			return false;
+		
+		return pair.getLhsType().equals(pair.getRhsType());
+	}
+
+	static Optional<UnifyPair> swap(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.EQUALSDOT)
+			return Optional.empty();
+		
+		if(pair.getLhsType() instanceof PlaceholderType)
+			return Optional.empty();
+		
+		if(!(pair.getRhsType() instanceof PlaceholderType))
+			return Optional.empty();
+		
+		return Optional.of(new UnifyPair(pair.getRhsType(), pair.getLhsType(), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	static Optional<UnifyPair> adapt(UnifyPair pair, IFiniteClosure fc) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOT)
+			return Optional.empty();
+		
+		UnifyType typeD = pair.getLhsType();
+		if(!(typeD instanceof ReferenceType))
+			return Optional.empty();
+		
+		UnifyType typeDs = pair.getRhsType();
+		if(!(typeDs instanceof ReferenceType))
+			return Optional.empty();
+		
+		/*if(typeD.getTypeParams().size() == 0 || typeDs.getTypeParams().size() == 0)
+			return Optional.empty();*/
+		
+		if(typeD.getName().equals(typeDs.getName()))
+			return Optional.empty();
+		
+
+		Optional<UnifyType> opt = fc.getLeftHandedType(typeD.getName());
+		if(!opt.isPresent())
+			return Optional.empty();
+		
+		// The generic Version of Type D (D<a1, a2, a3, ... >)
+		UnifyType typeDgen = opt.get();
+	
+		// Actually greater+ because the types are ensured to have different names
+		Set<UnifyType> greater = fc.getAncestors(typeDgen);
+		opt = greater.stream().filter(x -> x.getName().equals(typeDs.getName())).findAny();
+
+		if(!opt.isPresent())
+			return Optional.empty();
+		
+		UnifyType newLhs = opt.get();
+		
+		TypeParams typeDParams = typeD.getTypeParams();
+		TypeParams typeDgenParams = typeDgen.getTypeParams();
+
+		Unifier unif = Unifier.identity();
+		for(int i = 0; i < typeDParams.size(); i++) { 
+			//System.out.println("ADAPT" +typeDgenParams);
+			if (typeDgenParams.get(i) instanceof PlaceholderType) 
+			unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
+			else System.out.println("ERROR");
+		}
+		return Optional.of(new UnifyPair(unif.apply(newLhs), typeDs, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	static Optional<UnifyPair> adaptExt(UnifyPair pair, IFiniteClosure fc) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType typeD = pair.getLhsType();
+		if(!(typeD instanceof ReferenceType) && !(typeD instanceof ExtendsType))
+			return Optional.empty();
+		
+		UnifyType typeExtDs = pair.getRhsType();
+		if(!(typeExtDs instanceof ExtendsType))
+			return Optional.empty();
+		
+		if(typeD.getTypeParams().size() == 0 || typeExtDs.getTypeParams().size() == 0)
+			return Optional.empty();
+		
+		UnifyType typeDgen;
+		if(typeD instanceof ReferenceType)
+			typeDgen = fc.getLeftHandedType(typeD.getName()).orElse(null);
+		else {
+			Optional<UnifyType> opt = fc.getLeftHandedType(((ExtendsType) typeD).getExtendedType().getName());
+			typeDgen = opt.isPresent() ? new ExtendsType(opt.get()) : null;
+		}
+
+		if(typeDgen == null)
+			return Optional.empty();
+		
+		Set<UnifyType> grArg = fc.grArg(typeDgen, new HashSet<>());
+		
+		Optional<UnifyType> opt = grArg.stream().filter(x -> x.getName().equals(typeExtDs.getName())).findAny();
+
+		if(!opt.isPresent())
+			return Optional.empty();
+		
+		UnifyType newLhs = ((ExtendsType) opt.get()).getExtendedType();
+		
+		TypeParams typeDParams = typeD.getTypeParams();
+		TypeParams typeDgenParams = typeDgen.getTypeParams();
+		
+		Unifier unif = new Unifier((PlaceholderType) typeDgenParams.get(0), typeDParams.get(0));
+		for(int i = 1; i < typeDParams.size(); i++) 
+			unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
+		
+		return Optional.of(new UnifyPair(unif.apply(newLhs), typeExtDs, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	static Optional<UnifyPair> adaptSup(UnifyPair pair, IFiniteClosure fc) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType typeDs = pair.getLhsType();
+		if(!(typeDs instanceof ReferenceType) && !(typeDs instanceof SuperType))
+			return Optional.empty();
+		
+		UnifyType typeSupD = pair.getRhsType();
+		if(!(typeSupD instanceof SuperType))
+			return Optional.empty();
+		
+		if(typeDs.getTypeParams().size() == 0 || typeSupD.getTypeParams().size() == 0)
+			return Optional.empty();
+		
+		
+		Optional<UnifyType> opt = fc.getLeftHandedType(((SuperType) typeSupD).getSuperedType().getName());
+		
+		if(!opt.isPresent()) 
+			return Optional.empty();
+		
+		UnifyType typeDgen = opt.get();
+		UnifyType typeSupDgen = new SuperType(typeDgen);
+
+		// Use of smArg instead of grArg because
+		// a in grArg(b) => b in smArg(a)
+		Set<UnifyType> smArg = fc.smArg(typeSupDgen, new HashSet<>());
+		opt = smArg.stream().filter(x -> x.getName().equals(typeDs.getName())).findAny();
+
+		if(!opt.isPresent())
+			return Optional.empty();
+		
+		// New RHS
+		UnifyType newRhs = null;
+		if(typeDs instanceof ReferenceType)
+			newRhs = new ExtendsType(typeDs);
+		else
+			newRhs = new ExtendsType(((SuperType) typeDs).getSuperedType());
+		
+		// New LHS
+		UnifyType newLhs = opt.get();
+		TypeParams typeDParams = typeSupD.getTypeParams();
+		TypeParams typeSupDsgenParams = typeSupDgen.getTypeParams();
+		
+		Unifier unif = new Unifier((PlaceholderType) typeSupDsgenParams.get(0), typeDParams.get(0));
+		for(int i = 1; i < typeDParams.size(); i++) 
+			unif.add((PlaceholderType) typeSupDsgenParams.get(i), typeDParams.get(i));
+		
+		return Optional.of(new UnifyPair(unif.apply(newLhs), newRhs, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	/**
+	 * Finds the permutation pi of the type arguments of two types based on the finite closure
+	 * @param cArgs The type which arguments are permuted
+	 * @param dArgs The other type
+	 * @return An array containing the values of pi for every type argument of C or an empty array if the search failed.
+	 */
+	private static int[] pi(TypeParams cArgs, TypeParams dArgs) {
+		if(!(cArgs.size()==dArgs.size()))throw new DebugException("Fehler in Unifizierung");
+	
+		int[] permutation = new int[dArgs.size()];
+		
+		boolean succ = true;
+		for (int dArgIdx = 0; dArgIdx < dArgs.size() && succ; dArgIdx++) {
+			UnifyType dArg = dArgs.get(dArgIdx);
+			succ = false;
+			for (int pi = 0; pi < cArgs.size(); pi++)
+				if (cArgs.get(pi).getName().equals(dArg.getName())) {
+					permutation[dArgIdx] = pi;
+					succ = true;
+					break;
+				}
+		}
+
+		return succ ? permutation : new int[0];
+	}
+
+	static Optional<UnifyPair> reduceWildcardLow(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		if(!(lhsType instanceof ExtendsType) || !(rhsType instanceof ExtendsType))
+			return Optional.empty();
+		
+		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair())); 
+	}
+
+	static Optional<UnifyPair> reduceWildcardLowRight(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof ExtendsType))
+			return Optional.empty();
+		
+		return Optional.of(new UnifyPair(lhsType, ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	static Optional<UnifyPair> reduceWildcardUp(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		if(!(lhsType instanceof SuperType) || !(rhsType instanceof SuperType))
+			return Optional.empty();
+		
+		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), ((SuperType) lhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	static Optional<UnifyPair> reduceWildcardUpRight(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof SuperType))
+			return Optional.empty();
+		
+		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), lhsType, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	static Optional<Set<UnifyPair>> reduceFunN(UnifyPair pair) {
+		if((pair.getPairOp() != PairOperator.SMALLERDOT)  
+		  && (pair.getPairOp() != PairOperator.EQUALSDOT))     //PL 2017-10-03 hinzugefuegt  
+		                                                       //da Regel auch fuer EQUALSDOT anwendbar 
+			                                                   //TODO: fuer allen anderen Relationen noch pruefen
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		
+		if(!(lhsType instanceof FunNType) || !(rhsType instanceof FunNType))
+			return Optional.empty();
+
+		FunNType funNLhsType = (FunNType) lhsType;
+		FunNType funNRhsType = (FunNType) rhsType;
+		
+		if(funNLhsType.getN() != funNRhsType.getN())
+			return Optional.empty();
+		
+		Set<UnifyPair> result = new HashSet<UnifyPair>();
+		if (pair.getPairOp() == PairOperator.SMALLERDOT) { 
+			result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), funNRhsType.getTypeParams().get(funNRhsType.getTypeParams().size()-1), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+			for(int i = 0; i < funNLhsType.getTypeParams().size()-1; i++) {
+				result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+			}
+		}
+		else {// pair.getPairOp() == PairOperator.EQUALDOT
+			result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), funNRhsType.getTypeParams().get(funNRhsType.getTypeParams().size()-1), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+			for(int i = 0; i < funNLhsType.getTypeParams().size()-1; i++) {
+				result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), funNLhsType.getTypeParams().get(i), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+			}
+		}
+		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
+        								   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+        								   UnifyType r = x.getRhsType();
+        								   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
+								     } );
+		return Optional.of(result);
+	}
+
+	static Optional<Set<UnifyPair>> greaterFunN(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOT)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		
+		if(!(lhsType instanceof FunNType) || !(rhsType instanceof PlaceholderType))
+			return Optional.empty();
+
+		FunNType funNLhsType = (FunNType) lhsType;
+
+		Set<UnifyPair> result = new HashSet<UnifyPair>();
+		
+		Integer variance = ((PlaceholderType)rhsType).getVariance();
+		Integer inversVariance = distributeVariance.inverseVariance(variance);
+		
+		UnifyType[] freshPlaceholders = new UnifyType[funNLhsType.getTypeParams().size()];
+		for(int i = 0; i < freshPlaceholders.length-1; i++) {
+			freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
+			((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
+		}
+		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
+		((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
+		result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), freshPlaceholders[funNLhsType.getTypeParams().size()-1], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+		
+		for(int i = 0; i < funNLhsType.getTypeParams().size()-1; i++) {
+			result.add(new UnifyPair(freshPlaceholders[i], funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+		}
+		
+		result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+		
+		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
+									   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+									   UnifyType r = x.getRhsType();
+									   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
+									 } );
+		return Optional.of(result);
+	}
+
+	static Optional<Set<UnifyPair>> smallerFunN(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOT)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		
+		if(!(lhsType instanceof PlaceholderType) || !(rhsType instanceof FunNType))
+			return Optional.empty();
+
+		FunNType funNRhsType = (FunNType) rhsType;
+
+		Set<UnifyPair> result = new HashSet<UnifyPair>();
+		
+		Integer variance = ((PlaceholderType)lhsType).getVariance();
+		Integer inversVariance = distributeVariance.inverseVariance(variance);
+		
+		UnifyType[] freshPlaceholders = new UnifyType[funNRhsType.getTypeParams().size()];
+		for(int i = 0; i < freshPlaceholders.length-1; i++) {
+			freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
+			((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
+		}
+		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
+		((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
+		
+		result.add(new UnifyPair(freshPlaceholders[funNRhsType.getTypeParams().size()-1], funNRhsType.getTypeParams().get(funNRhsType.getTypeParams().size()-1), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+		
+		for(int i = 0; i < funNRhsType.getTypeParams().size()-1; i++) {
+			result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), freshPlaceholders[i], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+		}
+		
+		result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+		
+		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
+		   							   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+		   							   UnifyType r = x.getRhsType();
+		   							   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
+									 } );
+		return Optional.of(result);
+	}
+
+	static Optional<UnifyPair> reduceTph(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		if(!(lhsType instanceof PlaceholderType) || !(rhsType instanceof ReferenceType))
+			return Optional.empty();
+		
+		return Optional.of(new UnifyPair(lhsType, rhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+	}
+
+	static Optional<Set<UnifyPair>> reduceTphExt(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		if(!(lhsType instanceof ExtendsType) || !(rhsType instanceof PlaceholderType))
+			return Optional.empty();
+		
+		UnifyType extendedType = ((ExtendsType)lhsType).getExtendedType();
+		
+		if (extendedType.equals(rhsType)) return Optional.empty(); //PL 2019-02-18 eingefügt ? extends a <.? a
+		
+		boolean isGen = extendedType instanceof PlaceholderType && !((PlaceholderType) extendedType).isGenerated();
+		
+		Set<UnifyPair> result = new HashSet<>();
+		if(isGen)
+			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+		else {
+			UnifyType freshTph = PlaceholderType.freshPlaceholder();
+			result.add(new UnifyPair(rhsType, new ExtendsType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+			result.add(new UnifyPair(extendedType, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+		}
+		
+		return Optional.of(result);
+	}
+
+	static Optional<Set<UnifyPair>> reduceTphSup(UnifyPair pair) {
+		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
+			return Optional.empty();
+		
+		UnifyType lhsType = pair.getLhsType();
+		UnifyType rhsType = pair.getRhsType();
+		if(!(lhsType instanceof SuperType) || !(rhsType instanceof PlaceholderType))
+			return Optional.empty();
+		
+		UnifyType superedType = ((SuperType)lhsType).getSuperedType();
+		
+		if (superedType.equals(rhsType)) return Optional.empty(); //PL 2019-02-18 eingefügt ? super a <.? a
+		
+		boolean isGen = superedType instanceof PlaceholderType && !((PlaceholderType) superedType).isGenerated();
+		
+		Set<UnifyPair> result = new HashSet<>();
+		if(isGen)
+			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+		else {
+			UnifyType freshTph = PlaceholderType.freshPlaceholder();
+			result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+			Set<UnifyType> fBounded = pair.getfBounded();
+			fBounded.add(lhsType);
+			result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair(), fBounded));
+		}
+		
+		return Optional.of(result);
+	}
+}

src/main/java/de/dhbwstuttgart/unify2/TypeUnify.java

@@ -0,0 +1,54 @@
+package de.dhbwstuttgart.unify2;
+
+import de.dhbwstuttgart.typeinference.unify.model.*;
+import de.dhbwstuttgart.unify2.model.UnifyConstraintSet;
+
+import java.util.*;
+
+public class TypeUnify {
+
+    public static Optional<Set<UnifyPair>> unifyOrConstraints(UnifyConstraintSet eq, FiniteClosure fc){
+        return eq.cartesianProductParallel().map(eqPrime -> unify(eqPrime, fc)).filter(Optional::isPresent).map(Optional::get).findAny();
+    }
+
+    public static Optional<Set<UnifyPair>> unify(Set<UnifyPair> eq, FiniteClosure fc){
+        /*
+        TODO: Hier könnte man prüfen, ob es überhaupt einen Sinn macht mit eq weiterzumachen
+        Es könnte eine über threads geteiltes Objekt geben (Feld in TypeUnify), welches unmögliche Klauseln lernt
+         */
+
+        //Apply Reduce und Apply rules
+        Set<UnifyPair> res = RuleSet.applyTypeUnificationRules(eq, fc);
+        //Split result
+
+        /*
+         * Step 2 and 3: Create a subset eq1s of pairs where both sides are TPH and eq2s of the other pairs
+         */
+        Set<UnifyPair> eq1s = new HashSet<>();
+        Set<UnifyPair> eq2s = new HashSet<>();
+        for(UnifyPair pair : res) {
+            if (pair.getLhsType() instanceof PlaceholderType && pair.getRhsType() instanceof PlaceholderType)
+                eq1s.add(pair);
+            else
+                eq2s.add(pair);
+        }
+
+        Optional<UnifyConstraintSet> step4Res = Unify.step4(eq1s, eq2s, fc);
+
+        //Falls step4 etwas liefert, dann subst und rekursiver unify aufruf anwenden:
+        return step4Res.flatMap(constraintSet ->
+                constraintSet.cartesianProductParallel().map(toSubst -> {
+                    Optional<Set<UnifyPair>> substitutionResult = Unify.subst(toSubst); //hier substituieren
+                    //if it changed:
+                    if (substitutionResult.isPresent()) {
+                        return unify(substitutionResult.get(), fc);
+                    }else{
+                        //TODO: return the result
+                        return Optional.of(toSubst);
+                    }
+                }).filter(it -> it.isPresent()).map(Optional::get).findAny());
+    }
+
+
+
+}

src/main/java/de/dhbwstuttgart/unify2/Unify.java

@@ -0,0 +1,340 @@
+package de.dhbwstuttgart.unify2;
+
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.*;
+import de.dhbwstuttgart.unify2.model.UnifyConstraintSet;
+import de.dhbwstuttgart.unify2.model.UnifyOderConstraint;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class Unify {
+
+    /**
+     * Creates sets of pairs specified in the fourth step. Does not calculate cartesian products.
+     * @return The set of the eight cases (without empty sets). Each case is a set, containing sets generated
+     * from the pairs that matched the case. Each generated set contains singleton sets or sets with few elements
+     * (as in case 1 where sigma is added to the innermost set).
+     */
+    public static Optional<UnifyConstraintSet> step4(Set<UnifyPair> eq1s, Set<UnifyPair> eq2s, FiniteClosure fc) {
+        Set<UnifyOderConstraint> result = new HashSet<>(8);
+
+        for(UnifyPair pair : eq2s) {
+            PairOperator pairOp = pair.getPairOp();
+            UnifyType lhsType = pair.getLhsType();
+            UnifyType rhsType = pair.getRhsType();
+
+            // Case 1: (a <. Theta')
+            if(pairOp == PairOperator.SMALLERDOT && lhsType instanceof PlaceholderType)
+                result.add(unifyCase1((PlaceholderType) pair.getLhsType(), pair.getRhsType(), fc));
+
+                // Case 2: (a <.? ? ext Theta')
+            else if(pairOp == PairOperator.SMALLERDOTWC && lhsType instanceof PlaceholderType && rhsType instanceof ExtendsType)
+                result.add(unifyCase2((PlaceholderType) pair.getLhsType(), (ExtendsType) pair.getRhsType(), fc));
+
+                // Case 3: (a <.? ? sup Theta')
+            else if(pairOp == PairOperator.SMALLERDOTWC && lhsType instanceof PlaceholderType && rhsType instanceof SuperType)
+                result.add(unifyCase3((PlaceholderType) lhsType, (SuperType) rhsType, fc));
+
+                // Case 4 was replaced by an inference rule
+                // Case 4: (a <.? Theta')
+                //else if(pairOp == PairOperator.SMALLERDOTWC && lhsType instanceof PlaceholderType)
+                //	result.get(3).add(unifyCase4((PlaceholderType) lhsType, rhsType, fc));
+
+                // Case 5: (Theta <. a)
+            else if(pairOp == PairOperator.SMALLERDOT && rhsType instanceof PlaceholderType)
+                result.add(unifyCase5(lhsType, (PlaceholderType) rhsType, fc));
+
+                // Case 6 was replaced by an inference rule.
+                // Case 6: (? ext Theta <.? a)
+                //else if(pairOp == PairOperator.SMALLERDOTWC && lhsType instanceof ExtendsType && rhsType instanceof PlaceholderType)
+                //	result.get(5).add(unifyCase6((ExtendsType) lhsType, (PlaceholderType) rhsType, fc));
+
+                // Case 7 was replaced by an inference rule
+                // Case 7: (? sup Theta <.? a)
+                //else if(pairOp == PairOperator.SMALLERDOTWC && lhsType instanceof SuperType && rhsType instanceof PlaceholderType)
+                //	result.get(6).add(unifyCase7((SuperType) lhsType, (PlaceholderType) rhsType, fc));
+
+                // Case 8: (Theta <.? a)
+            else if(pairOp == PairOperator.SMALLERDOTWC && rhsType instanceof PlaceholderType)
+                result.add(unifyCase8(lhsType, (PlaceholderType) rhsType, fc));
+                // Case unknown: If a pair fits no other case, then the type unification has failed.
+                // Through application of the rules, every pair should have one of the above forms.
+                // Pairs that do not have one of the aboves form are contradictory.
+            else {
+                return Optional.empty();
+            }
+        }
+        result.add(new UnifyOderConstraint(Set.of(eq1s)));
+        // Filter empty sets or sets that only contain an empty set.
+        //Andi: Why? Should they exist? this should be an error then
+        return Optional.of(new UnifyConstraintSet(result));
+    }
+
+
+    /**
+     * Cartesian product Case 1: (a <. Theta')
+     */
+    static UnifyOderConstraint unifyCase1(PlaceholderType a, UnifyType thetaPrime, FiniteClosure fc) {
+        Set<Set<UnifyPair>> result = new HashSet<>();
+
+        boolean allGen = thetaPrime.getTypeParams().size() > 0;
+        for(UnifyType t : thetaPrime.getTypeParams())
+            if(!(t instanceof PlaceholderType) || !((PlaceholderType) t).isGenerated()) {
+                allGen = false;
+                break;
+            }
+
+        Set<UnifyType> cs = fc.getAllTypesByName(thetaPrime.getName());
+        cs.add(thetaPrime);
+
+        for(UnifyType c : cs) {
+            Set<UnifyType> thetaQs = fc.getChildren(c).stream().collect(Collectors.toCollection(HashSet::new));
+            //thetaQs.add(thetaPrime);
+            Set<UnifyType> thetaQPrimes = new HashSet<>();
+            TypeParams cParams = c.getTypeParams();
+            if(cParams.size() == 0)
+                thetaQPrimes.add(c);
+            else {
+                ArrayList<Set<UnifyType>> candidateParams = new ArrayList<>();
+
+                for(UnifyType param : cParams)
+                    candidateParams.add(fc.grArg(param, new HashSet<>()));
+
+                for(TypeParams tp : permuteParams(candidateParams))
+                    thetaQPrimes.add(c.setTypeParams(tp));
+            }
+
+            for(UnifyType tqp : thetaQPrimes) {
+                Optional<Unifier> opt = MartelliMontanariUnify.unify(tqp, thetaPrime);
+                if (!opt.isPresent())
+                    continue;
+
+                Unifier unifier = opt.get();
+                unifier.swapPlaceholderSubstitutions(thetaPrime.getTypeParams());
+                Set<UnifyPair> substitutionSet = new HashSet<>();
+                for (Map.Entry<PlaceholderType, UnifyType> sigma : unifier)
+                    substitutionSet.add(new UnifyPair(sigma.getKey(), sigma.getValue(), PairOperator.EQUALSDOT));
+
+                List<UnifyType> freshTphs = new ArrayList<>();
+                for (UnifyType tq : thetaQs) {
+                    Set<UnifyType> smaller = fc.smaller(unifier.apply(tq), new HashSet<>());
+                    for(UnifyType theta : smaller) {
+                        Set<UnifyPair> resultPrime = new HashSet<>();
+
+                        for(int i = 0; !allGen && i < theta.getTypeParams().size(); i++) {
+                            if(freshTphs.size()-1 < i)
+                                freshTphs.add(PlaceholderType.freshPlaceholder());
+                            resultPrime.add(new UnifyPair(freshTphs.get(i), theta.getTypeParams().get(i), PairOperator.SMALLERDOTWC));
+                        }
+
+                        if(allGen)
+                            resultPrime.add(new UnifyPair(a, theta, PairOperator.EQUALSDOT));
+                        else
+                            resultPrime.add(new UnifyPair(a, theta.setTypeParams(new TypeParams(freshTphs.toArray(new UnifyType[0]))), PairOperator.EQUALSDOT));
+                        resultPrime.addAll(substitutionSet);
+                        result.add(resultPrime);
+                    }
+                }
+
+            }
+        }
+
+        return new UnifyOderConstraint(result);
+    }
+
+    /**
+     * Takes a set of candidates for each position and computes all possible permutations.
+     * @param candidates The length of the list determines the number of type params. Each set
+     * contains the candidates for the corresponding position.
+     */
+    static Set<TypeParams> permuteParams(ArrayList<Set<UnifyType>> candidates) {
+        Set<TypeParams> result = new HashSet<>();
+        permuteParams(candidates, 0, result, new UnifyType[candidates.size()]);
+        return result;
+    }
+
+    /**
+     * Takes a set of candidates for each position and computes all possible permutations.
+     * @param candidates The length of the list determines the number of type params. Each set
+     * contains the candidates for the corresponding position.
+     * @param idx Idx for the current permutatiton.
+     * @param result Set of all permutations found so far
+     * @param current The permutation of type params that is currently explored
+     */
+    static void permuteParams(ArrayList<Set<UnifyType>> candidates, int idx, Set<TypeParams> result, UnifyType[] current) {
+        if(candidates.size() == idx) {
+            result.add(new TypeParams(Arrays.copyOf(current, current.length)));
+            return;
+        }
+
+        Set<UnifyType> localCandidates = candidates.get(idx);
+
+        for(UnifyType t : localCandidates) {
+            current[idx] = t;
+            permuteParams(candidates, idx+1, result, current);
+        }
+    }
+
+    /**
+     * Cartesian Product Case 2: (a <.? ? ext Theta')
+     */
+    static UnifyOderConstraint unifyCase2(PlaceholderType a, ExtendsType extThetaPrime, IFiniteClosure fc) {
+        Set<Set<UnifyPair>> result = new HashSet<>();
+
+        UnifyType aPrime = PlaceholderType.freshPlaceholder();
+        UnifyType extAPrime = new ExtendsType(aPrime);
+        UnifyType thetaPrime = extThetaPrime.getExtendedType();
+        Set<UnifyPair> resultPrime = new HashSet<>();
+        resultPrime.add(new UnifyPair(a, thetaPrime, PairOperator.SMALLERDOT));
+        result.add(resultPrime);
+
+        resultPrime = new HashSet<>();
+        resultPrime.add(new UnifyPair(a, extAPrime, PairOperator.EQUALSDOT));
+        resultPrime.add(new UnifyPair(aPrime, thetaPrime, PairOperator.SMALLERDOT));
+        result.add(resultPrime);
+        return new UnifyOderConstraint(result);
+    }
+
+    /**
+     * Cartesian Product Case 3: (a <.? ? sup Theta')
+     */
+    static UnifyOderConstraint unifyCase3(PlaceholderType a, SuperType subThetaPrime, IFiniteClosure fc) {
+        Set<Set<UnifyPair>> result = new HashSet<>();
+
+        UnifyType aPrime = PlaceholderType.freshPlaceholder();
+        UnifyType supAPrime = new SuperType(aPrime);
+        UnifyType thetaPrime = subThetaPrime.getSuperedType();
+        Set<UnifyPair> resultPrime = new HashSet<>();
+        resultPrime.add(new UnifyPair(thetaPrime, a, PairOperator.SMALLERDOT));
+        result.add(resultPrime);
+
+        resultPrime = new HashSet<>();
+        resultPrime.add(new UnifyPair(a, supAPrime, PairOperator.EQUALSDOT));
+        resultPrime.add(new UnifyPair(thetaPrime, aPrime, PairOperator.SMALLERDOT));
+        result.add(resultPrime);
+
+        return new UnifyOderConstraint(result);
+    }
+
+    /**
+     * Cartesian Product Case 5: (Theta <. a)
+     */
+    static UnifyOderConstraint unifyCase5(UnifyType theta, PlaceholderType a, IFiniteClosure fc) {
+        Set<Set<UnifyPair>> result = new HashSet<>();
+
+        boolean allGen = theta.getTypeParams().size() > 0;
+        for(UnifyType t : theta.getTypeParams())
+            if(!(t instanceof PlaceholderType) || !((PlaceholderType) t).isGenerated()) {
+                allGen = false;
+                break;
+            }
+
+        for(UnifyType thetaS : fc.greater(theta, new HashSet<>())) {
+            Set<UnifyPair> resultPrime = new HashSet<>();
+
+            UnifyType[] freshTphs = new UnifyType[thetaS.getTypeParams().size()];
+            for(int i = 0; !allGen && i < freshTphs.length; i++) {
+                freshTphs[i] = PlaceholderType.freshPlaceholder();
+                resultPrime.add(new UnifyPair(thetaS.getTypeParams().get(i), freshTphs[i], PairOperator.SMALLERDOTWC));
+            }
+
+            if(allGen)
+                resultPrime.add(new UnifyPair(a, thetaS, PairOperator.EQUALSDOT));
+            else
+                resultPrime.add(new UnifyPair(a, thetaS.setTypeParams(new TypeParams(freshTphs)), PairOperator.EQUALSDOT));
+            result.add(resultPrime);
+        }
+
+        return new UnifyOderConstraint(result);
+    }
+
+    /**
+     * Cartesian Product Case 8: (Theta <.? a)
+     */
+    static UnifyOderConstraint unifyCase8(UnifyType theta, PlaceholderType a, IFiniteClosure fc) {
+        Set<Set<UnifyPair>> result = new HashSet<>();
+        //for(UnifyType thetaS : fc.grArg(theta)) {
+        Set<UnifyPair> resultPrime = new HashSet<>();
+        resultPrime.add(new UnifyPair(a, theta, PairOperator.EQUALSDOT));
+        result.add(resultPrime);
+
+        UnifyType freshTph = PlaceholderType.freshPlaceholder();
+        resultPrime = new HashSet<>();
+        resultPrime.add(new UnifyPair(a, new ExtendsType(freshTph), PairOperator.EQUALSDOT));
+        resultPrime.add(new UnifyPair(theta, freshTph, PairOperator.SMALLERDOT));
+        result.add(resultPrime);
+
+        resultPrime = new HashSet<>();
+        resultPrime.add(new UnifyPair(a, new SuperType(freshTph), PairOperator.EQUALSDOT));
+        resultPrime.add(new UnifyPair(freshTph, theta, PairOperator.SMALLERDOT));
+        result.add(resultPrime);
+        //}
+
+        return new UnifyOderConstraint(result);
+    }
+
+    static Optional<Set<UnifyPair>> subst(Set<UnifyPair> pairs) {
+        HashMap<UnifyType, Integer> typeMap = new HashMap<>();
+
+        Stack<UnifyType> occuringTypes = new Stack<>();
+
+        for(UnifyPair pair : pairs) {
+            occuringTypes.push(pair.getLhsType());
+            occuringTypes.push(pair.getRhsType());
+        }
+
+        while(!occuringTypes.isEmpty()) {
+            UnifyType t1 = occuringTypes.pop();
+            if(!typeMap.containsKey(t1))
+                typeMap.put(t1, 0);
+            typeMap.put(t1, typeMap.get(t1)+1);
+
+            if(t1 instanceof ExtendsType)
+                occuringTypes.push(((ExtendsType) t1).getExtendedType());
+            if(t1 instanceof SuperType)
+                occuringTypes.push(((SuperType) t1).getSuperedType());
+            else
+                t1.getTypeParams().forEach(x -> occuringTypes.push(x));
+        }
+
+        Queue<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
+        ArrayList<UnifyPair> result = new ArrayList<UnifyPair>();
+        boolean applied = false;
+
+        while(!result1.isEmpty()) {
+            UnifyPair pair = result1.poll();
+            PlaceholderType lhsType = null;
+            UnifyType rhsType;
+
+            if(pair.getPairOp() == PairOperator.EQUALSDOT
+                    && pair.getLhsType() instanceof PlaceholderType)
+                lhsType = (PlaceholderType) pair.getLhsType();
+            rhsType = pair.getRhsType(); //PL eingefuegt 2017-09-29 statt !((rhsType = pair.getRhsType()) instanceof PlaceholderType)
+            if(lhsType != null
+                    //&& !((rhsType = pair.getRhsType()) instanceof PlaceholderType) //PL geloescht am 2017-09-29 Begründung: auch Typvariablen muessen ersetzt werden.
+                    && typeMap.get(lhsType) > 1  // The type occurs in more pairs in the set than just the recent pair.
+                    && !rhsType.getTypeParams().occurs(lhsType)
+                    && !((rhsType instanceof WildcardType) && ((WildcardType)rhsType).getWildcardedType().equals(lhsType))) //PL eigefuegt 2018-02-18
+            {
+                Unifier uni = new Unifier(lhsType,  rhsType);
+                result = result.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(ArrayList::new));
+                result1 = result1.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(LinkedList::new));
+
+                Function<? super Constraint<UnifyPair>,? extends Constraint<UnifyPair>> applyUni = b -> b.stream().map(
+                        x -> uni.apply(pair,x)).collect(Collectors.toCollection((b.getExtendConstraint() != null)
+                        ? () -> new Constraint<UnifyPair>(
+                        b.getExtendConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(Constraint::new)))
+                        : () -> new Constraint<UnifyPair>()
+                ));
+                applied = true;
+            }
+            result.add(pair);
+        }
+
+        return applied ? Optional.of(new HashSet<>(result)) : Optional.empty();
+    }
+
+}

src/main/java/de/dhbwstuttgart/unify2/UnifyResult.java

@@ -0,0 +1,11 @@
+package de.dhbwstuttgart.unify2;
+
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+
+import java.util.Set;
+
+public class UnifyResult {
+    public UnifyResult(Set<UnifyPair> toSubst) {
+
+    }
+}

src/main/java/de/dhbwstuttgart/unify2/model/UnifyConstraintSet.java

@@ -0,0 +1,124 @@
+package de.dhbwstuttgart.unify2.model;
+
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+
+import java.util.*;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/*
+OrC1 OrC2 OrC3 -> Constraints
+                Step4: OrC1 OrC2/c OrC3 OrC4
+
+Tiefensuche, neue UnifyConstraints erstellen
+
+Wie wird ConstraintSet geändert?
+
+wird nicht gebraucht:
+( map -> bei subst
+    Alle Constraints ändern, neues ConstraintSet zurückgeben )
+
+Step 4 bildet anschließend das karthesische Produkt und muss über alle Möglichkeiten iterieren
+die erste möglichkeit vom karthesischen produkt nehmen, subst schritt ausführen und mit dem Ergebnis (einzelnes Constraint Set) weiterarbeiten
+
+ */
+
+public class UnifyConstraintSet {
+    Set<UnifyOderConstraint> oderConstraints = new HashSet<>();
+
+    public UnifyConstraintSet(Set<UnifyOderConstraint> constraints){
+        if(constraints.isEmpty())throw new RuntimeException("Empty constraint set");
+        this.oderConstraints = constraints;
+    }
+
+    @Override
+    public String toString(){
+        BinaryOperator<String> b = (x, y) -> x+y;
+        return "ODER:" + this.oderConstraints.stream().reduce("", (x,y) -> x.toString()+ "\n"  +y, b);
+    }
+
+    /*
+    Cartesian product als optimierter Stream
+
+    - Ein Split teilt das Set so auf, dass der zweite Thread jedes zweite Element behandelt
+            - Ein thread der jedes zweite element behandelt wird gesplittet indem
+
+    1 2 1 2 1 2 1 2 => (o = 0, n = 2), (o = 1, n = 2)
+    1 2 1 3 1 2 1 3 => (o = 0, n = 2), (o = 1, n = 4), (o = 3, n = 4)
+
+     */
+    private class ConstraintSpliterator implements Spliterator<Set<UnifyPair>> {
+        private List<UnifyOderConstraint> constraints;
+        private long i = 0;
+        private long iterationFactor = 1;
+        private long max = 0;
+        private List<Integer> sizes;
+        private List<Long> bases = new ArrayList<>();
+
+        ConstraintSpliterator(List<UnifyOderConstraint> constraints){
+            this.constraints = constraints;
+            sizes = constraints.stream().map(UnifyOderConstraint::getSize).collect(Collectors.toList());
+            long base = 1;
+            for(int size : sizes){
+                bases.add(base);
+                base *= size;
+            }
+            i = 0;
+            max = estimateSize() - 1;
+        }
+
+        ConstraintSpliterator(List<UnifyOderConstraint> constraints, long start, long factor){
+            this(constraints);
+            i = start;
+            this.iterationFactor = factor;
+        }
+
+        @Override
+        public boolean tryAdvance(Consumer<? super Set<UnifyPair>> consumer) {
+            if(i > max) return false;
+            consumer.accept(get(i));
+            i++;
+            return true;
+        }
+
+        private Set<UnifyPair> get(long num){
+            Set<UnifyPair> ret = new HashSet<>();
+            Iterator<Long> baseIt = bases.iterator();
+            for(UnifyOderConstraint constraint : constraints){
+                ret.addAll(constraint.get((int) ((num/baseIt.next())%constraint.getSize())));
+            }
+            return ret;
+        }
+
+        @Override
+        public Spliterator<Set<UnifyPair>> trySplit() {
+            if(max - (i+iterationFactor * 2) < 0) return null;
+            long iNext = i + iterationFactor;
+            iterationFactor *= 2;
+            return new UnifyConstraintSet.ConstraintSpliterator(constraints, iNext, iterationFactor);
+        }
+
+        @Override
+        public long estimateSize() {
+            long ret = 1;
+            for (int size : sizes)ret*=size;
+            return ret;
+        }
+
+        @Override
+        public int characteristics() {
+            return ORDERED | SIZED | IMMUTABLE | NONNULL;
+        }
+    }
+
+    public Stream<Set<UnifyPair>> cartesianProductParallel(){
+        return StreamSupport.stream(new UnifyConstraintSet.ConstraintSpliterator(oderConstraints.stream().collect(Collectors.toList())), true);
+    }
+
+    public Stream<Set<UnifyPair>> cartesianProductParallel(Comparator<Set<UnifyPair>> prioritiser){
+        return StreamSupport.stream(new UnifyConstraintSet.ConstraintSpliterator(oderConstraints.stream().collect(Collectors.toList())), true);
+    }
+}

src/main/java/de/dhbwstuttgart/unify2/model/UnifyConstraintSetBuilder.java

@@ -0,0 +1,30 @@
+package de.dhbwstuttgart.unify2.model;
+
+import de.dhbwstuttgart.typeinference.unify.model.Pair;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class UnifyConstraintSetBuilder {
+
+    private Set<UnifyPair> undConstraints = new HashSet<>();
+    private Set<UnifyOderConstraint> oderConstraints = new HashSet<>();
+    private boolean done = false;
+
+    public void addUndConstraint(UnifyPair p){
+        undConstraints.add(p);
+    }
+
+    public void addOderConstraint(UnifyOderConstraint orConstraint) {
+        oderConstraints.add(orConstraint);
+    }
+
+    public UnifyConstraintSet build(){
+        if(done)throw new RuntimeException("Trying to build cartesian product twice");
+        this.done = true;
+        if(!undConstraints.isEmpty())
+            oderConstraints.add(new UnifyOderConstraint(Set.of(undConstraints)));
+        return new UnifyConstraintSet(oderConstraints);
+    }
+}

src/main/java/de/dhbwstuttgart/unify2/model/UnifyOderConstraint.java

@@ -0,0 +1,27 @@
+package de.dhbwstuttgart.unify2.model;
+
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class UnifyOderConstraint {
+
+    private final List<Set<UnifyPair>> cons;
+    public UnifyOderConstraint(Set<Set<UnifyPair>> orCons){
+        if(orCons.isEmpty())throw new RuntimeException("Empty constraint set");
+        for(Set<UnifyPair> c : orCons){
+            if(c.isEmpty())throw new RuntimeException("Empty constraint set");
+        }
+        this.cons = orCons.stream().collect(Collectors.toList());
+    }
+
+    public int getSize(){
+        return cons.size();
+    }
+
+    public Set<UnifyPair> get(int l) {
+        return cons.get(l);
+    }
+}

src/test/java/AllgemeinTest.java

@@ -40,7 +40,7 @@ public class AllgemeinTest {
 		//String className = "FCTest3";
 		//String className = "Var";
 		//String className = "Put";
-		String className = "Twice";
+		String className = "Cycle";
 		//PL 2019-10-24: genutzt fuer unterschiedliche Tests
 		path = System.getProperty("user.dir")+"/src/test/resources/AllgemeinTest/" + className + ".jav";
 		//path = System.getProperty("user.dir")+"/src/test/resources/AllgemeinTest/Overloading_Generics.jav";

src/test/java/inferWildcards/TestInferWildcardsFields.java

@@ -1,148 +0,0 @@
-package inferWildcards;
-
-import static org.junit.Assert.assertThat;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.hamcrest.CoreMatchers;
-import org.junit.Before;
-import org.junit.Test;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
-import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
-import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
-import de.dhbwstuttgart.typeinference.result.ResultPair;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-
-public class TestInferWildcardsFields
-{
-
-	private String resourceFilePath;
-	private String resourceDirPath;
-
-	@Before
-	public void setup () {
-		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
-		resourceFilePath = resourceDirPath + "/TestClassWildcardsFields.java";
-	}
-
-	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompiler(files1);
-	}
-
-	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompilerWildcards(files1);
-	}
-
-	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
-			JavaTXCompiler javaTXCompiler) {
-		System.out.println("\nReplacements:");
-
-		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
-	}
-
-	private static List<ResultSet> generateExpectedTypeInferResult (JavaTXCompilerWildcards compiler) {
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = compiler.getTphMap();
-
-		ArrayList<ResultSet> list = new ArrayList<>();
-
-		tphMap.forEach( (tph, t) -> {
-			ResultPair r = new PairTPHequalRefTypeOrWildcardType(tph,
-					new RefType(new JavaClassName("java.lang.String"), new NullToken()));
-			HashSet<ResultPair> set = new HashSet<>();
-			set.add(r);
-			list.add(new ResultSet(set));
-		});
-		
-		return list;
-	}
-
-	@Test
-	public void testGenerateTph () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate TPH --------------\n");
-
-		JavaTXCompiler javaTXCompiler = getStandardCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
-				javaTXCompiler);
-
-		System.out.println(generateTph);
-		
-		assertThat("Number of TPH is 4", 4, CoreMatchers.is(generateTph.size()));
-	}
-
-	@Test
-	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
-				.getTphMap();
-		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
-
-		System.out.println(generateConstraints);
-
-		int size = 0;
-		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
-			for (Constraint<Pair> c : l)
-				size += c.size();
-
-		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
-	}
-
-	@Test
-	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Combined Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
-
-		System.out.println(constraints);
-	}
-
-	@Test
-	public void testTypeInference () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
-
-		System.out.println(typeInference);
-
-		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
-				CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-}

src/test/java/inferWildcards/TestInferWildcardsMap.java

@@ -1,125 +0,0 @@
-package inferWildcards;
-
-import static org.junit.Assert.assertThat;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.hamcrest.CoreMatchers;
-import org.junit.Before;
-import org.junit.Test;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
-import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
-import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-
-public class TestInferWildcardsMap
-{
-
-	private String resourceFilePath;
-	private String resourceDirPath;
-
-	@Before
-	public void setup () {
-		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
-		resourceFilePath = resourceDirPath + "/TestClassWildcardsMap.java";
-	}
-
-	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompiler(files1);
-	}
-
-	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompilerWildcards(files1);
-	}
-
-	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
-			JavaTXCompiler javaTXCompiler) {
-		System.out.println("\nReplacements:");
-
-		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
-	}
-
-	@Test
-	public void testGenerateTph () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate TPH --------------\n");
-
-		JavaTXCompiler javaTXCompiler = getStandardCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
-				javaTXCompiler);
-
-		System.out.println(generateTph);
-		
-		assertThat("Number of TPH is 6", 6, CoreMatchers.is(generateTph.size()));
-	}
-
-	@Test
-	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
-				.getTphMap();
-		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
-
-		System.out.println(generateConstraints);
-
-		int size = 0;
-		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
-			for (Constraint<Pair> c : l)
-				size += c.size();
-
-		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
-	}
-
-	@Test
-	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Combined Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
-
-		System.out.println(constraints);
-	}
-
-	@Test
-	public void testTypeInference () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
-
-		System.out.println(typeInference);
-
-		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
-				CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-		
-		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-}

src/test/java/inferWildcards/TestInferWildcardsMapNested.java

@@ -1,126 +0,0 @@
-package inferWildcards;
-
-import static org.junit.Assert.assertThat;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.hamcrest.CoreMatchers;
-import org.junit.Before;
-import org.junit.Test;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
-import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
-import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-
-public class TestInferWildcardsMapNested
-{
-
-	private String resourceFilePath;
-	private String resourceDirPath;
-
-	@Before
-	public void setup () {
-		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
-		resourceFilePath = resourceDirPath + "/TestClassWildcardsMapNested.java";
-	}
-
-
-	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompiler(files1);
-	}
-
-	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompilerWildcards(files1);
-	}
-
-	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
-			JavaTXCompiler javaTXCompiler) {
-		System.out.println("\nReplacements:");
-
-		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
-	}
-
-	@Test
-	public void testGenerateTph () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate TPH --------------\n");
-
-		JavaTXCompiler javaTXCompiler = getStandardCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
-				javaTXCompiler);
-
-		System.out.println(generateTph);
-		
-		assertThat("Number of TPH is 9", 9, CoreMatchers.is(generateTph.size()));
-	}
-
-	@Test
-	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
-				.getTphMap();
-		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
-
-		System.out.println(generateConstraints);
-
-		int size = 0;
-		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
-			for (Constraint<Pair> c : l)
-				size += c.size();
-
-		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
-	}
-
-	@Test
-	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Combined Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
-
-		System.out.println(constraints);
-	}
-
-	@Test
-	public void testTypeInference () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
-
-		System.out.println(typeInference);
-
-		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
-				CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-}

src/test/java/inferWildcards/TestInferWildcardsNested.java

@@ -1,125 +0,0 @@
-package inferWildcards;
-
-import static org.junit.Assert.assertThat;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.hamcrest.CoreMatchers;
-import org.junit.Before;
-import org.junit.Test;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
-import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
-import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-
-public class TestInferWildcardsNested
-{
-
-	private String resourceFilePath;
-	private String resourceDirPath;
-
-	@Before
-	public void setup () {
-		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
-		resourceFilePath = resourceDirPath + "/TestClassWildcardsNested.java";
-	}
-
-	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompiler(files1);
-	}
-
-	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompilerWildcards(files1);
-	}
-
-	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
-			JavaTXCompiler javaTXCompiler) {
-		System.out.println("\nReplacements:");
-
-		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
-	}
-
-	@Test
-	public void testGenerateTph () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate TPH --------------\n");
-
-		JavaTXCompiler javaTXCompiler = getStandardCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
-				javaTXCompiler);
-
-		System.out.println(generateTph);
-		
-		assertThat("Number of TPH is 6", 6, CoreMatchers.is(generateTph.size()));
-	}
-
-	@Test
-	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
-				.getTphMap();
-		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
-
-		System.out.println(generateConstraints);
-
-		int size = 0;
-		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
-			for (Constraint<Pair> c : l)
-				size += c.size();
-
-		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
-	}
-
-	@Test
-	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Combined Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
-
-		System.out.println(constraints);
-	}
-
-	@Test
-	public void testTypeInference () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
-
-		System.out.println(typeInference);
-
-		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
-				CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-}

src/test/java/inferWildcards/TestInferWildcardsParamType.java

@@ -1,125 +0,0 @@
-package inferWildcards;
-
-import static org.junit.Assert.assertThat;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.hamcrest.CoreMatchers;
-import org.junit.Before;
-import org.junit.Test;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
-import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
-import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-
-public class TestInferWildcardsParamType
-{
-
-	private String resourceFilePath;
-	private String resourceDirPath;
-
-	@Before
-	public void setup () {
-		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
-		resourceFilePath = resourceDirPath + "/TestClassWildcardsParamType.java";
-	}
-
-	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompiler(files1);
-	}
-
-	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompilerWildcards(files1);
-	}
-
-	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
-			JavaTXCompiler javaTXCompiler) {
-		System.out.println("\nReplacements:");
-
-		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
-	}
-
-	@Test
-	public void testGenerateTph () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate TPH --------------\n");
-
-		JavaTXCompiler javaTXCompiler = getStandardCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
-				javaTXCompiler);
-
-		System.out.println(generateTph);
-		
-		assertThat("Number of TPH is 4", 4, CoreMatchers.is(generateTph.size()));
-	}
-
-	@Test
-	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
-				.getTphMap();
-		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
-
-		System.out.println(generateConstraints);
-
-		int size = 0;
-		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
-			for (Constraint<Pair> c : l)
-				size += c.size();
-
-		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
-	}
-
-	@Test
-	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Combined Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
-
-		System.out.println(constraints);
-	}
-
-	@Test
-	public void testTypeInference () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
-
-		System.out.println(typeInference);
-
-		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
-				CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-}

src/test/java/inferWildcards/TestInferWildcardsSingle.java

@@ -1,125 +0,0 @@
-package inferWildcards;
-
-import static org.junit.Assert.assertThat;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.hamcrest.CoreMatchers;
-import org.junit.Before;
-import org.junit.Test;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
-import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
-import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-
-public class TestInferWildcardsSingle
-{
-
-	private String resourceFilePath;
-	private String resourceDirPath;
-
-	@Before
-	public void setup () {
-		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
-		resourceFilePath = resourceDirPath + "/TestClassWildcardsSingle.java";
-	}
-
-	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompiler(files1);
-	}
-
-	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompilerWildcards(files1);
-	}
-
-	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
-			JavaTXCompiler javaTXCompiler) {
-		System.out.println("\nReplacements:");
-
-		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
-	}
-
-	@Test
-	public void testGenerateTph () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate TPH --------------\n");
-
-		JavaTXCompiler javaTXCompiler = getStandardCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
-				javaTXCompiler);
-
-		System.out.println(generateTph);
-		
-		assertThat("Number of TPH is 3", 3, CoreMatchers.is(generateTph.size()));
-	}
-
-	@Test
-	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
-				.getTphMap();
-		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
-
-		System.out.println(generateConstraints);
-
-		int size = 0;
-		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
-			for (Constraint<Pair> c : l)
-				size += c.size();
-
-		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
-	}
-
-	@Test
-	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Combined Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
-
-		System.out.println(constraints);
-	}
-
-	@Test
-	public void testTypeInference () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
-
-		System.out.println(typeInference);
-
-		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
-				CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-}

src/test/java/inferWildcards/TestInferWildcardsSingleLib.java

@@ -1,125 +0,0 @@
-package inferWildcards;
-
-import static org.junit.Assert.assertThat;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.hamcrest.CoreMatchers;
-import org.junit.Before;
-import org.junit.Test;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
-import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
-import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-
-public class TestInferWildcardsSingleLib
-{
-
-	private String resourceFilePath;
-	private String resourceDirPath;
-
-	@Before
-	public void setup () {
-		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
-		resourceFilePath = resourceDirPath + "/TestClassWildcardsSingleLib.java";
-	}
-
-	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompiler(files1);
-	}
-
-	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
-		File[] files1 = { new File(resourceFilePath) };
-		return new JavaTXCompilerWildcards(files1);
-	}
-
-	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
-			JavaTXCompiler javaTXCompiler) {
-		System.out.println("\nReplacements:");
-
-		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
-	}
-
-	@Test
-	public void testGenerateTph () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate TPH --------------\n");
-
-		JavaTXCompiler javaTXCompiler = getStandardCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
-				javaTXCompiler);
-
-		System.out.println(generateTph);
-		
-		assertThat("Number of TPH is 2", 2, CoreMatchers.is(generateTph.size()));
-	}
-
-	@Test
-	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Generate Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
-				.getTphMap();
-		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
-
-		System.out.println(generateConstraints);
-
-		int size = 0;
-		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
-			for (Constraint<Pair> c : l)
-				size += c.size();
-
-		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
-	}
-
-	@Test
-	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
-		System.out.println("\n--------- Test Combined Constraints --------------\n");
-
-		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
-		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
-
-		System.out.println(constraints);
-	}
-
-	@Test
-	public void testTypeInference () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
-
-		System.out.println(typeInference);
-
-		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
-				CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-
-	@Test
-	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
-		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
-
-		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
-
-		assertThat("Generation Succeeded", null, CoreMatchers.anything());
-	}
-}

src/test/java/insertGenerics/FamilyOfGeneratedGenericsTest.java

@@ -29,6 +29,13 @@ public class FamilyOfGeneratedGenericsTest extends TestCase {
         List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(inputConstraints, tphPositions);
         assertTrue(classConstraints.isEmpty());
 
+        /*
+        MethodConstraints should be the same as the input constraint
+         */
+        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(inputConstraints, new ArrayList<ClassConstraint>(), tphPositions);
+        assertTrue(methodConstraints.size() == 2);
+        assertTrue(methodConstraints.get(0).getLeft().equals("B"));
+        assertTrue(methodConstraints.get(0).getRight().equals("A"));
     }
 
     public void testClassField(){
@@ -102,8 +109,12 @@ public class FamilyOfGeneratedGenericsTest extends TestCase {
 
         List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(inputConstraints, tphPositions);
         System.out.println(classConstraints);
+        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(inputConstraints, classConstraints, tphPositions);
+        System.out.println(methodConstraints);
         assertFalse(classConstraints.isEmpty());
         assertTrue(classConstraints.size() == 6);
+        assertFalse(methodConstraints.isEmpty());
+        assertTrue(methodConstraints.size() == 5);
 
     }
 
@@ -158,6 +169,13 @@ public class FamilyOfGeneratedGenericsTest extends TestCase {
 
         List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(inputConstraints, tphPositions);
         System.out.println(classConstraints);
+        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(inputConstraints, classConstraints, tphPositions);
+        System.out.println(methodConstraints);
+
+        assertFalse(classConstraints.isEmpty());
+        assertTrue(classConstraints.size() == 3);
+        assertFalse(methodConstraints.isEmpty());
+        assertTrue(methodConstraints.size()==9);
     }
 
 

src/test/java/insertGenerics/TestExample42.java

@@ -6,6 +6,7 @@ import de.dhbwstuttgart.bytecode.insertGenerics.*;
 import org.junit.Test;
 import static org.junit.Assert.assertEquals;
 
+import java.io.BufferedReader;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -54,6 +55,8 @@ public class TestExample42 {
     public void genericTest() {
         List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(fillConstraintsList(),fillPosOfTphs());
         System.out.println("ClassConstraints: " + classConstraints);
+        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(fillConstraintsList(),classConstraints,fillPosOfTphs());
+        System.out.println("MethodConstraints: " + methodConstraints);
 
         List<TPHConstraint> testCons;
     }

src/test/java/insertGenerics/TestExample42_allInOneMethod.java

@@ -53,6 +53,8 @@ public class TestExample42_allInOneMethod {
     public void genericTest() {
         List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(fillConstraintsList(),fillPosOfTphs());
         System.out.println("ClassConstraints: " + classConstraints);
+        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(fillConstraintsList(),classConstraints,fillPosOfTphs());
+        System.out.println("MethodConstraints: " + methodConstraints);
 
         List<TPHConstraint> testCons;
     }

src/test/java/typeinference/ConstraintSetTests.java

@@ -0,0 +1,62 @@
+package typeinference;
+
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSetBuilder;
+import de.dhbwstuttgart.typeinference.constraints.OderConstraint;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class ConstraintSetTests {
+    @Test
+    public void cartesianProductTestSingleConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 1;
+    }
+
+    @Test
+    public void cartesianProductTestSingleOderConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 2;
+    }
+
+    @Test
+    public void cartesianProductTestTwoOderConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 4;
+    }
+
+    @Test
+    public void cartesianProductTestThreeOderConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 4;
+
+        ConstraintSetBuilder builder2 = new ConstraintSetBuilder();
+        builder2.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder2.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder2.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        List<Set<Pair>> result2 = builder2.build().cartesianProductParallel().collect(Collectors.toList());
+        
+        assert result2.stream().map( a -> a.stream().map(p -> p.TA1.toString()).reduce("", (x, y)-> x+" "+y)).collect(Collectors.toSet()).size() == 8;
+        assert result2.size() == 8;
+    }
+
+    public Pair generatePair(){
+        return new Pair(TypePlaceholder.fresh(new NullToken()), TypePlaceholder.fresh(new NullToken()));
+    }
+}

src/test/java/typeinference/UnifyConstraintSetTests.java

@@ -0,0 +1,62 @@
+package typeinference;
+
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSetBuilder;
+import de.dhbwstuttgart.typeinference.constraints.OderConstraint;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class UnifyConstraintSetTests {
+    @Test
+    public void cartesianProductTestSingleConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 1;
+    }
+
+    @Test
+    public void cartesianProductTestSingleOderConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 2;
+    }
+
+    @Test
+    public void cartesianProductTestTwoOderConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 4;
+    }
+
+    @Test
+    public void cartesianProductTestThreeOderConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 4;
+
+        ConstraintSetBuilder builder2 = new ConstraintSetBuilder();
+        builder2.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder2.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder2.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        List<Set<Pair>> result2 = builder2.build().cartesianProductParallel().collect(Collectors.toList());
+        
+        assert result2.stream().map( a -> a.stream().map(p -> p.TA1.toString()).reduce("", (x, y)-> x+" "+y)).collect(Collectors.toSet()).size() == 8;
+        assert result2.size() == 8;
+    }
+
+    public Pair generatePair(){
+        return new Pair(TypePlaceholder.fresh(new NullToken()), TypePlaceholder.fresh(new NullToken()));
+    }
+}

src/test/java/unify/RuleSetTest.java

@@ -0,0 +1,4 @@
+package unify;
+
+public class RuleSetTest {
+}

src/test/java/unify/TypeUnifyTest.java

@@ -0,0 +1,47 @@
+package unify;
+
+import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import de.dhbwstuttgart.unify2.TypeUnify;
+import de.dhbwstuttgart.unify2.model.UnifyConstraintSet;
+import de.dhbwstuttgart.unify2.model.UnifyOderConstraint;
+import org.junit.Test;
+
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+
+public class TypeUnifyTest {
+    @Test
+    public void emptyInput(){
+        UnifyConstraintSet empty = new UnifyConstraintSet(new HashSet<>());
+        TypeUnify.unifyOrConstraints(empty, emptyFC());
+    }
+
+    @Test
+    public void singleOrConstraintOnlyTPHs(){
+        Set<UnifyPair> pairs = Set.of(new UnifyPair(PlaceholderType.freshPlaceholder(), PlaceholderType.freshPlaceholder(), PairOperator.EQUALSDOT));
+        UnifyOderConstraint orConstraint = new UnifyOderConstraint(Set.of(pairs));
+        UnifyConstraintSet input = new UnifyConstraintSet(Set.of(orConstraint));
+        Optional<Set<UnifyPair>> res = TypeUnify.unifyOrConstraints(input, emptyFC());
+        assert res.isPresent();
+    }
+
+    @Test
+    public void unifyTest1(){
+        PlaceholderType tph1 = PlaceholderType.freshPlaceholder();
+        PlaceholderType tph2 = PlaceholderType.freshPlaceholder();
+        UnifyPair p1 = new UnifyPair(tph1, tph2, PairOperator.SMALLERDOT);
+        Set<UnifyPair> pairs = Set.of(p1);
+        UnifyOderConstraint orConstraint = new UnifyOderConstraint(Set.of(pairs));
+        UnifyConstraintSet input = new UnifyConstraintSet(Set.of(orConstraint));
+        Optional<Set<UnifyPair>> res = TypeUnify.unifyOrConstraints(input, emptyFC());
+        assert res.isPresent();
+    }
+
+    private FiniteClosure emptyFC(){
+        return new FiniteClosure(new HashSet<>(), null);
+    }
+}

src/test/resources/AllgemeinTest/Cycle.jav

@@ -0,0 +1,11 @@
+class Cycle{
+
+    <A> A und(A a, A b){
+        return a;
+    }
+
+    m(a){
+        return und(m(m(a)), a);
+    }
+
+}

src/test/resources/AllgemeinTest/Twice.jav

@@ -0,0 +1,5 @@
+class Twice{
+    m(x, f){
+        return f.apply(f.apply(x));
+    }
+}

src/test/resources/inferWildcards/.gitignore

@@ -1,2 +0,0 @@
-/generatedSC/
-/generatedBC/

src/test/resources/inferWildcards/TestClassWildcardsFields.java

@@ -1,31 +0,0 @@
-import java.util.ArrayList;
-import java.util.List;
-import java.lang.String;
-
-class TestClassWildcardsFields
-{
-
-	private List<String> field1;
-	//private int counter;
-
-	public TestClassWildcards () {
-		//field1 = new ArrayList<>();
-		//counter = 0;
-	}
-
-	/**
-	 * Working method for Java
-	 * @param param1
-	 * @return
-	 */
-	public List<String> test (List<String> param1) {
-		List<String> localVar = field1;
-		field1 = param1;
-		//counter++;
-		return localVar;
-	}
-	
-	public void foo() {
-		
-	}
-}

src/test/resources/inferWildcards/TestClassWildcardsMap.java

@@ -1,13 +0,0 @@
-import java.lang.String;
-import java.lang.Object;
-import java.util.Map;
-import java.lang.Integer;
-
-class TestClassWildcardsMap
-{
-	
-	public Map<Integer, Object> test(Map<Integer, String> input){
-		Map<Integer, Object> listOfObjects = input;
-		return listOfObjects;
-	}
-}

src/test/resources/inferWildcards/TestClassWildcardsMapNested.java

@@ -1,16 +0,0 @@
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.lang.String;
-import java.lang.Object;
-import java.util.Map;
-import java.lang.Integer;
-
-class TestClassWildcardsMapNested
-{
-	
-	public Map<Integer, Collection<Object>> test(Map<Integer, List<String>> input){
-		Map<Integer, Collection<Object>> listOfObjects = input;
-		return listOfObjects;
-	}
-}

src/test/resources/inferWildcards/TestClassWildcardsNested.java

@@ -1,15 +0,0 @@
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.lang.String;
-import java.lang.Object;
-import java.util.Map;
-import java.lang.Integer;
-
-class TestClassWildcardsNested
-{	
-	public List<Collection<Object>> test(List<List<String>> input){
-		List<Collection<Object>> listOfObjects = input;
-		return listOfObjects;
-	}
-}

src/test/resources/inferWildcards/TestClassWildcardsParamType.java

@@ -1,23 +0,0 @@
-import java.util.List;
-import java.lang.String;
-
-public final class TestClassWildcardsParamType<T1, T2> {
-    public final T1 first;
-    public final T2 second;
-
-    public TestClassWildcardsParamType(T1 first, T2 second) {
-        this.first = first;
-        this.second = second;
-    }
-
-    public static <T1, T2> TestClassWildcardsParamType<T1, T2> of(T1 first, T2 second) {
-        return new TestClassWildcardsParamType<>(first, second);
-    }
-    
-    public static void main(String[] agrs) {
-    	TestClassWildcardsParamType<Class<?>, String> pair = TestClassWildcardsParamType.of(List.class, "hello");
-    	    	
-    	//Output of compiler
-    	//TestClassWildcardsParamType<? extends Class<?>, String> pair = TestClassWildcardsParamType.of(List.class, "hello");
-    }
-}

src/test/resources/inferWildcards/TestClassWildcardsSingle.java

@@ -1,20 +0,0 @@
-import java.util.List;
-import java.lang.String;
-import java.lang.Object;
-
-class TestClassWildcardsSingle
-{
-
-	/**
-	 * Non working method in normal Java
-	 * @param input
-	 * @return
-	 */
-	public List<Object> test (List<String> input) {
-		List<Object> listOfObjects = input;
-		Object test = listOfObjects.get(0);
-		String string = "Test";
-		input.add(string);
-		return listOfObjects;
-	}
-}

src/test/resources/inferWildcards/TestClassWildcardsSingleLib.java

@@ -1,15 +0,0 @@
-import java.util.List;
-
-class TestClassWildcardsLib
-{
-
-//  public <T> List<T> merge (List<T> l1, List<T> l2) {
-//		l2.forEach(s -> {if(!l1.contains(s)) l1.add(s);});
-//		return l2;
-//	}
-	
-	public <T, S extends T> List<S> di(List<T> dd){
-		T t = dd.get(1);
-		return dd;
-	}	
-}