Merge branch 'bytecode2' of ssh://gohorb.ba-horb.de/bahome/projekt/git/JavaCompilerCore into bigRefactoring

pom.xml

@@ -55,6 +55,14 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 		<finalName>${project.artifactId}-${project.version}</finalName>
 		<testOutputDirectory>target/test-classes</testOutputDirectory>
 		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>3.0.0-M3</version>
+				<configuration>
+					<skipTests>true</skipTests>
+				</configuration>
+			</plugin>
 			<plugin>
 				<groupId>org.antlr</groupId>
 				<artifactId>antlr4-maven-plugin</artifactId>
@@ -138,10 +146,6 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 					</execution>
 				</executions>
 			</plugin>
-			<!-- plugin> <groupId>org.eclipse.tycho</groupId> <artifactId>tycho-p2-repository-plugin</artifactId> 
-				<version>${tycho.version}</version> <executions> <execution> <phase>package</phase> 
-				<goals> <goal>archive-repository</goal> </goals> </execution> </executions> 
-				</plugin -->
 		</plugins>
 	</build>
 	<pluginRepositories>
@@ -169,5 +173,3 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 		</repository>
 	</distributionManagement>
 </project>
-
-

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

@@ -148,8 +148,17 @@ public class BytecodeGen implements ASTVisitor {
 						tphsClass.add(t);
 				}
 
+				String sig = null;
+				/* if class has generics then creates signature
+				 * Signature looks like:
+				 * <E:Ljava/...>Superclass 
+				 */
+				if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty() || 
+						classOrInterface.getSuperClass().acceptTV(new TypeToSignature()).contains("<")
+						|| !tphsClass.isEmpty()) {
+					HashMap<TPHConstraint, HashSet<String>> constraints = Simplify.simplifyConstraintsClass(tphExtractor,tphsClass);
 					ArrayList<TPHConstraint> consClass = new ArrayList<>();
-				for(TPHConstraint cons : tphExtractor.allCons) {
+					for(TPHConstraint cons : constraints.keySet()) {
 						TypePlaceholder right = null;
 						for(TypePlaceholder tph : tphsClass) {
 							if(cons.getLeft().equals(tph.getName())) {
@@ -164,14 +173,6 @@ public class BytecodeGen implements ASTVisitor {
 							right = null;
 						}
 					}
-				String sig = null;
-				/* if class has generics then creates signature
-				 * Signature looks like:
-				 * <E:Ljava/...>Superclass 
-				 */
-				if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty() || 
-						classOrInterface.getSuperClass().acceptTV(new TypeToSignature()).contains("<")
-						|| !tphsClass.isEmpty()) {
 					Signature signature = new Signature(classOrInterface, genericsAndBounds,commonPairs,tphsClass, consClass);
 					sig = signature.toString();
 					System.out.println("Signature: => " + sig);

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

@@ -140,7 +140,8 @@ public class BytecodeGenMethod implements StatementVisitor {
 	}
 
 	public BytecodeGenMethod(LambdaExpression lambdaExpression, ArrayList<String> usedVars, ResultSet resultSet, MethodVisitor mv,
-			int indexOfFirstParamLam, boolean isInterface, HashMap<String, byte[]> classFiles, String path, int lamCounter, SourceFile sf) {
+			int indexOfFirstParamLam, boolean isInterface, HashMap<String, byte[]> classFiles, String path, int lamCounter, SourceFile sf,HashMap<String, String> genericsAndBoundsMethod,
+			HashMap<String, String> genericsAndBounds) {
 
 		this.resultSet = resultSet;
 		this.mv = mv;
@@ -149,6 +150,9 @@ public class BytecodeGenMethod implements StatementVisitor {
 		this.path = path;
 		this.lamCounter = lamCounter;
 		this.sf = sf;
+		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
+		this.genericsAndBounds = genericsAndBounds;
+		
 		Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
 		int i = indexOfFirstParamLam;
 		
@@ -644,7 +648,8 @@ public class BytecodeGenMethod implements StatementVisitor {
 			ArrayList<String> usedVars = kindOfLambda.getUsedVars();
 			
 			new BytecodeGenMethod(lambdaExpression, usedVars,this.resultSet, mvLambdaBody, indexOfFirstParamLam, isInterface,
-					classFiles,this.path, lamCounter, sf);
+					classFiles,this.path, lamCounter, sf, genericsAndBoundsMethod,
+					genericsAndBounds);
 	
 			mvLambdaBody.visitMaxs(0, 0);
 			mvLambdaBody.visitEnd();
@@ -744,6 +749,13 @@ public class BytecodeGenMethod implements StatementVisitor {
 		statement = new IfStatement(ifStmt.expr, ifStmt.then_block, ifStmt.else_block);
 		isBinaryExp = statement.isExprBinary();
 		ifStmt.expr.accept(this);
+		if(!(ifStmt.expr instanceof BinaryExpr)) {
+			doUnboxing(getResolvedType(ifStmt.expr.getType()));
+			Label branchLabel = new Label();
+			Label endLabel = new Label();
+			mv.visitJumpInsn(Opcodes.IFEQ, branchLabel);
+			statement.genBCForRelOp(mv, branchLabel, endLabel, this);
+		}
 		statement = null;
 	}
 
@@ -758,11 +770,13 @@ public class BytecodeGenMethod implements StatementVisitor {
 		System.out.println("In MethodCall = " + methodCall.name);
 		String receiverName = getResolvedType(methodCall.receiver.getType());
 		System.out.println("Methods of " + receiverName + " ");
+		java.lang.reflect.Method methodRefl = null;
+		String clazz = receiverName.replace("/", ".");
+//		if(!receiverName.equals(className)) {
 			ClassLoader cLoader = ClassLoader.getSystemClassLoader();
 			// This will be used if the class is not standard class (not in API)
 			ClassLoader cLoader2;
-		java.lang.reflect.Method methodRefl = null;
+			
-		String clazz = receiverName.replace("/", ".");
 			String methCallType = resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 			String[] typesOfParams = getTypes(methodCall.arglist.getArguments());
 			try {
@@ -838,6 +852,8 @@ public class BytecodeGenMethod implements StatementVisitor {
 					//do nothing
 				}
 			}
+//		}
+		
 		methodCall.receiver.accept(this);
 		
 		System.out.println("Methodcall type : " + resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor()));
@@ -850,6 +866,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 			mDesc = method.accept(new DescriptorToString(resultSet));
 			methodCall.arglist.accept(this);
 		} else {
+			System.out.println(methodCall.name + " -> Refl != null");
 			receiverRefl = methodRefl.getAnnotatedReceiverType().getType().toString();
 			for(Parameter p:methodRefl.getParameters()) {
 				System.out.println(p.getName() + " und is Primitive = " + p.getType().isPrimitive());
@@ -865,7 +882,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 			}
 		}
 		
-		System.out.println("Methodcall Desc : " + mDesc);
+		System.out.println("Methodcall ("+ methodCall.name +") Desc : " + mDesc);
 		
 		
 //		methodCall.arglist.accept(this);
@@ -1197,6 +1214,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 			break;
 		case "java/lang/Boolean":
+			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false);
 			break;
 		case "java/lang/Byte":
 			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B", false);

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

@@ -5,13 +5,19 @@ package de.dhbwstuttgart.bytecode;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
 
 import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
 import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
+import de.dhbwstuttgart.syntaxtree.Constructor;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
+import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
+import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
@@ -25,7 +31,10 @@ public class TPHExtractor extends AbstractASTWalker{
 	// alle TPHs der Klasse: (TPH, is in Method?)
 	final HashMap<TypePlaceholder, Boolean> allTPHS = new HashMap<>();
 	MethodAndTPH methodAndTph;
+
 	Boolean inMethod = false;
+	boolean inLocalOrParam = false;
+
 	public final ArrayList<MethodAndTPH> ListOfMethodsAndTph = new ArrayList<>();
 	final ArrayList<GenericInsertPair> allPairs = new ArrayList<>();
 	public final ArrayList<TPHConstraint> allCons = new ArrayList<>();
@@ -43,8 +52,11 @@ public class TPHExtractor extends AbstractASTWalker{
 	public void visit(TypePlaceholder tph) {
 		if (resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) {
 			TypePlaceholder resolvedTPH = (TypePlaceholder) resultSet.resolveType(tph).resolvedType;
-			if(inMethod)
+			if (inMethod) {
 				methodAndTph.getTphs().add(resolvedTPH.getName());
+				if (inLocalOrParam)
+					methodAndTph.getLocalTphs().add(resolvedTPH.getName());
+			}
 
 			allTPHS.put(resolvedTPH, inMethod);
 			resultSet.resolveType(tph).additionalGenerics.forEach(ag -> {
@@ -58,6 +70,7 @@ public class TPHExtractor extends AbstractASTWalker{
 			});
 		}
 	}
+
 	private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
 		for (int i = 0; i < pairs.size(); ++i) {
 			GenericInsertPair p = pairs.get(i);
@@ -66,6 +79,7 @@ public class TPHExtractor extends AbstractASTWalker{
 		}
 		return false;
 	}
+
 	@Override
 	public void visit(Method method) {
 		inMethod = true;
@@ -75,4 +89,32 @@ public class TPHExtractor extends AbstractASTWalker{
 		ListOfMethodsAndTph.add(methodAndTph);
 	}
 
+	@Override
+	public void visit(Constructor cons) {
+		inMethod = false;
+		super.visit(cons);
+		inMethod = true;
+	}
+
+	@Override
+	public void visit(LocalVarDecl localVarDecl) {
+		inLocalOrParam = true;
+		super.visit(localVarDecl);
+		inLocalOrParam = false;
+	}
+
+	@Override
+	public void visit(LocalVar localVar) {
+		inLocalOrParam = true;
+		super.visit(localVar);
+		inLocalOrParam = false;
+	}
+
+	@Override
+	public void visit(ParameterList formalParameters) {
+		inLocalOrParam = true;
+		super.visit(formalParameters);
+		inLocalOrParam = false;
+	}
+
 }

src/main/java/de/dhbwstuttgart/bytecode/signature/Signature.java

@@ -391,7 +391,7 @@ public class Signature {
 			}
 			
 			for(TPHConstraint cons : consClass) {
-				if(!types.contains(cons.getRight())) {
+				if(!types.contains(cons.getRight()) && !genericsAndBounds.keySet().contains(cons.getRight()+"$")) {
 					String t = cons.getRight()+"$";
 					String bound = Type.getInternalName(Object.class);
 					sw.visitFormalTypeParameter(t);

src/main/java/de/dhbwstuttgart/bytecode/utilities/ConstraintsFinder.java

@@ -0,0 +1,51 @@
+package de.dhbwstuttgart.bytecode.utilities;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+
+public class ConstraintsFinder {
+	private List<TPHConstraint> allConstaints;
+
+	public ConstraintsFinder(List<TPHConstraint> allConstaints) {
+		super();
+		this.allConstaints = allConstaints;
+	}
+
+	public List<List<TPHConstraint>> findConstraints() {
+		List<List<TPHConstraint>> result = new ArrayList<>();
+		
+		List<TPHConstraint> visitedCons = new ArrayList<>();
+		for(TPHConstraint c : allConstaints) {
+			if(c.getRel() == Relation.EXTENDS) {
+				// get constraints with the same left side
+				List<TPHConstraint> cons = getConstraints(c,visitedCons);
+				if(cons.size()>1)
+					result.add(cons);
+			}
+		}
+		
+		return result;
+	}
+	
+	private List<TPHConstraint> getConstraints(TPHConstraint c, List<TPHConstraint> visitedCons) {
+		List<TPHConstraint> res = new ArrayList<>();
+		for(TPHConstraint cons : allConstaints) {
+			if(!isVisited(cons,visitedCons) && cons.getLeft().equals(c.getLeft())) {
+				res.add(cons);
+				visitedCons.add(cons);
+			}
+		}
+		return res;
+	}
+
+	private boolean isVisited(TPHConstraint cons, List<TPHConstraint> visitedCons) {
+		for(TPHConstraint c : visitedCons) {
+			if(c.getLeft().equals(cons.getLeft()) && c.getRight().equals(cons.getRight()))
+				return true;
+		}
+		return false;
+	}
+}

src/main/java/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java

@@ -10,6 +10,8 @@ public class MethodAndTPH {
 	private String name;
 	private final ArrayList<String> tphs = new ArrayList<>();
 	private final ArrayList<GenericInsertPair> pairs = new ArrayList<>();
+	// tphs of local variables and parameters
+	private final ArrayList<String> localTphs = new ArrayList<>();
 
 	public MethodAndTPH(String name) {
 		this.name = name;
@@ -26,4 +28,9 @@ public class MethodAndTPH {
 	public String getName() {
 		return name;
 	}
+
+	public ArrayList<String> getLocalTphs() {
+		return localTphs;
+	}
+	
 }

src/main/java/de/dhbwstuttgart/bytecode/utilities/NameReplacer.java

@@ -0,0 +1,49 @@
+package de.dhbwstuttgart.bytecode.utilities;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
+
+public class NameReplacer {
+	private List<TPHConstraint> constraints;
+	private List<TPHConstraint> allConstraints;
+	private List<String> tphs;
+	private List<String> localTphs;
+	
+	public NameReplacer(List<TPHConstraint> constraints, List<TPHConstraint> allConstraints,List<String> tphs, ArrayList<String> localTphs) {
+		super();
+		this.constraints = constraints;
+		this.allConstraints = allConstraints;
+		this.tphs = tphs;
+		this.localTphs = localTphs;
+	}
+	
+	public Map<String, List<String>> replaceNames() {
+		String newName = NameGenerator.makeNewName();
+		ArrayList<String> names = new ArrayList<>();
+		for(TPHConstraint cons : constraints) {
+			names.add(cons.getRight());
+			cons.setRight(newName);
+		}
+		
+		for(TPHConstraint cons : allConstraints) {
+			if(names.contains(cons.getLeft()))
+				cons.setLeft(newName);
+			if(names.contains(cons.getRight()))
+				cons.setRight(newName);
+		}
+		
+		tphs.removeAll(names);
+		tphs.add(newName);
+		localTphs.removeAll(names);
+		localTphs.add(newName);
+		
+		HashMap<String, List<String>> res = new HashMap<>();
+		res.put(newName, names);
+		return res;
+	}
+}

src/main/java/de/dhbwstuttgart/bytecode/utilities/Simplify.java

@@ -4,6 +4,8 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
 
 import org.objectweb.asm.Type;
 
@@ -16,13 +18,15 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
 public class Simplify {
 
-	public static HashMap<TPHConstraint, HashSet<String>> simplifyConstraints(String name, TPHExtractor tphExtractor, ArrayList<TypePlaceholder> tphsClass) {
+	public static HashMap<TPHConstraint, HashSet<String>> simplifyConstraints(String name, TPHExtractor tphExtractor,
+			ArrayList<TypePlaceholder> tphsClass) {
 		// 1. check if there are any simple cycles like L<R and R<L:
 		// a) yes => set L=R and:
 		// * remove both constraints
 		// * substitute L with R in all constraint
 		// b)no => go to next step
-		// 2. check the result of step 1 if there are any equal-constraints like L=R, M=R ..
+		// 2. check the result of step 1 if there are any equal-constraints like L=R,
+		// M=R ..
 		// a) yes => put all such TPhs in a map and define "key-Cons"
 		// -- key-Cons = TPH < Object --
 		// put this Constraint and the
@@ -30,9 +34,26 @@ public class Simplify {
 		// 3. is
 
 		// all constraints that will be simplified
-		ArrayList<TPHConstraint> allCons = tphExtractor.allCons;
+//		ArrayList<TPHConstraint> allCons = tphExtractor.allCons;
+		ArrayList<TPHConstraint> allCons = new ArrayList<>();
+		
+		for(TPHConstraint c : tphExtractor.allCons) {
+			TPHConstraint nc = new TPHConstraint(c.getLeft(), c.getRight(), c.getRel());
+			allCons.add(nc);
+		}
 		ArrayList<TPHConstraint> consToRemove = new ArrayList<>();
 
+		// get all tph of the method
+		ArrayList<String> methodTphs = new ArrayList<>();
+		ArrayList<String> localTphs = new ArrayList<>();
+		for (MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) {
+			if (m.getName().equals(name)) {
+				methodTphs = m.getTphs();
+				localTphs = m.getLocalTphs();
+				break;
+			}
+		}
+
 		// step 1:
 		for (TPHConstraint c : allCons) {
 
@@ -133,7 +154,8 @@ public class Simplify {
 						eq.add(t);
 					}
 					// generate a new constraint (left < Object)
-					TPHConstraint constraint = new ExtendsConstraint(left, Type.getInternalName(Object.class), Relation.EXTENDS);
+					TPHConstraint constraint = new ExtendsConstraint(left, Type.getInternalName(Object.class),
+							Relation.EXTENDS);
 					// put the generated constraint and its equal set into result set
 					result.put(constraint, eq);
 					constraints.clear();
@@ -141,23 +163,36 @@ public class Simplify {
 				allTypes.clear();
 			}
 		}
+
+		for (TPHConstraint ec : allCons) {
+			
+			if(ec.getRel() == Relation.EQUAL) {
+				if(!localTphs.contains(ec.getRight())) {
+					localTphs.add(ec.getRight());
+				}
+				if(!methodTphs.contains(ec.getRight())) {
+					methodTphs.add(ec.getRight());
+				}
+				
+			}
+		}
 		// build an equal set that contains all types
 		// which are equal and for each equal constraint put left side and right side
 		// in this set Then generate a constraint type < Object and put it
 		// with the equal set into the result.
-		for(TPHConstraint c : allCons) {
+//		for(TPHConstraint c : allCons) {
-			if(c.getRel()==Relation.EQUAL) {
+//			if(c.getRel()==Relation.EQUAL) {
-				if(!isTPHInResEqual(result, c.getLeft())) {
+//				if(!isTPHInResEqual(result, c.getLeft())) {
-					HashSet<String> equalTPHs = getEqualsTPHs(result, c);
+//					HashSet<String> equalTPHs = getEqualsTPHs(result, c);
-					TPHConstraint constraint = getKeyConstraint(result,c);
+//					TPHConstraint constraint = getKeyConstraint(result,c);
-					equalTPHs.add(c.getLeft());
+//					equalTPHs.add(c.getLeft());
-					equalTPHs.add(c.getRight());
+//					equalTPHs.add(c.getRight());
-					result.put(constraint, equalTPHs);
+//					result.put(constraint, equalTPHs);
-				}
+//				}
-				consToRemove.add(c);
+//				consToRemove.add(c);
-				size--;
+//				size--;
-			}
+//			}
-		}
+//		}
 
 		System.out.println("Step 2 Result: ");
 		result.forEach((c, hs) -> {
@@ -168,16 +203,14 @@ public class Simplify {
 			System.out.println();
 		});
 		System.out.println("----------------");
-		// remove all equal-constraints
-		allCons.removeAll(consToRemove);
-		// add all generated constraints to allCons 
-		allCons.addAll(result.keySet());
 
 		if (!allCons.isEmpty() && allCons.size() < 2) {
 			TPHConstraint cons = allCons.get(0);
 			if (!result.containsKey(cons)) {
 				result.put(cons, null);
-				result.put(new ExtendsConstraint(cons.getRight(), Type.getInternalName(Object.class), Relation.EXTENDS), null);
+				if (!cons.getRight().equals(Type.getInternalName(Object.class)))
+					result.put(new ExtendsConstraint(cons.getRight(), Type.getInternalName(Object.class),
+							Relation.EXTENDS), null);
 			}
 
 			return result;
@@ -190,58 +223,103 @@ public class Simplify {
 			if (c.getRight().equals(Type.getInternalName(Object.class)))
 				size--;
 		}
-		// get all tph of the method
+
-		ArrayList<String> methodTphs = new ArrayList<>();
+		// finder looks for constraints that have the same left hand side
-		for(MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) {
+		// and put them in a list
-			if(m.getName().equals(name)) {
+		ConstraintsFinder finder = new ConstraintsFinder(allCons);
-				methodTphs = m.getTphs();
+		List<List<TPHConstraint>> foundCons = finder.findConstraints();
-				break;
+
+		ArrayList<TPHConstraint> eqCons = new ArrayList<>();
+
+		for (List<TPHConstraint> list : foundCons) {
+			// generate a new name and replace the right hand side for each constraint
+			// in list with the new name
+			NameReplacer replacer = new NameReplacer(list, allCons, methodTphs, localTphs);
+			// new name -> [all old names]
+			Map<String, List<String>> replRes = replacer.replaceNames();
+			// create an equal constraint for each value in repres
+			String key = replRes.keySet().iterator().next();
+			for (String val : replRes.values().iterator().next()) {
+				EqualConstraint ec = new EqualConstraint(val, key, Relation.EQUAL);
+				eqCons.add(ec);
+			}
+			for (TPHConstraint c : allCons) {
+				if (c.getRel() == Relation.EQUAL && key.equals(c.getRight())) {
+					eqCons.add(c);
 				}
 			}
+			updateEqualCons(replRes, eqCons);
+
+			TPHConstraint c = list.get(0);
+			allCons.removeAll(list);
+			allCons.add(c);
+		}
+
 		// check if there are multiple constraint with the same left side.
 		// if yes => check if the super type in the method, if not
 		// then ignore it.
+//		HashMap<String, String> subAndSuper = new HashMap<>();
+//		ArrayList<TPHConstraint> eqCons = new ArrayList<>();
+//		for(TPHConstraint c : allCons) {
+//			if(subAndSuper.containsKey(c.getLeft())) {
+//				LinkedList<String> all = new LinkedList<>();
+//				all.add(c.getLeft());
+//				String sup =c.getRight();
+//				all.add(sup);
+//				HashMap<String, String> ss = new HashMap<>();
+//				for(TPHConstraint constr : allCons) {
+//					ss.put(constr.getLeft(), constr.getRight());
+//				}
+//				while(ss.containsKey(sup)) {
+//					sup = ss.get(sup);
+//					all.add(sup);
+//				}
+//				if(!containTPH(methodTphs, all.getLast()))
+//					continue;
+//			}
+//			if(subAndSuper.containsKey(c.getLeft())) {
+//				System.out.println(c.getLeft());
+//				String r = c.getRight();
+//				String r2 = subAndSuper.get(c.getLeft());
+//				EqualConstraint eq = new EqualConstraint(r2, r, Relation.EQUAL);
+//				eqCons.add(eq);
+//				substituteInMap(subAndSuper,eqCons,allCons,r,r2);
+//			}
+//			subAndSuper.put(c.getLeft(), c.getRight());
+//		}
+//		
+//		System.out.println("SAME LEFT SIDE: ");
+//		subAndSuper.forEach((c,hs)->{
+//			if(c!=null) {
+//				System.out.print(c+ " -> " + hs);
+//				
+//			}
+//			
+//			
+//			System.out.println();
+//		});
+//		System.out.println("----------------");
 		HashMap<String, String> subAndSuper = new HashMap<>();
-		ArrayList<TPHConstraint> eqCons = new ArrayList<>();
+
 		for (TPHConstraint c : allCons) {
-			if(subAndSuper.containsKey(c.getLeft())) {
+			if (c.getRel() == Relation.EXTENDS)
-				LinkedList<String> all = new LinkedList<>();
-				all.add(c.getLeft());
-				String sup =c.getRight();
-				all.add(sup);
-				HashMap<String, String> ss = new HashMap<>();
-				for(TPHConstraint constr : allCons) {
-					ss.put(constr.getLeft(), constr.getRight());
-				}
-				while(ss.containsKey(sup)) {
-					sup = ss.get(sup);
-					all.add(sup);
-				}
-				if(!containTPH(methodTphs, all.getLast()))
-					continue;
-			}
-			if(subAndSuper.containsKey(c.getLeft())) {
-				System.out.println(c.getLeft());
-				String r = c.getRight();
-				String r2 = subAndSuper.get(c.getLeft());
-				EqualConstraint eq = new EqualConstraint(r2, r, Relation.EQUAL);
-				eqCons.add(eq);
-				substituteInMap(subAndSuper,eqCons,allCons,r,r2);
-			}
 				subAndSuper.put(c.getLeft(), c.getRight());
 		}
 
-		System.out.println("SAME LEFT SIDE: ");
+		for (TPHConstraint ec : allCons) {
-		subAndSuper.forEach((c,hs)->{
+			if(ec.getRel() == Relation.EQUAL) {
-			if(c!=null) {
+				methodTphs.remove(ec.getLeft());
-				System.out.print(c+ " -> " + hs);
+				localTphs.remove(ec.getLeft());
+				if(!localTphs.contains(ec.getRight())) {
+					localTphs.add(ec.getRight());
+				}
+				if(!methodTphs.contains(ec.getRight())) {
+					methodTphs.add(ec.getRight());
+				}
+			}
 			
 		}
 
-			
-			System.out.println();
-		});
-		System.out.println("----------------");
 		int numOfVisitedPairs = 0;
 		for (String sub : subAndSuper.keySet()) {
 			if (isTPHInConstraint(result, sub))
@@ -258,7 +336,7 @@ public class Simplify {
 			tphInRel.add(superT);
 
 			numOfVisitedPairs++;
-			while(subAndSuper.containsKey(superT)) {
+			while (!localTphs.contains(superT) && subAndSuper.containsKey(superT)) {
 				superT = subAndSuper.get(superT);
 				if (tphInRel.contains(superT)) {
 					break;
@@ -274,7 +352,7 @@ public class Simplify {
 
 			// if there is any constraint X < subTph, then
 			// add X at the beginning of the list.
-			while(subAndSuper.containsValue(subTphRes)) {
+			while (!localTphs.contains(subTphRes) && subAndSuper.containsValue(subTphRes)) {
 				for (String tph : subAndSuper.keySet()) {
 					if (containTPH(methodTphs, tph) && subAndSuper.get(tph).equals(subTphRes)) {
 						subTphRes = tph;
@@ -307,7 +385,8 @@ public class Simplify {
 				if (classTPHSContainsTPH(tphsClass, superTphRes)) {
 					result.put(new ExtendsConstraint(subTphRes, superTphRes, Relation.EXTENDS), equals);
 				} else {
-					result.put(new ExtendsConstraint(subTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), equals);
+					result.put(new ExtendsConstraint(subTphRes, Type.getInternalName(Object.class), Relation.EXTENDS),
+							equals);
 				}
 
 			} else {
@@ -315,18 +394,43 @@ public class Simplify {
 				result.put(new ExtendsConstraint(subTphRes, superTphRes, Relation.EXTENDS), equals);
 				if (!isTPHInConstraint(result, superTphRes) && !isTphInEqualSet(result, superTphRes)) {
 					HashSet<String> equals2 = getEqualsTphsFromEqualCons(eqCons, superTphRes);
-					result.put(new ExtendsConstraint(superTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), equals2);
+					result.put(new ExtendsConstraint(superTphRes, Type.getInternalName(Object.class), Relation.EXTENDS),
+							equals2);
 				}
 			}
 		}
 
-		for(String tph : methodTphs) {
+//		for(String tph : methodTphs) {
+		for (String tph : localTphs) {
 			if (!isTPHInConstraint(result, tph) && !isTphInEqualSet(result, tph)) {
 				HashSet<String> equals = getEqualsTphsFromEqualCons(eqCons, tph);
 				result.put(new ExtendsConstraint(tph, Type.getInternalName(Object.class), Relation.EXTENDS), equals);
 			}
 		}
 
+		// build an equal set that contains all types
+		// which are equal and for each equal constraint put left side and right side
+		// in this set Then generate a constraint type < Object and put it
+		// with the equal set into the result.
+		for (TPHConstraint c : allCons) {
+			if (c.getRel() == Relation.EQUAL) {
+				if (!isTPHInResEqual(result, c.getLeft())) {
+					HashSet<String> equalTPHs = getEqualsTPHs(result, c);
+					TPHConstraint constraint = getKeyConstraint(result, c);
+					equalTPHs.add(c.getLeft());
+					equalTPHs.add(c.getRight());
+					result.put(constraint, equalTPHs);
+				}
+				consToRemove.add(c);
+				size--;
+			}
+		}
+
+		// remove all equal-constraints
+		allCons.removeAll(consToRemove);
+		// add all generated constraints to allCons
+		allCons.addAll(result.keySet());
+
 		System.out.println("EndResult: ");
 		result.forEach((c, hs) -> {
 			if (c != null) {
@@ -340,6 +444,253 @@ public class Simplify {
 				}
 			}
 
+			System.out.println();
+		});
+		System.out.println("----------------");
+		return result;
+	}
+
+	private static void updateEqualCons(Map<String, List<String>> replRes, ArrayList<TPHConstraint> eqCons) {
+		List<String> oldNames = replRes.values().iterator().next();
+		String newName = replRes.keySet().iterator().next();
+		for (TPHConstraint c : eqCons) {
+//			if(oldNames.contains(c.getLeft()))
+//				c.setLeft(newName);
+			if (oldNames.contains(c.getRight()))
+				c.setRight(newName);
+		}
+
+	}
+
+	public static HashMap<TPHConstraint, HashSet<String>> simplifyConstraintsClass(TPHExtractor tphExtractor,
+			ArrayList<TypePlaceholder> tphsClass) {
+		// all constraints that will be simplified
+		ArrayList<TPHConstraint> allCons = tphExtractor.allCons;
+		ArrayList<TPHConstraint> consToRemove = new ArrayList<>();
+
+		// step 1:
+		for (TPHConstraint c : allCons) {
+
+			String left = c.getLeft();
+			String right = c.getRight();
+			if (c.getRel() == Relation.EXTENDS) {
+				TPHConstraint revCon = getReverseConstraint(allCons, left, right);
+				if (revCon != null) {
+					revCon.setRel(Relation.EQUAL);
+					// the reverse constraint is removed because
+					// otherwise there is the same constraint twice
+					// (e.g. A<B and B<A => A=B and B=A)
+					consToRemove.add(revCon);
+					c.setRel(Relation.EQUAL);
+					substituteTPH(allCons, left, right);
+				}
+			}
+		}
+
+		allCons.removeAll(consToRemove);
+		consToRemove = new ArrayList<>();
+
+		int size = allCons.size();
+
+		HashMap<TPHConstraint, HashSet<String>> result = new HashMap<>();
+
+		// check if there is any long cycle (e.g. A<B<C<A)
+
+		// to save all types that are in relation
+		LinkedList<String> allTypes = new LinkedList<>();
+		// we will put all constraints which are in the cycle, in this ArrayList.
+		// Later these contraints will be converted to equal-constraints
+		ArrayList<TPHConstraint> constraints = new ArrayList<>(size);
+		int visited = 0;
+
+		// contains all constraints
+		HashMap<String, String> ss1 = new HashMap<>();
+
+		for (TPHConstraint constr : allCons) {
+			ss1.put(constr.getLeft(), constr.getRight());
+		}
+
+		for (TPHConstraint c : allCons) {
+
+			if (visited >= size)
+				break;
+			// Only extends-constraints will be checked
+			if (c.getRel() == Relation.EXTENDS) {
+				++visited;
+
+				String left = c.getLeft();
+				String right = c.getRight();
+				// put the types in linked list
+				allTypes.add(left);
+				allTypes.add(right);
+
+				constraints.add(c);
+
+				boolean isCycle = false;
+
+				// iterate through the map to check if there is a cycle
+				while (ss1.containsKey(right)) {
+					++visited;
+					String oldRight = right;
+					right = ss1.get(right);
+
+					TPHConstraint toAdd = getConstraint(oldRight, right, allCons);
+
+					if (toAdd != null)
+						constraints.add(toAdd);
+
+					if (left.equals(right)) {
+						isCycle = true;
+						break;
+					}
+
+					allTypes.add(right);
+				}
+
+				if (isCycle) {
+					// convert all constraints to equal constraints
+					setAllEqual(constraints);
+					// these constraints will be removed from allCons
+					consToRemove.addAll(constraints);
+					// all equal types will be substitute with one type
+					substituteAllTPH(allCons, constraints, left);
+
+					HashSet<String> eq = new HashSet<>();
+					// put all equal types in a set
+					for (String t : allTypes) {
+						eq.add(t);
+					}
+					// generate a new constraint (left < Object)
+					TPHConstraint constraint = new ExtendsConstraint(left, Type.getInternalName(Object.class),
+							Relation.EXTENDS);
+					// put the generated constraint and its equal set into result set
+					result.put(constraint, eq);
+					constraints.clear();
+				}
+				allTypes.clear();
+			}
+		}
+		// build an equal set that contains all types
+		// which are equal and for each equal constraint put left side and right side
+		// in this set Then generate a constraint type < Object and put it
+		// with the equal set into the result.
+		for (TPHConstraint c : allCons) {
+			if (c.getRel() == Relation.EQUAL) {
+				if (!isTPHInResEqual(result, c.getLeft())) {
+					HashSet<String> equalTPHs = getEqualsTPHs(result, c);
+					TPHConstraint constraint = getKeyConstraint(result, c);
+					equalTPHs.add(c.getLeft());
+					equalTPHs.add(c.getRight());
+					result.put(constraint, equalTPHs);
+				}
+				consToRemove.add(c);
+				size--;
+			}
+		}
+
+		// remove all equal-constraints
+		allCons.removeAll(consToRemove);
+		// add all generated constraints to allCons
+		allCons.addAll(result.keySet());
+
+		if (!allCons.isEmpty() && allCons.size() < 2) {
+			TPHConstraint cons = allCons.get(0);
+			if (!result.containsKey(cons)) {
+				result.put(cons, null);
+				result.put(new ExtendsConstraint(cons.getRight(), Type.getInternalName(Object.class), Relation.EXTENDS),
+						null);
+			}
+
+			return result;
+		}
+
+		size += result.keySet().size();
+		// all constraints which have Object on the right side will
+		// be ignored, because they are simplified and can not be changed.
+		for (TPHConstraint c : allCons) {
+			if (c.getRight().equals(Type.getInternalName(Object.class)))
+				size--;
+		}
+
+		// check if there are multiple constraint with the same left side.
+		// if yes => check if the super type in the method, if not
+		// then ignore it.
+		HashMap<String, String> subAndSuper = new HashMap<>();
+		ArrayList<TPHConstraint> eqCons = new ArrayList<>();
+		for (TPHConstraint c : allCons) {
+
+			subAndSuper.put(c.getLeft(), c.getRight());
+		}
+
+		int numOfVisitedPairs = 0;
+		for (String sub : subAndSuper.keySet()) {
+			if (isTPHInConstraint(result, sub))
+				continue;
+
+			if (!classTPHSContainsTPH(tphsClass, sub))
+				continue;
+
+			if (numOfVisitedPairs >= size)
+				break;
+			LinkedList<String> tphInRel = new LinkedList<>();
+			tphInRel.add(sub);
+			String superT = subAndSuper.get(sub);
+			tphInRel.add(superT);
+
+			numOfVisitedPairs++;
+			while (subAndSuper.containsKey(superT)) {
+				superT = subAndSuper.get(superT);
+				if (tphInRel.contains(superT)) {
+					break;
+				}
+				tphInRel.add(superT);
+				numOfVisitedPairs++;
+			}
+
+			// Subtype
+			String subTphRes = tphInRel.getFirst();
+			// Die größte Supertype
+			String superTphRes = tphInRel.getLast();
+
+			// if there is any constraint X < subTph, then
+			// add X at the beginning of the list.
+			while (subAndSuper.containsValue(subTphRes)) {
+				for (String tph : subAndSuper.keySet()) {
+					if (classTPHSContainsTPH(tphsClass, tph) && subAndSuper.get(tph).equals(subTphRes)) {
+						subTphRes = tph;
+						break;
+					}
+				}
+				if (subTphRes.equals(tphInRel.getFirst())) {
+					break;
+				}
+
+				if (isTPHInConstraint(result, subTphRes))
+					break;
+
+				tphInRel.addFirst(subTphRes);
+				numOfVisitedPairs++;
+			}
+
+			subTphRes = tphInRel.getFirst();
+
+			HashSet<String> equals = getEqualsTphsFromEqualCons(eqCons, superTphRes);
+			result.put(new ExtendsConstraint(subTphRes, superTphRes, Relation.EXTENDS), equals);
+
+		}
+
+		System.out.println("EndResult: ");
+		result.forEach((c, hs) -> {
+			if (c != null) {
+				System.out.print(c.toString() + " -> ");
+				if (hs == null) {
+					System.out.print(" [] ");
+				} else {
+					hs.forEach(s -> {
+						System.out.print(s + ", ");
+					});
+				}
+			}
 
 			System.out.println();
 		});
@@ -374,8 +725,8 @@ public class Simplify {
 		return ee;
 	}
 
-	private static void substituteInMap(HashMap<String, String> subAndSuper, ArrayList<TPHConstraint> allCons,ArrayList<TPHConstraint> eqCons, String toSubs,
+	private static void substituteInMap(HashMap<String, String> subAndSuper, ArrayList<TPHConstraint> allCons,
-			String tph) {
+			ArrayList<TPHConstraint> eqCons, String toSubs, String tph) {
 		substituteTPH(allCons, toSubs, tph);
 		if (subAndSuper.containsKey(toSubs) && subAndSuper.containsKey(tph)) {
 			toSubs = subAndSuper.remove(toSubs);
@@ -430,13 +781,15 @@ public class Simplify {
 		}
 	}
 
-	public static HashMap<TPHConstraint, HashSet<String>> simplifyContraints(HashMap<TPHConstraint, HashSet<String>> allConstraints) {
+	public static HashMap<TPHConstraint, HashSet<String>> simplifyContraints(
+			HashMap<TPHConstraint, HashSet<String>> allConstraints) {
 		// 1. check if there are any cycles like L<R and R<L:
 		// a) yes => set L=R and:
 		// * remove both constraints
 		// * substitute L with R in all constraint
 		// b)no => go to next step
-		// 2. check the result of step 1 if there are any equal-constraints like L=R, M=R ..
+		// 2. check the result of step 1 if there are any equal-constraints like L=R,
+		// M=R ..
 		// a) yes => put all such TPhs in a map and define "key-Cons"
 		// -- key-Cons = TPH < Object --
 		// put this Constraint and the
@@ -570,10 +923,12 @@ public class Simplify {
 				i++;
 			}
 			if (superTphRes.equals(Type.getInternalName(Object.class))) {
-				result.put(new ExtendsConstraint(subTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), null);
+				result.put(new ExtendsConstraint(subTphRes, Type.getInternalName(Object.class), Relation.EXTENDS),
+						null);
 			} else {
 				result.put(new ExtendsConstraint(subTphRes, superTphRes, Relation.EXTENDS), null);
-				result.put(new ExtendsConstraint(superTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), null);
+				result.put(new ExtendsConstraint(superTphRes, Type.getInternalName(Object.class), Relation.EXTENDS),
+						null);
 			}
 
 		}
@@ -590,7 +945,6 @@ public class Simplify {
 				}
 			}
 
-			
 			System.out.println();
 		});
 		System.out.println("----------------");
@@ -633,11 +987,29 @@ public class Simplify {
 		return false;
 	}
 
-	private static TPHConstraint getKeyConstraint(HashMap<TPHConstraint, HashSet<String>> result, TPHConstraint toFind) {
+	private static TPHConstraint getKeyConstraint(HashMap<TPHConstraint, HashSet<String>> result, TPHConstraint toFind,
+			ArrayList<TPHConstraint> allCons) {
+
+		for (TPHConstraint c : result.keySet()) {
+			if (c.containTPH(toFind.getLeft()))
+				return c;
+		}
+		for (TPHConstraint c : allCons) {
+			if (toFind.getRight().equals(c.getLeft()))
+				return c;
+		}
+
+		return new ExtendsConstraint(toFind.getRight(), Type.getInternalName(Object.class), Relation.EXTENDS);
+	}
+
+	private static TPHConstraint getKeyConstraint(HashMap<TPHConstraint, HashSet<String>> result,
+			TPHConstraint toFind) {
+
 		for (TPHConstraint c : result.keySet()) {
 			if (c.containTPH(toFind.getLeft()) || c.containTPH(toFind.getRight()))
 				return c;
 		}
+
 		return new ExtendsConstraint(toFind.getRight(), Type.getInternalName(Object.class), Relation.EXTENDS);
 	}
 

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

@@ -34,6 +34,7 @@ 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;
 
@@ -41,6 +42,10 @@ import java.io.File;
 import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
+<<<<<<< HEAD
+=======
+import java.io.OutputStreamWriter;
+>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2
 import java.io.Writer;
 import java.util.*;
 import java.util.function.Function;
@@ -48,6 +53,7 @@ import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.antlr.v4.parse.ANTLRParser.throwsSpec_return;
+import org.apache.commons.io.output.NullOutputStream;
 
 public class JavaTXCompiler {
 
@@ -275,7 +281,7 @@ public class JavaTXCompiler {
 	}
 	*/
     
-    public UnifyResultModel typeInferenceAsync() throws ClassNotFoundException {
+    public UnifyResultModel typeInferenceAsync(UnifyResultListener resultListener, Writer logFile) throws ClassNotFoundException {
     	List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
         //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
         for(SourceFile sf : this.sourceFiles.values()) {
@@ -285,10 +291,18 @@ public class JavaTXCompiler {
 
         final ConstraintSet<Pair> cons = getConstraints();
         Set<Set<UnifyPair>> results = new HashSet<>();
+<<<<<<< HEAD
         UnifyResultModel urm = null;
         try {
 			Writer logFile = new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName()));
 			
+=======
+        UnifyResultModel urm = new UnifyResultModel();
+        urm.addUnifyResultListener(resultListener);
+        try {
+        	logFile = logFile == null ? new FileWriter(new File("log_"+sourceFiles.keySet().iterator().next().getName())) : logFile;
+
+>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2
 			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile);
 			System.out.println(finiteClosure);
 			urm = new UnifyResultModel(cons, finiteClosure);
@@ -423,7 +437,12 @@ public class JavaTXCompiler {
         final ConstraintSet<Pair> cons = getConstraints();
         Set<Set<UnifyPair>> results = new HashSet<>();
         try {
+<<<<<<< HEAD
 			Writer logFile = new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName()));
+=======
+			Writer logFile = new OutputStreamWriter(new NullOutputStream());
+				//new FileWriter(new File("log_"+sourceFiles.keySet().iterator().next().getName()));	
+>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2
 			
 			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile);
 			System.out.println(finiteClosure);

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

@@ -80,6 +80,9 @@ public abstract class AbstractASTWalker implements ASTVisitor{
         for(Field f : classOrInterface.getFieldDecl()){
             f.accept(this);
         }
+        for(Constructor c : classOrInterface.getConstructors()){
+            c.accept(this);
+        }
         for(Method m : classOrInterface.getMethods()){
             m.accept(this);
         }

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

@@ -14,6 +14,7 @@ import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 public class TypeUnify {
+<<<<<<< HEAD
 	
 	/**
 	 * unify parallel ohne result modell
@@ -27,12 +28,17 @@ public class TypeUnify {
 	 */
 	public Set<Set<UnifyPair>> unify(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret);
+=======
+	public Set<Set<UnifyPair>> unify(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, ConstraintSet<Pair> cons) {
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, new UnifyResultModel(), cons);
+>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		Set<Set<UnifyPair>> res =  unifyTask.join();
 		return res;
 	}
 	
+<<<<<<< HEAD
 	/**
 	 * unify asynchron mit Rückgabe UnifyResultModel ohne dass alle results gesammelt sind
 	 * @param undConstrains
@@ -46,11 +52,16 @@ public class TypeUnify {
 	 */
 	public UnifyResultModel unifyAsync(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret);
+=======
+	public UnifyResultModel unifyAsync(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, ConstraintSet<Pair> cons, UnifyResultModel ret) {
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, cons);
+>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		return ret;
 	}
 	
+<<<<<<< HEAD
 	/**
 	 * unify parallel mit Rückgabe UnifyResultModel nachdem alle results gesammelt sind
 	 * @param undConstrains
@@ -64,6 +75,10 @@ public class TypeUnify {
 	 */
 	public UnifyResultModel unifyParallel(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret);
+=======
+	public UnifyResultModel unifyParallel(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, ConstraintSet<Pair> cons, UnifyResultModel ret) {
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, cons);
+>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		Set<Set<UnifyPair>> res =  unifyTask.join();

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

@@ -1,7 +1,10 @@
 package de.dhbwstuttgart.typeinference.unify;
 
 import java.io.FileWriter;
+<<<<<<< HEAD
 import java.io.IOException;
+=======
+>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2
 import java.io.Writer;
 import java.util.HashSet;
 import java.util.List;
@@ -17,8 +20,13 @@ public class TypeUnify2Task extends TypeUnifyTask {
        
        Set<Set<UnifyPair>> setToFlatten;
 
+<<<<<<< HEAD
        public TypeUnify2Task(Set<Set<UnifyPair>> setToFlatten, Set<UnifyPair> eq, List<Set<Set<UnifyPair>>> oderConstraints, Set<UnifyPair> nextSetElement, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm) {
                super(eq, oderConstraints, fc, parallel, logFile, log, rekTiefe, urm);
+=======
+       public TypeUnify2Task(Set<Set<UnifyPair>> setToFlatten, Set<UnifyPair> eq, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm, ConstraintSet<Pair> cons) {
+               super(eq, oderConstraints, fc, parallel, logFile, log, rekTiefe, urm, cons);
+>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2
                this.setToFlatten = setToFlatten;
                this.nextSetElement = nextSetElement;
        }

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

@@ -133,7 +133,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	}
 	*/
 	
+<<<<<<< HEAD
 	public TypeUnifyTask(Set<UnifyPair> eq, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm) {
+=======
+	public TypeUnifyTask(Set<UnifyPair> eq, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm, ConstraintSet<de.dhbwstuttgart.typeinference.constraints.Pair> cons2) {
+>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2
 		synchronized (this) { 
 			this.eq = eq;
 			//this.oderConstraints = oderConstraints.stream().map(x -> x.stream().map(y -> new HashSet<>(y)).collect(Collectors.toSet(HashSet::new))).collect(Collectors.toList(ArrayList::new));

src/test/java/bytecode/FieldTphConsMethTest.java

@@ -32,11 +32,11 @@ public class FieldTphConsMethTest {
 		pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("FieldTphConsMeth");
-		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}
 
 	@Test
 	public void test() throws Exception {
+		instanceOfClass = classToTest.getConstructor(Object.class).newInstance("C");
 		Field a = classToTest.getDeclaredField("a");
 		a.setAccessible(true);
 		
@@ -44,6 +44,7 @@ public class FieldTphConsMethTest {
 		Object result = m.invoke(instanceOfClass, 42);
 		
 		assertEquals(42,result);
+		assertEquals("C", a.get(instanceOfClass));
 	}
 
 }

src/test/java/bytecode/FieldTphMMethTest.java

@@ -0,0 +1,66 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class FieldTphMMethTest {
+
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	private static Object instanceOfClass2;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/FieldTphMMeth.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		compiler.generateBytecode(System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/");
+		pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("FieldTphMMeth");
+		instanceOfClass = classToTest.getConstructor(Object.class,Object.class,Boolean.class).newInstance("C",42,true);
+		instanceOfClass2 = classToTest.getConstructor(Object.class,Object.class,Boolean.class).newInstance("C",42,false);
+	}
+
+	@Test
+	public void testM() throws Exception {
+		
+		Method m = classToTest.getDeclaredMethod("m", Object.class,Object.class,Boolean.class);
+		Object result = m.invoke(instanceOfClass, "C",42,false);
+		
+		assertEquals(42,result);
+	}
+	
+	@Test
+	public void testWithTrue() throws Exception {
+		Field a = classToTest.getDeclaredField("a");
+		a.setAccessible(true);
+
+		assertEquals("C", a.get(instanceOfClass));
+		
+	}
+	
+	@Test
+	public void testWithFalse() throws Exception {
+		Field a = classToTest.getDeclaredField("a");
+		a.setAccessible(true);
+		
+		assertEquals(42, a.get(instanceOfClass2));
+	}
+
+}

src/test/java/bytecode/InfTest.java

@@ -3,7 +3,7 @@ package bytecode;
 import static org.junit.Assert.*;
 
 import java.io.File;
-import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
 
@@ -12,7 +12,7 @@ import org.junit.Test;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
 
-public class FieldTph {
+public class InfTest {
 	
 	private static String path;
 	private static File fileToTest;
@@ -22,22 +22,16 @@ public class FieldTph {
 	private static String pathToClassFile;
 	private static Object instanceOfClass;
 	
-	@BeforeClass
+	@Test
-	public static void setUpBeforeClass() throws Exception {
+	public void generateBC() throws Exception {
-		path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/FieldTph.jav";
+		path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/Inf.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
-		compiler.generateBytecode(System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/");
 		pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
-		classToTest = loader.loadClass("FieldTph");
+		classToTest = loader.loadClass("Inf");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}
 
-	@Test
-	public void test() {
-		Field[] fields = classToTest.getFields();
-		assertEquals(1, fields.length);
-	}
-
 }

src/test/java/bytecode/KompTphTest.java

@@ -0,0 +1,37 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class KompTphTest {
+	
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@Test
+	public void generateBC() throws Exception {
+		path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/KompTph.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("KompTph");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+}

src/test/java/bytecode/MatrixOpTest.java

@@ -4,6 +4,7 @@ import static org.junit.Assert.*;
 
 import java.io.File;
 import java.io.IOException;
+import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URL;
@@ -27,7 +28,7 @@ public class MatrixOpTest {
 	private static Object instanceOfClass_m3;
 
 	@Test
-	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException, IOException, InstantiationException {	
+	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException, IOException, InstantiationException, NoSuchFieldException {	
 		path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/MatrixOP.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
@@ -35,7 +36,7 @@ public class MatrixOpTest {
 		compiler.generateBytecode(pathToClassFile);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("MatrixOP"); 
-/*		
+		
 		Vector<Vector<Integer>> vv = new Vector<Vector<Integer>>();
 		 Vector<Integer> v1 = new Vector<Integer> ();
 		 v1.addElement(2);
@@ -48,6 +49,7 @@ public class MatrixOpTest {
 		 //m1.addElement(v2);
 		 vv.addElement(v1);
 		 vv.addElement(v2);
+		 
 		 instanceOfClass_m1 = classToTest.getDeclaredConstructor(Vector.class).newInstance(vv);  //Matrix m1 = new Matrix(vv);
 
 		 Vector<Vector<Integer>> vv1 = new Vector<Vector<Integer>>();
@@ -62,13 +64,23 @@ public class MatrixOpTest {
 		 //m2.addElement(v4);
 		 vv1.addElement(v3);
 		 vv1.addElement(v4);
+		 
 		 instanceOfClass_m2 = classToTest.getDeclaredConstructor(Vector.class).newInstance(vv1);//Matrix m2 = new Matrix(vv1);
 		 
 		 
 
 		 //Matrix m3 = m1.mul(vv1);
-		 Method mul = classToTest.getDeclaredMethod("mul", Vector.class);
+//		 Method mul = classToTest.getDeclaredMethod("mul", Vector.class);
-		 Object result = mul.invoke(instanceOfClass_m1, instanceOfClass_m2);
+//		 Object result = mul.invoke(instanceOfClass_m1, instanceOfClass_m2);
+		 Field mul = classToTest.getField("mul");
+		 mul.setAccessible(true);
+		 
+		 Class<?> lambda = mul.get(instanceOfClass_m1).getClass();
+		 Method apply = lambda.getMethod("apply", Object.class,Object.class);
+		// Damit man auf die Methode zugreifen kann
+		 apply.setAccessible(true);
+		 
+		 Object result = apply.invoke(mul.get(instanceOfClass_m1),instanceOfClass_m1, instanceOfClass_m2);
 		 System.out.println(instanceOfClass_m1.toString() + " * " + instanceOfClass_m2.toString() + " = " + result.toString());
 		
 		 Vector<Vector<Integer>> res = new Vector<Vector<Integer>>();
@@ -85,7 +97,7 @@ public class MatrixOpTest {
 		 res.addElement(v6);
 		 instanceOfClass_m3 = classToTest.getDeclaredConstructor(Vector.class).newInstance(res);
 		 assertEquals(result, instanceOfClass_m3);
-*/		
+		
 	}
 
 }

src/test/java/bytecode/simplifyalgo/FinderTest.java

@@ -0,0 +1,64 @@
+package bytecode.simplifyalgo;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.objectweb.asm.Type;
+
+import de.dhbwstuttgart.bytecode.TPHExtractor;
+import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.utilities.ConstraintsFinder;
+import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
+import de.dhbwstuttgart.bytecode.utilities.Simplify;
+import de.dhbwstuttgart.typedeployment.TypeInsertPlacer;
+
+/**
+ * 
+ * @author Fayez Abu Alia
+ *
+ */
+public class FinderTest {
+
+	@Test
+	public void testM1() {
+		List<TPHConstraint> allCons = new ArrayList<>();
+		// L < M
+		TPHConstraint c1 = new ExtendsConstraint("L", "M", Relation.EXTENDS);
+		// L < N
+		TPHConstraint c2 = new ExtendsConstraint("L", "N", Relation.EXTENDS);
+		// M < O
+		TPHConstraint c3 = new ExtendsConstraint("M", "O", Relation.EXTENDS);
+		// M < P
+		TPHConstraint c4 = new ExtendsConstraint("M", "P", Relation.EXTENDS);
+
+		allCons.add(c1);
+		allCons.add(c2);
+		allCons.add(c3);
+		allCons.add(c4);
+		List<List<TPHConstraint>> res = new ArrayList<>();
+		List<TPHConstraint> l1 = new ArrayList<>();
+		List<TPHConstraint> l2 = new ArrayList<>();
+		
+		l1.add(c1);
+		l1.add(c2);
+		
+		l2.add(c3);
+		l2.add(c4);
+		
+		res.add(l1);
+		res.add(l2);
+		
+		ConstraintsFinder finder = new ConstraintsFinder(allCons);
+		
+		assertEquals(finder.findConstraints(), res);
+	}
+
+}

src/test/resources/bytecode/javFiles/FieldTphMMeth.jav

@@ -0,0 +1,27 @@
+import java.lang.Boolean;
+
+public class FieldTphMMeth {
+	a;
+	
+	public FieldTphMMeth(c,d,e) {
+		a = m(c,d,e);
+	}
+	
+	m(b,d,e) {
+		if(e) {
+			return m3(b);
+		} else{
+			return m3(d);
+		}
+		
+	}
+	
+	m2(b) {
+		a = m3(b);
+	}
+	
+	m3(b){
+		return b;
+	}
+	
+}

src/test/resources/bytecode/javFiles/Inf.jav

@@ -0,0 +1,19 @@
+public class Inf {
+	m(x,y,a){
+		var z; 
+		var v;
+		var w;
+		var b;
+		y=x;
+		z=x;
+		v=y;
+		w=y;
+		y=a;
+		b=a;
+	}
+}
+//     v    w 
+//      \  /
+//   z   y   b
+//    \ / \ /
+//     x   a

src/test/resources/bytecode/javFiles/KompTph.jav

@@ -0,0 +1,13 @@
+public class KompTph {
+	public m(a, b, c) {
+		var d = a;
+		var e = a;
+		a = b;
+		c = b;
+		m2(a,c);
+	}
+
+	public m2(a,b){
+		m(a,a,b);
+	}
+}

src/test/resources/bytecode/javFiles/MatrixOP.jav

@@ -18,7 +18,7 @@ public class MatrixOP   extends Vector<Vector<Integer>> {
 	  }
     }
 
-	mul = (m1, m2) -> {
+	public mul = (m1, m2) -> {
         var ret = new MatrixOP();
         var i = 0;
         while(i < m1.size()) {