Änderung von OLFun.jav zum originalen Sourcecode.

Rückgabetypen dieser werden nicht korrekt aufgelöst.
Dies muss geändert werden.
Deskriptoren nicht angepasst.
Da Basis-Interface FunN$$ mit erstellt wird, sind Tests noch korrekt.

README_aktuelle_Branches

@@ -0,0 +1,10 @@
+Stand: 24.5.21
+  bigRefactoring: Master-Brach
+  bigRefactoringUnifyComment: Dokumentation Unify, Martin
+  bytecodeGenericsSecond: Generated Generics, Ali, Martin
+  inferWildcards, Wildcards, Till
+  master, derzeit nicht genutzt
+  plugin, eigemntlicher Branch fuer Plugin-Basis, derzeit nicht aktuelle (aktuelle Version in simplifyRes
+  simplifyRes, Basis fuer Plugin, sollte auf Plugin gemerged werden, noch keine Packages, Michael
+  strucTypesNew, Struturelle Typen, alte Basis, arbeite derzeit niemand
+

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

@@ -584,6 +584,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		}
 	}
 
+	//ToDo Etienne: Für Type Erasure relevant?!
 	@Override
 	public void visit(LambdaExpression lambdaExpression) {
 		this.lamCounter++;
@@ -653,6 +654,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 //		generateBCForFunN(lambdaExpression, typeErasure);
 	}
 
+	//ToDo Etienne: Relevant?!
 	private String addUsedVarsToDesugaredMethodDescriptor(String lamDesc) {
 		String newDesc = "(";
 		int pos = 0;
@@ -674,6 +676,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		}
 	}
 
+	//ToDo Etienne: Relevant?!
 	private String createDescriptorWithTypeErasure(LambdaExpression lambdaExpression) {
 		String typeErasure = "(";
 		Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
@@ -767,6 +770,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		// This will be used if the class is not standard class (not in API)
 		ClassLoader cLoader2;
 
+		//ToDo methodCallType wird nicht korrekt resolved, da kein Constraint vorhanden ist
 		String methCallType = resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 		String[] typesOfParams = getTypes(methodCall.arglist.getArguments());
 		try {
@@ -811,11 +815,13 @@ public class BytecodeGenMethod implements StatementVisitor {
 					} catch (NotInCurrentPackageException | NotFoundException e) {
 						e.printStackTrace();
 					}
+					//ToDo Etienne: Für Type Erasure wichtig?!
 				} else if(!helper.isInCurrPkg(clazz)){
 					if(clazz.contains(CONSTANTS.$$)) {
+						//ToDo Methoden Deskriptor neu setzen
+						//ToDo Receiver neu setzen?!
 						mDesc = helper.getDescriptorOfApplyMethod(methCallType);
-						helper.generateBCForFunN(mDesc);
-//						mDesc = helper.generateBCForFunN(methCallType,typesOfParams);
+						helper.generateBCForFunN(typesOfParams, methCallType);
 					}else {
 						try {
 							cLoader2 = new DirectoryClassLoader(path, classLoader);
@@ -872,6 +878,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 			if(parentBinary || isBinaryExp) {
 				doUnboxing(resolver.getResolvedType(methodCall.getType()));
 			}
+			//ToDo Etienne: Für Type Erasure wichtig?!
 		} else if(receiverName.contains(CONSTANTS.$$) && !methCallType.equals(Type.getInternalName(Object.class))) {
 			helper.createCheckCast(methodCall,mv);
 		}
@@ -899,6 +906,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		}
 	}
 
+	//ToDo Etienne: Für Type Erasure wichtig?!
 	private void visitInvokeInsn(MethodCall methodCall, String receiverName, java.lang.reflect.Method methodRefl, String clazz, String mDesc, String receiverRefl) {
 		// is methodCall.receiver functional Interface)?
 		if (varsFunInterface.contains(methodCall.receiver.getType()) || (methodRefl!= null && receiverRefl.contains("interface")) ||

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

@@ -92,7 +92,7 @@ public class TPHExtractor extends AbstractASTWalker {
 			if (inMethod && !tphsClass.contains(tphName)) {
 				ArrayList<String> tphs = null;
 				if (!(tphs = methodAndTph.getTphs()).contains(tphName)) {
-					tphs.add(tphName);
+					methodAndTph.addTph(tphName);
 			    }
 				if (inLocalOrParamOrReturn) {
 					if (!(tphs = methodAndTph.getLocalTphs()).contains(tphName)) {
@@ -173,7 +173,7 @@ public class TPHExtractor extends AbstractASTWalker {
 	public void visit(GenericRefType genericRefType) {
 		String name = genericRefType.getParsedName();
 		if (inMethod) {
-			methodAndTph.getTphs().add(name);
+			methodAndTph.addTph(name);
 			if (inLocalOrParamOrReturn)
 				methodAndTph.getLocalTphs().add(name);
 		}else {
@@ -195,7 +195,7 @@ public class TPHExtractor extends AbstractASTWalker {
 	public void visit(Method method) {
 		inMethod = true;
 		String id = MethodUtility.createID(resolver,method);
-		Predicate<Pair> filterUndConstraints =  cs -> ((cs.TA1 instanceof TypePlaceholder) && (cs.TA1 instanceof TypePlaceholder) &&
+		Predicate<Pair> filterUndConstraints =  cs -> ((cs.TA1 instanceof TypePlaceholder) && (cs.TA2 instanceof TypePlaceholder) &&
 				(resultSet.resolveType((TypePlaceholder)(cs.TA1)).resolvedType instanceof TypePlaceholder) &&
 				(resultSet.resolveType((TypePlaceholder)(cs.TA2)).resolvedType instanceof TypePlaceholder));
 		    
@@ -209,10 +209,12 @@ public class TPHExtractor extends AbstractASTWalker {
 					  
 					csS.getOderConstraints()
 					   .forEach(oConSSet -> { Set<Constraint<Pair>> setCons = new HashSet<>();
-					            oConSSet.forEach(OConS -> { setCons.add(
+					            oConSSet.forEach(OConS -> { Constraint<Pair> newConsPair = new Constraint<Pair>();
+					            				 newConsPair.isStatement = OConS.isStatement;
+					            	             setCons.add(
 					                             OConS.stream()
 					                                  .filter(filterUndConstraints)
-					                                  .collect(Collectors.toCollection(Constraint<Pair>::new)) ); 
+					                                  .collect(Collectors.toCollection(() -> newConsPair)) ); 
 					                             } ); 
 					            ret.addOderConstraint(setCons);} );
 				return ret;

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

@@ -1,5 +1,10 @@
 package de.dhbwstuttgart.bytecode.constraint;
 
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
 public class TPHConstraint {
 	protected String left;
 	protected String right;
@@ -9,6 +14,12 @@ public class TPHConstraint {
 		EXTENDS, EQUAL
 	}
 	
+	public TPHConstraint(Pair p) {
+		this.left = ((TypePlaceholder)p.TA1).getName();
+		this.right = ((TypePlaceholder)p.TA2).getName();
+		this.rel = p.GetOperator().equals(PairOperator.SMALLERDOT) ? Relation.EXTENDS : Relation.EQUAL;
+	}
+	
 	public TPHConstraint(String left, String right, Relation rel) {
 		this.left = left;
 		this.right = right;
@@ -58,14 +69,16 @@ public class TPHConstraint {
 	public boolean equals (Object o) {
 		if (o instanceof TPHConstraint) {
 			TPHConstraint o_tphcons = (TPHConstraint)o;
-			return (left+right).equals(o_tphcons.getLeft()+o_tphcons.getRight());
+			return (this.left.equals(o_tphcons.getLeft())
+					&& this.right.equals(o_tphcons.getRight())
+					&& this.rel.equals(o_tphcons.rel));
 		}
 		else {
 			return false;
 		}
 	}
 	
-	/*
+	
 	@Override
 	public String toString() {
 		if(rel == Relation.EXTENDS) {
@@ -74,13 +87,4 @@ public class TPHConstraint {
 			return left + " = " + right;
 		}
 	}
-	*/
-	public String toString() {
-		if(rel == Relation.EXTENDS) {
-			return "new TPHConstraint(\"" + left + "\", \"" + right + "\", Relation.EXTENDS)";
-		}
-		else {
-			return "new TPHConstraint(\"" + left + "\", \"" + right + "\", Relation.EQUAL)";
-		}
-	}
 }

src/main/java/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java

@@ -68,6 +68,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 					}
 				}
 			}
+			//ToDo Etienne: Für Type Erasure wichtig?!
 			//TODO: generate a class java%% ... %%
 			else if(resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()).contains(CONSTANTS.ANGLEBRACKET)){
 				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "$$").replace(CONSTANTS.ANGLEBRACKET, "$$$").replace(">", "$$$")+ ";";
@@ -207,7 +208,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 		String desc = "(";
 		for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
 			String d = resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor());
-			
+			//ToDo Etienne: Ändern von $$ nötig für TypeErasure?
 			if(d.contains(CONSTANTS.TPH) ||d.contains(CONSTANTS.ANGLEBRACKET) || methodFromMethodCall.getReceiverName().contains("$$")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
@@ -225,6 +226,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 		System.out.println("DescriptorToString retType = " + retType);
 		if(retType.equals(CONSTANTS.VOID)) {
 			desc += ")V";
+			//ToDo Etienne: Ändern von $$ nötig für TypeErasure?
 		}else if(retType.contains(CONSTANTS.TPH)|| retType.contains(CONSTANTS.ANGLEBRACKET) || methodFromMethodCall.getReceiverName().contains("$$")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
@@ -240,6 +242,7 @@ public class DescriptorToString implements DescriptorVisitor, CONSTANTS {
 		return desc;
 	}
 
+	//ToDo Etienne: Ändern für TypeErasure
 	@Override
 	public String createDescForFunN(ArgumentList argumentList, String returnType) {
 		Iterator<Expression> itr1 = argumentList.getArguments().iterator();

src/main/java/de/dhbwstuttgart/bytecode/descriptor/DescriptorVisitor.java

@@ -11,7 +11,9 @@ public interface DescriptorVisitor {
 	String visit(NormalMethod method);
 	String visit(NormalConstructor constructor);
 	String visit(Lambda lambdaExpression);
+	//ToDo Etienne: Was ist SamMethod?
 	String visit(SamMethod samMethod);
+	//ToDo Etienne: Was ist MethodFromMethodCall?
 	String visit(MethodFromMethodCall methodFromMethodCall);
 	String createDescForFunN(ArgumentList argumentList, String returnType);
 }

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

@@ -29,5 +29,13 @@ public class GenericGeneratorResultsForAllMethods {
 	public List<MethodAndConstraints> getMethodsAndConstraints() {
 		return methodsAndConstraints;
 	}
+	
+	@Override
+	public String toString() {
+		String ret = "";
+		ret = ret + methodsAndConstraints.stream().reduce("", (x,y) -> x + y.toString(), (x,y) -> x + y);
+		//ret = ret + "\n";
+		return ret;
+	}
 
 }

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

@@ -52,4 +52,8 @@ public class GenericsGeneratorResult {
 		this.equalsTPHs = equalsTPHs;
 	}
 	
+	@Override
+	public String toString() {
+		return constraint.toString() + " EqualsTPS: " + equalsTPHs.toString();
+	}
 }

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

@@ -73,4 +73,12 @@ public class GenericsGeneratorResultForClass {
 			return Collections.emptyList();
 		}
 	}
+	
+	@Override
+	public String toString() {
+		String ret = "Classconstraints: ";
+		ret = ret + classConstraints.stream().reduce("", (x,y) -> x + y.toString(), (x,y) -> x + y);
+		ret = ret + "\n" + methodsAndTheirConstraints.toString(); 
+		return ret;
+	}
 }

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

@@ -33,4 +33,14 @@ public class MethodAndConstraints {
 		return constraints;
 	}
 	
+	
+	@Override
+	public String toString() {
+		String ret = methodID + ": ";
+		ret = ret + constraints.stream().reduce("", 
+				(x,y) -> x + y.toString(), 
+				(x,y) -> x + y);
+		ret = ret + "\n";
+		return ret;
+	}
 }

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

@@ -13,12 +13,4 @@ public class ClassConstraint extends TPHConstraint {
     /*public ClassConstraint(TPHConstraint constraint) {
         this.constraint = constraint;
     }*/
-    public String toString() {
-		if(rel == Relation.EXTENDS) {
-			return "new ClassConstraint(\"" + left + "\", \"" + right + "\", Relation.EXTENDS)";
-		}
-		else {
-			return "new ClassConstraint(\"" + left + "\", \"" + right + "\", Relation.EQUAL)";
-		}
-	}
 }

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

@@ -8,6 +8,7 @@ import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 import java.util.*;
 import java.util.function.Predicate;
 
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
@@ -21,6 +22,7 @@ public class FamilyOfGeneratedGenerics {
     // HashMap speichert ob TPH in einer Methode oder in der Klasse ist; und wenn es in der Methode ist, in welcher Methode
     public HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTPHs = new HashMap<>();
     public List<ClassConstraint> classConstraints = new ArrayList<>();
+    private HashMap<String, MethodAndTPH> mapMethodsAndTph = new HashMap<>();
     public List<MethodConstraint> methodConstraints = new ArrayList<>();
     public HashMap<String, List<MethodConstraint>> methodConstraintsWithPosition = new HashMap<>();
     public ResultSet resSet;
@@ -34,6 +36,7 @@ public class FamilyOfGeneratedGenerics {
         this.allConstraints = tphExtractor.allCons;
         this.posOfTPHs = positionConverter(tphExtractor.allTPHS, tphExtractor.ListOfMethodsAndTph);
         this.classConstraints = getClassConstraints(allConstraints,posOfTPHs);
+        tphExtractor.ListOfMethodsAndTph.forEach(matph -> this.mapMethodsAndTph.put(matph.getId(), matph));
         this.methodConstraints = getMethodConstraints(allConstraints,classConstraints,posOfTPHs, tphExtractor.ListOfMethodsAndTph);
         this.methodConstraintsWithPosition = getMethodConstraintsWithPositionNew(allConstraints,classConstraints,posOfTPHs, tphExtractor.ListOfMethodsAndTph, resSet, oldCons);
     }
@@ -60,7 +63,7 @@ public class FamilyOfGeneratedGenerics {
             }
         } while (addedToConstraintsListForCC2);
 
-        List<ClassConstraint> classConstraints3 = hasNoSupertypeForClassTypes(cs, cs_cl, posOfTphs);
+        List<ClassConstraint> classConstraints3 = hasNoSupertypeForClassTypes(cs_cl, posOfTphs);
         for (ClassConstraint cons: classConstraints3) {
             if (!checkForDuplicates(cons, cs_cl)) {
                 cs_cl.add(cons);
@@ -69,7 +72,7 @@ public class FamilyOfGeneratedGenerics {
         return cs_cl;
     }
 
-    public static List<MethodConstraint> getMethodConstraints(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, List<MethodAndTPH> listOfMethodsAndTph) {
+    public List<MethodConstraint> getMethodConstraints(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, List<MethodAndTPH> listOfMethodsAndTph) {
         List<MethodConstraint> cs_m = new ArrayList<>();
         List<MethodConstraint> methodConstraints1 = typeOfTheMethodInClSigma(cs, posOfTphs);
         for (MethodConstraint cons: methodConstraints1) {
@@ -114,7 +117,7 @@ public class FamilyOfGeneratedGenerics {
         return cs_m;
     }
 
-    public static HashMap<String, List<MethodConstraint>> getMethodConstraintsWithPosition(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, List<MethodAndTPH> listOfMethodsAndTph, ResultSet resSet, Set<Pair> oldCons) {
+    public HashMap<String, List<MethodConstraint>> getMethodConstraintsWithPosition(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, List<MethodAndTPH> listOfMethodsAndTph, ResultSet resSet, Set<Pair> oldCons) {
         HashMap<String, List<MethodConstraint>> tempMethodConstraintsWithPosition = new HashMap<>();
         for(MethodAndTPH method: listOfMethodsAndTph){
             List<String> methodsAddedToHashMap = new ArrayList<>();
@@ -224,28 +227,34 @@ public class FamilyOfGeneratedGenerics {
      * {T <. Object | ((T is a type variable in a type of a node of a field
      *                  or (\exists T~: (T~ <. T) \in cs_cl)) and (\existsnot T': T <. T') \in cs)}
      */
-    public static List<ClassConstraint> hasNoSupertypeForClassTypes(List<TPHConstraint> allConstraints, List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs) {
+    public static List<ClassConstraint> hasNoSupertypeForClassTypes(List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs) {
         List<ClassConstraint> tempCC= new ArrayList<>();
-        for(TPHConstraint allCons: allConstraints) {
-            for(ClassConstraint cCons: cs_cl) {
-                for(String tph: posOfTphs.keySet()) {
-                    for(PairTphMethod pair: posOfTphs.get(tph)) {
-                        boolean tvInField = pair.fst == PositionFinder.Position.FIELD;
-                        boolean hasSmallerTVInClCons = (posOfTphs.containsKey(cCons.getRight()) && cCons.getRight() == tph && cCons.getLeft() != null);
-                        if( ((tvInField || hasSmallerTVInClCons) && cCons.getRel()==Relation.EXTENDS) &&
-                                !checkUpperBound(allConstraints, tph)  && allCons.getRel()==Relation.EXTENDS) {
-                            ClassConstraint consToAdd = new ClassConstraint(tph, objectType, Relation.EXTENDS);
-                            if (!checkForDuplicates(consToAdd, tempCC)){
-                                tempCC.add(consToAdd);
-                            }
+        List<TPHConstraint> clCons = new ArrayList<>(cs_cl);
+            for(String tph: posOfTphs.keySet()) {
+                for(PairTphMethod pair: posOfTphs.get(tph)) {
+                    boolean tvInField = pair.fst == PositionFinder.Position.FIELD;
+                    boolean hasSmallerTVInClCons = hasSmallerTVInClCons(tph, cs_cl);
+                    if ((tvInField || hasSmallerTVInClCons) &&
+                            !checkUpperBound(clCons, tph)) {
+                        ClassConstraint consToAdd = new ClassConstraint(tph, objectType, Relation.EXTENDS);
+                        if (!checkForDuplicates(consToAdd, tempCC)) {
+                            tempCC.add(consToAdd);
                         }
                     }
                 }
             }
-        }
         return tempCC;
     }
 
+    public static boolean hasSmallerTVInClCons(String tph, List<ClassConstraint> cs_cl) {
+        for(ClassConstraint cC: cs_cl) {
+            if(tph == cC.getRight() && cC.getRel() == Relation.EXTENDS) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /**
      * 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}
@@ -275,7 +284,7 @@ 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
+    public 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);
@@ -300,7 +309,7 @@ public class FamilyOfGeneratedGenerics {
      * 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) {
+    public 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);
@@ -363,7 +372,7 @@ public class FamilyOfGeneratedGenerics {
 /**
      * nimm die Menge cs_cl aus cs_m raus
      */
-    public static List<MethodConstraint> methodTypesWithoutClassTypes(List<ClassConstraint> cs_cl, List<MethodConstraint> cs_m) {
+    public List<MethodConstraint> methodTypesWithoutClassTypes(List<ClassConstraint> cs_cl, List<MethodConstraint> cs_m) {
         // erstelle Kopie der Liste cs_cl
         List<TPHConstraint> tempCC = new ArrayList<>();
         for(ClassConstraint cc: cs_cl) {
@@ -409,7 +418,7 @@ public class FamilyOfGeneratedGenerics {
         return false;
     }
 
-    public static List<TPHConstraint> buildTransitiveClosure(List list) {
+    public List<TPHConstraint> buildTransitiveClosure(List list) {
         List<TPHConstraint> iterList = new ArrayList<>(list);
         List<TPHConstraint> runList = new ArrayList<>(list);
         List<TPHConstraint> tcList = new ArrayList<>(list);
@@ -496,27 +505,32 @@ public class FamilyOfGeneratedGenerics {
                 r = Relation.EQUAL;
             }
             MethodConstraint mc = new MethodConstraint(ta1, ta2, r);
-            if(mc.getRel() != Relation.EQUAL) {
-                if(!checkForDuplicates(mc, tempMC)) {
-                    tempMC.add(mc);
-                }
+            if(mc.getRel() == Relation.EXTENDS) {
+            	if (!mc.getLeft().equals(mc.getRight())) { //eliminieren der Fälle wie AA<.AA
+            		if(!checkForDuplicates(mc, tempMC)) {
+            			tempMC.add(mc);
+            		}
+            	}
             }
         }
         return tempMC;
     }
 
-    public static List<MethodConstraint> secondLineMethodDefinition(List<TPHConstraint> allConstraints, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, MethodAndTPH methodAndTPH, ResultSet resSet, Set<Pair> oldCons) {
-        List<MethodConstraint> tempMC = new ArrayList<>();
-        Set<Pair> tempSet = new HashSet<>();
+    public List<MethodConstraint> secondLineMethodDefinition(List<TPHConstraint> allConstraints, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, MethodAndTPH methodAndTPH, ResultSet resSet, Set<Pair> oldCons) {
+        List<MethodConstraint> tempMC = new ArrayList<>(); //für Ergebnisse basierend auf der neuen Datenstruktur (Ali)
+        Set<Pair> tempSet = new HashSet<>(); //für Ergebnisse des ersten Teils der Bedinung basierend auf der alten Datenstruktur
+        Set<Pair> tempSet2 = new HashSet<>(); //für Ergebnisse des zweiten Teils der Bedingung basierend auf der alten Datenstruktur
         Set<Pair> tcOfoldConsSet = buildTransitiveClosureForCP(oldCons, resSet);
+        List<TPHConstraint> tcOfCs = buildTransitiveClosure(allConstraints);
         MethodAndTPH methAndTphs = methodAndTPH;
+        Set<Pair> undCons =  methAndTphs.constraints.getUndConstraints();
         List<Set<Constraint<Pair>>> orCons = methAndTphs.constraints.getOderConstraints();
-        List<List<Constraint<Pair>>> orConsList = new ArrayList<>();
         List<HashMap<Relation, List<TPHConstraint>>> orConsListConverted = new ArrayList<>();
+        //gehe die OrConstraints der aktuellen Methode durch und teile nach Operator auf (
         for(int i=0; i<orCons.size(); i++) {
-            HashMap<Relation, List<TPHConstraint>> orConsInternal = new HashMap<>();
             List<TPHConstraint> orConsWithEQUAL = new ArrayList();
             List<TPHConstraint> orConsWithEXTENDS = new ArrayList();
+            HashMap<Relation, List<TPHConstraint>> orConsInternal = new HashMap<>();
             for(Constraint con: orCons.get(i)) {
                 Iterator<Pair> it = con.iterator();
                 while(it.hasNext()) {
@@ -525,10 +539,10 @@ public class FamilyOfGeneratedGenerics {
                     if(p.GetOperator() == PairOperator.SMALLERDOT) {
                         r = Relation.EXTENDS;
                         orConsWithEXTENDS.add(new TPHConstraint(((TypePlaceholder) p.TA1).getName(), ((TypePlaceholder) p.TA2).getName(), r));
-                        MethodConstraint mc = new MethodConstraint(((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA1)).resolvedType)).getName(), ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA2)).resolvedType)).getName(), r);
+                        /*MethodConstraint mc = new MethodConstraint(((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA1)).resolvedType)).getName(), ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA2)).resolvedType)).getName(), r);
                         if(!checkForDuplicates(mc, tempMC)) {
                             tempMC.add(mc);
-                        }
+                        }*/
                     } else if(p.GetOperator() == PairOperator.EQUALSDOT) {
                         r = Relation.EQUAL;
                         orConsWithEQUAL.add(new TPHConstraint(((TypePlaceholder) p.TA1).getName(), ((TypePlaceholder) p.TA2).getName(), r));
@@ -544,6 +558,8 @@ public class FamilyOfGeneratedGenerics {
             orConsListConverted.add(orConsInternal);
         }
 
+        // oldCons sind alle Und- und Oder-Constraints
+        // zunächst in meine Datenstruktur(Ali) konvertieren
         List<Pair> oldConsList = new ArrayList<>(oldCons);
         List<TPHConstraint> oldConsListConverted = new ArrayList<>();
         for(Pair pair: oldConsList) {
@@ -555,54 +571,106 @@ public class FamilyOfGeneratedGenerics {
             }
             oldConsListConverted.add(new TPHConstraint(((TypePlaceholder) pair.TA1).getName(), ((TypePlaceholder) pair.TA2).getName(), r));
         }
-//        List<TPHConstraint> tcOfoldCons =  buildTransitiveClosure(oldConsListConverted);
-//        Set<Pair> tcOfoldConsSet = buildTransitiveClosureForCP(oldCons);
 
-//        for(int i=0; i<orConsListConverted.size(); i++) {
+
+        // Berechnung des zweiten Teils der Bedingung der Regel
         for(int i=0; i<orCons.size(); i++) {
             Constraint<Pair> extendsSet = new Constraint<Pair>();
             Constraint<Pair> equalSet = new Constraint<Pair>();
-            for(Constraint con: orCons.get(i)) {
+            //für jede einzelne OrConstraint-Menge gehe durch
+            for (Constraint con : orCons.get(i)) {
                 Iterator<Pair> it = con.iterator();
                 while (it.hasNext()) {
                     Pair p = it.next();
-//            List<TPHConstraint> extendsList = orConsListConverted.get(i).get(Relation.EXTENDS);
-//            List<TPHConstraint> equalList = orConsListConverted.get(i).get(Relation.EQUAL);
                     if (p.OperatorSmallerDot()) {
                         extendsSet.add(p);
                     } else if (p.OperatorEqual()) {
                         equalSet.add(p);
                     }
                 }
-//                for (TPHConstraint ex : extendsList) {
-                Iterator<Pair> itExtends = extendsSet.iterator();
-                while(itExtends.hasNext()) {
-                    Pair pairExtends = itExtends.next();
-//                    for (TPHConstraint eq : equalList) {
-                    Iterator<Pair> itEqual = equalSet.iterator();
-                    while(itEqual.hasNext()) {
-                        Pair pairEqual = itEqual.next();
-//                        MethodConstraint mc = new MethodConstraint(ex.getRight(), eq.getLeft(), Relation.EXTENDS);
-                        Pair newPair = new Pair(resSet.resolveType((TypePlaceholder)(pairExtends.TA2)).resolvedType, resSet.resolveType((TypePlaceholder)(pairEqual.TA1)).resolvedType, PairOperator.SMALLERDOT);
-//                        for (TPHConstraint tc : tcOfoldCons) {
-                        Iterator<Pair> itTC = tcOfoldConsSet.iterator();
-                        while(itTC.hasNext()) {
-                            Pair pairTC = itTC.next();
-//                            if (tc.getLeft() == mc.getLeft() && tc.getRight() == mc.getRight() && tc.getRel() == mc.getRel()) {
-                            if(resSet.resolveType((TypePlaceholder)(pairTC.TA1)).resolvedType == newPair.TA1 && resSet.resolveType((TypePlaceholder)(pairTC.TA2)).resolvedType == newPair.TA2 && pairTC.OperatorSmallerDot() && newPair.OperatorSmallerDot()) { //hier bei pairTC resolvedType, damit Pairs aus oldCons in der Methode zur Berechnung von der transitiven Hülle nicht in eine Endlosschleife kommen (Cycles!)
-//                                if (!checkForDuplicates(mc, tempMC)) {
-                                if(newPair.TA1 != newPair.TA2) {
-                                    if (!checkForDuplicatesForSets(newPair, tempSet)) {
-                                        tempSet.add(newPair);
+                Iterator<Pair> itExtends2 = extendsSet.iterator();
+                while(itExtends2.hasNext()) {
+                    Pair pairExtends2 = itExtends2.next();
+                    Set<String> containedVars = new HashSet<>(methodAndTPH.getTphs());
+                    String pairExtends2RHSName = ((TypePlaceholder)((resSet.resolveType((TypePlaceholder)pairExtends2.TA2)).resolvedType)).getName();
+                    Iterator<Pair> itEqual2 = equalSet.iterator();
+                    while (itEqual2.hasNext()) {
+                    	boolean transClo = false;
+                        Pair pairEqual2 = itEqual2.next();
+                        //TODO: Auf trans.FamilyOfGeneratedGenerics Huelle pruefen
+                        Pair newPairOld = new Pair(pairExtends2.TA2, pairEqual2.TA1);
+                        Pair newPair2 = new Pair(resSet.resolveType((TypePlaceholder) (pairExtends2.TA2)).resolvedType, resSet.resolveType((TypePlaceholder) (pairEqual2.TA1)).resolvedType, PairOperator.SMALLERDOT);
+                        TPHConstraint newPairTPHConstraint = new TPHConstraint(newPair2);
+                        if (tcOfCs.contains(newPairTPHConstraint)|| (newPairTPHConstraint.getLeft().equals(newPairTPHConstraint.getRight()))) {
+                        	transClo = true;
+                        }
+                        TypePlaceholder tphR = (TypePlaceholder) pairEqual2.TA2;
+                        Iterator<Pair> itUndCons = undCons.iterator();
+                        boolean rEqExRtilde = false;
+                        while (itUndCons.hasNext()) {
+                            Pair pairUndCons2 = itUndCons.next();
+                            rEqExRtilde = rEqExRtilde || (tphR == pairUndCons2.TA1);
+                        }            
+                        boolean isPairInTExTapostrophe = false;
+                        for(Set<Constraint<Pair>> scp: orCons) {
+                        	Iterator<Constraint<Pair>> itSCP = scp.iterator();
+                        	while(itSCP.hasNext()) {
+                        		Constraint<Pair> cp = itSCP.next();
+                        		Iterator<Pair> itCP = cp.iterator();
+                        		while(itCP.hasNext()) {
+                        			Pair p = itCP.next();
+                        			if(p.OperatorSmallerDot()) {
+                        				isPairInTExTapostrophe = isPairInTExTapostrophe || tphR.equals(p.TA1);
                                     }
                                 }
                             }
+                            
                         }
+                               
+                        if (transClo && (rEqExRtilde || isPairInTExTapostrophe)) {
+                        	if (!newPair2.TA1.equals(newPair2.TA2)) { //eliminieren der Fälle wie AA<.AA
+                        		if (!checkForDuplicatesForSets(newPair2, tempSet2)) {
+                        			tempSet2.add(newPair2);
+                        		}
+                        	}
+                        	if (!checkForDuplicatesForSets(pairExtends2, tempSet2)) {
+                        		tempSet2.add(pairExtends2);
+                        	}
+                        }
+                        else {
+                        	//containedVars.remove(((TypePlaceholder)newPair2.TA2).getName());
+                        }
+                        	
+                    }	
+                    
+                    //String key = ((TypePlaceholder)((resSet.resolveType((TypePlaceholder)pairExtends2.TA2)).resolvedType)).getName();
+                    //TODO: containedVars stimmt noch nicht. Ueberpruefen, ob ggf. mit den containedVars möglicherweise auch die anderen Faelle
+                    //      rEqExRtilde isPairInTExTapostrophe abgedeckt sind => ggf. integrieren
+                    /*
+                    posOfTphs.forEach((x,y) -> { 
+                                       if (y.contains(new PairTphMethod<>(PositionFinder.Position.METHOD, methodAndTPH.getId()))) {
+                                    	   containedVars.add(x);
+                                       };
+                                      }
+                    		         );
+                    */
+                    //Referenzbeispiel Put.jav
+                    if (containedVars.stream().filter(v -> tcOfCs.contains(new TPHConstraint(pairExtends2RHSName, v, Relation.EXTENDS)))
+                    		                  .count() > 0) { 
+                    	System.out.println();
+                    	//tempSet2.add(pairExtends2);
                     }
+                    if (posOfTphs.containsKey(pairExtends2RHSName)) {//Refrenzbeispiel TestVector.jav
+                    	if (posOfTphs.get(pairExtends2RHSName).contains(new PairTphMethod<>(PositionFinder.Position.METHOD, methodAndTPH.getId()))) {
+                    		tempSet2.add(pairExtends2);
+                    	}
+                    } 
                 }
             }
         }
 
+
+        // aus der alten Datenstruktur in die neue Datenstruktur (von Ali) für ersten Teil
         Iterator<Pair> itTemp = tempSet.iterator();
         while(itTemp.hasNext()) {
             Pair p = itTemp.next();
@@ -615,13 +683,35 @@ public class FamilyOfGeneratedGenerics {
                 r = Relation.EQUAL;
             }
             MethodConstraint mc = new MethodConstraint(ta1, ta2, r);
-            if(mc.getRel() != Relation.EQUAL) {
+            if(mc.getRel() == Relation.EXTENDS) {
                 if(!checkForDuplicates(mc, tempMC)) {
                     tempMC.add(mc);
                 }
             }
         }
 
+        // aus der alten Datenstruktur in die neue Datenstruktur (von Ali) für zweiten Teil
+        Iterator<Pair> itTemp2 = tempSet2.iterator();
+        while(itTemp2.hasNext()) {
+            Pair p = itTemp2.next();
+            String ta1 = ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA1)).resolvedType)).getName();
+            String ta2 = ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA2)).resolvedType)).getName();
+            Relation r = null;
+            if (p.GetOperator() == PairOperator.SMALLERDOT) {
+                r = Relation.EXTENDS;
+            } else if (p.GetOperator() == PairOperator.EQUALSDOT) {
+                r = Relation.EQUAL;
+            }
+            for(TPHConstraint tphCons: tcOfCs) {//TODO: hier werden Elemente der Trans. clo herausgenommen, aber die dazugehoerigen OrCons nicht.
+                if(ta1 == tphCons.getLeft() && ta2 == tphCons.getRight() && r==Relation.EXTENDS) {
+                    MethodConstraint mc = new MethodConstraint(ta1, ta2, r);
+                    if(!checkForDuplicates(mc, tempMC)) {
+                        tempMC.add(mc);
+                    }
+                }
+            }
+        }
+
         return tempMC;
     }
 
@@ -678,27 +768,43 @@ public class FamilyOfGeneratedGenerics {
         return false;
     }
 
-    public static List<MethodConstraint> hasNoSupertypeForMethodTypesNew(List<TPHConstraint> allConstraints, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, MethodAndTPH methodAndTPH) {
+    public static List<MethodConstraint> hasNoSupertypeForMethodTypesNew(HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, MethodAndTPH methodAndTPH, List<MethodConstraint> cs_m) {
         List<MethodConstraint> tempMC = new ArrayList<>();
-        List<TPHConstraint> allCons = allConstraints;
+        List<TPHConstraint> methCons = new ArrayList<>(cs_m);
         MethodAndTPH methAndTphs = methodAndTPH;
         for(String tph: posOfTphs.keySet()) {
             for(int i=0; i<posOfTphs.get(tph).size(); i++)
-            if(posOfTphs.get(tph).get(i).fst == PositionFinder.Position.METHOD && posOfTphs.get(tph).get(i).snd == methAndTphs.getId()) {
-                for(TPHConstraint ac: allCons) {
-                    if(tph==ac.getRight() && !checkUpperBound(allCons,tph)) {
-                        MethodConstraint mc2 = new MethodConstraint(tph, objectType, Relation.EXTENDS);
-                        if(!checkForDuplicates(mc2, tempMC)) {
-                            tempMC.add(mc2);
-                        }
-                    }
+            if(posOfTphs.get(tph).get(i).fst == PositionFinder.Position.METHOD && posOfTphs.get(tph).get(i).snd == methAndTphs.getId() && !checkUpperBound(methCons,tph)) {
+                MethodConstraint mc2 = new MethodConstraint(tph, objectType, Relation.EXTENDS);
+                if (!checkForDuplicates(mc2, tempMC)) {
+                    tempMC.add(mc2);
                 }
             }
         }
         return tempMC;
     }
 
-    public static HashMap<String, List<MethodConstraint>> getMethodConstraintsWithPositionNew(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, List<MethodAndTPH> listOfMethodsAndTph, ResultSet resSet, Set<Pair> oldCons) {
+
+
+    public static List<MethodConstraint> methodTypesWithoutClassTypesNEW(List<String> tphsToCompute, List<MethodConstraint> cs_m) {
+        List<MethodConstraint> tempMC = new ArrayList<>(cs_m);
+        List<MethodConstraint> tempMC2 = new ArrayList<>(cs_m);
+        List<String> toRemove = new ArrayList<>();
+        for(String tph: tphsToCompute) {
+            for(TPHConstraint tphCons: tempMC) {
+                if(tphCons.getLeft() == tph) {
+                    toRemove.add(tphCons.getRight());
+                    tempMC2.remove(tphCons);
+                    tempMC2 = methodTypesWithoutClassTypesNEW(toRemove,tempMC2);
+                }
+            }
+        }
+        return tempMC2;
+    }
+
+
+
+    public HashMap<String, List<MethodConstraint>> getMethodConstraintsWithPositionNew(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, List<MethodAndTPH> listOfMethodsAndTph, ResultSet resSet, Set<Pair> oldCons) {
         HashMap<String, List<MethodConstraint>> tempMethodConstraintsWithPosition = new HashMap<>();
         List<MethodConstraint> newMCList = new ArrayList<>();
         List<MethodConstraint> newMCList2 = new ArrayList<>();
@@ -736,14 +842,23 @@ public class FamilyOfGeneratedGenerics {
                     tempMethodConstraintsWithPosition.put(currentMethod, newMCList2);
                 }*/
 
-                hasNoSupType = hasNoSupertypeForMethodTypesNew(cs,posOfTphs,method);
+                hasNoSupType = hasNoSupertypeForMethodTypesNew(posOfTphs,method,listToAdd);
                 for (MethodConstraint cons: hasNoSupType) {
                     if (!checkForDuplicates(cons, listToAdd)) {
                         listToAdd.add(cons);
                     }
                 }
 
-                mcWithoutCc = methodTypesWithoutClassTypes(cs_cl, listToAdd);
+                mcWithoutCc = listToAdd;
+                List<String> tphs = new ArrayList<>();
+                for(String tph: posOfTphs.keySet()) {
+                    for (PairTphMethod p : posOfTphs.get(tph)) {
+                        if(p.fst == PositionFinder.Position.FIELD) {
+                            tphs.add(tph);
+                            mcWithoutCc = methodTypesWithoutClassTypesNEW(tphs, listToAdd);
+                        }
+                    }
+                }
 
                 tempMethodConstraintsWithPosition.put(currentMethod, mcWithoutCc);
             }
@@ -760,25 +875,6 @@ public class FamilyOfGeneratedGenerics {
 
         return tempMethodConstraintsWithPosition;
     }
-    
-    public String toString() {
-    	String ret =
-    	"List<ClassConstraint> classConstraintsTest = new ArrayList<>();\n";
-    	for(ClassConstraint cC: classConstraints) {
-    		ret = ret + "classConstraintsTest.add(" + cC.toString() + ");\n";
-    	}
-    	ret = ret + "HashMap<String, List<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();\n";
-        ret = ret + "List<MethodConstraint> lmc;\n";
-    	for (String methName : methodConstraintsWithPosition.keySet()) {
-        	String consSet = "";
-        	ret = ret + "lmc = new ArrayList<>();\n";
-        	for (MethodConstraint methConstrs : methodConstraintsWithPosition.get(methName)) {
-        		consSet = consSet + "lmc.add(" + methConstrs + ");\n";
-        	}
-        	ret = ret + consSet + "methodConstraintsWithPositionTest.put(\""+ methName + "\",  lmc);\n";
-        }
-        return ret;
-    }
 
 
 }

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

@@ -7,13 +7,4 @@ public class MethodConstraint extends TPHConstraint {
     public MethodConstraint(String left, String right, Relation rel) {
         super(left, right, rel);
     }
-    
-    public String toString() {
-		if(rel == Relation.EXTENDS) {
-			return "new MethodConstraint(\"" + left + "\", \"" + right + "\", Relation.EXTENDS)";
-		}
-		else {
-			return "new MethodConstraint(\"" + left + "\", \"" + right + "\", Relation.EQUAL)";
-		}
-	}
 }

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

@@ -136,6 +136,7 @@ public class Signature {
 		defineGenericsFromConstraints(constraints,genericsAndBoundsMethod);
 	}
 
+	//ToDo Etienne: für TypeErasure anschauen
 	private void createSignatureForFunN(int numberOfParams, String to, String[] paramTypes) {
 		defineTypeVariablesForParametersOfFunN(numberOfParams);
 
@@ -147,6 +148,7 @@ public class Signature {
 
 	}
 
+	//ToDo Etienne: für TypeErasure anschauen
 	private void createSignatureForFunN(int numberOfParams) {
 
 		defineTypeVariablesForParametersOfFunN(numberOfParams);
@@ -202,6 +204,7 @@ public class Signature {
 			if (r instanceof GenericRefType) {
 				sv.visitTypeVariable(sig2);
 			} else if (!(r instanceof TypePlaceholder)) {
+				//ToDo Etienne: Wichtig für Type Erasure?!
 				if (sig2.contains(SPECIAL_CHAR_FOR_FUN)) {
 					sv.visitInterface().visitClassType(sig2.substring(1));
 				} else {
@@ -266,6 +269,7 @@ public class Signature {
 	}
 
 	private void checkInnerSignatureOfWildCard(SignatureVisitor sv, String sigInner, int length, char superOrExtendsChar) {
+		//ToDo Etienne: Wichtig für Type Erasure?!
 		if (sigInner.contains(SPECIAL_CHAR_FOR_FUN)) {
 			sv.visitTypeArgument(superOrExtendsChar).visitInterface().visitClassType(sigInner.substring(1, length));
 		} else {

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

@@ -99,4 +99,34 @@ public class TypeToSignature implements TypeVisitor<String> {
 				.filter(c -> c.getConstraint().getLeft().equals(tph) || c.getEqualsTPHs().contains(tph))
 				.findFirst();
 	}
+
+	/**
+	 * //ToDo beschreiben
+	 *
+	 * @param type
+	 * @return
+	 *
+	 * @since Studienarbeit Type Erasure
+	 * @author Etienne Zink
+	 */
+	public String visit(RefTypeOrTPHOrWildcardOrGeneric type){
+		String returnString = "";
+		if (type instanceof GenericRefType){
+			GenericRefType genericRefType = (GenericRefType) type;
+			returnString += visit(genericRefType);
+		} else if (type instanceof RefType){
+			RefType refType = (RefType) type;
+			returnString += visit(refType);
+		} else if (type instanceof TypePlaceholder){
+			TypePlaceholder typePlaceholder = (TypePlaceholder) type;
+			returnString += visit(typePlaceholder);
+		} else if (type instanceof SuperWildcardType){
+			SuperWildcardType superWildcardType = (SuperWildcardType) type;
+			returnString += visit(superWildcardType);
+		} else if (type instanceof ExtendsWildcardType) {
+			ExtendsWildcardType extendsWildcardType = (ExtendsWildcardType) type;
+			returnString += visit(extendsWildcardType);
+		}
+		return returnString;
+	}
 }

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

@@ -1,25 +1,38 @@
 package de.dhbwstuttgart.bytecode.utilities;
 
 import de.dhbwstuttgart.bytecode.signature.Signature;
+import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
 import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
 import de.dhbwstuttgart.syntaxtree.statement.Expression;
 import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
+import de.dhbwstuttgart.syntaxtree.type.*;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.MethodVisitor;
-import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.objectweb.asm.signature.SignatureVisitor;
 import org.objectweb.asm.signature.SignatureWriter;
 
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
+import java.io.*;
+import java.sql.Ref;
+import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.objectweb.asm.Opcodes.*;
 
 public class ByteCodeForFunNGenerator {
 
+    /**
+     * HashSet which contains the parameter number for which already a FunN$$ interface was generated.
+     *
+     * @since Studienarbeit Type Erasure
+     * @author Etienne Zink
+     */
+    private static HashSet<Integer> alreadyGeneratedFunN = new HashSet<>();
+
+    //ToDo Etienne: wird in Test OLFun nicht verwendet!
     public static void generateBCForFunN(LambdaExpression lambdaExpression, String methDesc, File path) {
         ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
 
@@ -38,57 +51,121 @@ public class ByteCodeForFunNGenerator {
         // ")"+lam.getReturn.getBounds
         Signature sig = new Signature(numberOfParams);
         String name = CONSTANTS.FUN + numberOfParams + CONSTANTS.$$;
-        classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC+Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT, name, sig.toString(),
+        classWriter.visit(V1_8, ACC_PUBLIC + ACC_INTERFACE + ACC_ABSTRACT, name, sig.toString(),
                 Type.getInternalName(Object.class), null);
-        MethodVisitor mvApply = classWriter.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT, "apply", methDesc,
+        MethodVisitor mvApply = classWriter.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "apply", methDesc,
                 methSig.toString(), null);
         mvApply.visitEnd();
-        writeClassFile(classWriter.toByteArray(), name, path);
+        writeClassFile(name, classWriter.toByteArray(), path);
     }
 
-    public static void generateBCForFunN(ArgumentList argumentList, String methDesc, File path) {
+    /**
+     * //ToDo beschreiben
+     *
+     * @param typesOfFormalParameters
+     * @param returnType
+     * @param path
+     *
+     * @since Studienarbeit Type Erasure
+     * @author Etienne Zink
+     */
+    public static void generateBCForFunN(String[] typesOfFormalParameters, String returnType, File path) {
         ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
+        int numberOfParameters = typesOfFormalParameters.length;
+        generateSuperFunNInterface(numberOfParameters, path);
 
-        SignatureWriter methSig = new SignatureWriter();
+        String className = getBaseFunClassname(numberOfParameters);
+        String classSignature = String.format("L%s;L%s<", Type.getInternalName(Object.class), className);
 
-        int numberOfParams = 0;
-        SignatureVisitor paramVisitor = methSig.visitParameterType();
-        Iterator<Expression> itr1 = argumentList.getArguments().iterator();
-
-        while(itr1.hasNext()) {
-            numberOfParams++;
-            // getBounds
-            paramVisitor.visitTypeVariable(CONSTANTS.T + numberOfParams);
-            itr1.next();
+        //ToDo testen ob der Klassenname und -signatur so passt
+        for (String typeOfFormalParameter: typesOfFormalParameters) {
+            className += String.format("%s$_$", typeOfFormalParameter);
+            classSignature += String.format("L%s;", typeOfFormalParameter);
         }
+        className += returnType;
+        className = className.replace('/', '$');
+        classSignature += String.format("L%s>;", returnType);
 
-        methSig.visitReturnType().visitTypeVariable(CONSTANTS.R);
-        // ")"+lam.getReturn.getBounds
-        Signature sig = new Signature(numberOfParams);
-        String name = CONSTANTS.FUN + numberOfParams + CONSTANTS.$$;
-        classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC+Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT, name, sig.toString(),
-                Type.getInternalName(Object.class), null);
-        MethodVisitor mvApply = classWriter.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT, "apply", methDesc,
-                methSig.toString(), null);
-        mvApply.visitEnd();
-        writeClassFile(classWriter.toByteArray(), name, path);
+        System.out.println("Generated className: " + className);
+        System.out.println("Generated signature: " + classSignature);
+
+        classWriter.visit(V1_8, ACC_PUBLIC | ACC_INTERFACE | ACC_ABSTRACT, className, classSignature,
+                Type.getInternalName(Object.class), new String[]{getBaseFunClassname(numberOfParameters)});
+        writeClassFile(className, classWriter.toByteArray(), path);
     }
 
+    /**
+     * Function which generates a {@code class-File} for the super interface
+     * Fun<{@code numberOfParameters}>$$ if it doesn't exist already.
+     *
+     * @param numberOfParameters
+     * @return {@code true}, iff the {@code class-File} exists after this method invocation
+     * based on {@link #alreadyGeneratedFunN alreadyGeneratedFunN}.
+     *
+     * @since Studienarbeit Type Erase
+     * @author Etienne Zink
+     */
+    public static boolean generateSuperFunNInterface(int numberOfParameters, File path){
+        if(alreadyGeneratedFunN.contains(numberOfParameters)) return true;
+        //ToDo Etienne: Generierung der Signaturen/Deskriptoren vielleicht auslagern? Bzw. schauen ob nicht schon vorhanden und anpassen!
+        String className = getBaseFunClassname(numberOfParameters);
+        String classSignature = "<";
+        String methodSignature = "(";
+        String methodDescriptor = "(";
+        for (int parameter = 1; parameter <= numberOfParameters; parameter++) {
+            classSignature += String.format("T%d:L%s;", parameter, Type.getInternalName(Object.class));
+            methodSignature += String.format("TT%d;", parameter);
+            methodDescriptor += String.format("L%s;", Type.getInternalName(Object.class));
+        }
+        classSignature += String.format("R:L%s;>L%s;",Type.getInternalName(Object.class),Type.getInternalName(Object.class));
+        methodSignature += ")TR;";
+        methodDescriptor += String.format(")L%s;",Type.getInternalName(Object.class));
 
-    public static void writeClassFile(byte[] bytecode, String name, File path) {
-        FileOutputStream output;
-        try {
-            System.out.println("generating " + name + ".class file...");
-            output = new FileOutputStream(
-                    new File(path , name + CONSTANTS.EXTENSIONCLASS));
+        ClassWriter classWriter = new ClassWriter(0);
+        classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, className, classSignature, Type.getInternalName(Object.class), null);
+
+        MethodVisitor methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, "apply", methodDescriptor, methodSignature, null);
+        methodVisitor.visitEnd();
+        classWriter.visitEnd();
+
+        byte[] bytecode = classWriter.toByteArray();
+        if(writeClassFile(className, bytecode, path)) {
+            alreadyGeneratedFunN.add(numberOfParameters);
+        }
+        return alreadyGeneratedFunN.contains(numberOfParameters);
+    }
+
+    /**
+     *
+     * @param countParameters
+     * @return the String of the super Fun$$ type
+     *
+     * @since Studienarbeit Type Erasure
+     * @author Etienne Zink
+     */
+    private static String getBaseFunClassname(int countParameters){
+        return String.format("Fun%d$$", countParameters);
+    }
+
+    /**
+     * Generates a {@code class-File} for the class {@code className} with the {@code bytecode}.
+     *
+     * @param className of the class to generate
+     * @param bytecode of the class
+     * @param directory where the class should be saved to
+     * @return {@code true}, iff the {@code class-File} could be generated.
+     *
+     * @since Studienarbeit Type Erasure
+     * @author Etienne Zink
+     */
+    private static boolean writeClassFile(String className, byte[] bytecode, File directory) {
+        try (FileOutputStream output = new FileOutputStream(new File(directory , className + CONSTANTS.EXTENSIONCLASS))){
             output.write(bytecode);
-            output.close();
-            System.out.println(name + ".class file generated");
-        } catch (FileNotFoundException e) {
-            e.printStackTrace();
-        } catch (IOException e) {
+            output.flush();
+            return true;
+        } catch (Exception e) {
             e.printStackTrace();
         }
-
+        return false;
     }
-}
+}

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

@@ -27,7 +27,11 @@ public class MethodAndTPH {
 		this.id = name;
 		this.constraints = constraints;
 	}
-
+	
+	public void addTph(String tph) {
+		tphs.add(tph);
+	}
+	
 	public ArrayList<String> getTphs() {
 		return tphs;
 	}
@@ -47,4 +51,9 @@ public class MethodAndTPH {
 		return localTphs;
 	}
 	
+	@Override
+	public String toString() {
+		return id;
+	} 
+	
 }

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

@@ -220,10 +220,13 @@ public class MethodCallHelper {
 		}
 	}
 
-	public void generateBCForFunN(String methodDescriptor) {
-		ByteCodeForFunNGenerator.generateBCForFunN(methCall.arglist,methodDescriptor,path);
+	//ToDo Etienne: Für Type Erasure wichtig?!
+	public void generateBCForFunN(String[] typesOfFormalParams, String receiverType) {
+		//ToDo return Descriptor auf apply Methode?
+		ByteCodeForFunNGenerator.generateBCForFunN(typesOfFormalParams, receiverType,path);
 	}
 
+	//ToDo Etienne: Für Type Erasure wichtig
 	public String getDescriptorOfApplyMethod(String methodCallType) {
 		return new DescriptorToString().createDescForFunN(methCall.arglist, methodCallType);
 	}

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

@@ -884,6 +884,7 @@ public class JavaTXCompiler {
 		return result;
 	}
 
+	//ToDo Etienne: Für Type Erasure wichtig?! (alle generatedBytecode-Methoden?)
 	public void generateBytecode() throws ClassNotFoundException, IOException, BytecodeGeneratorError {
 		generateBytecode((File) null);
 	}

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

@@ -216,6 +216,7 @@ public class StatementGenerator {
         MethodCall ret = new MethodCall(TypePlaceholder.fresh(methodInvocationContext.getStart()), 
         		getReceiver(receiver), name, argumentList, TypePlaceholder.fresh(methodInvocationContext.getStart()), 
         		argTypes, methodInvocationContext.getStart());
+        ret.setStatement();
         return ret;
     }
 
@@ -271,8 +272,10 @@ public class StatementGenerator {
             whole+=".";
         }
 
-        if(parts.length < 2){
+        if(parts.length < 2 || parts[0].contentEquals("this") ){
             receiver = new This(offset);
+        } else if (parts[0].contentEquals("super")) {
+        	receiver = new Super(offset);
         }else if(receiver == null){ //Handelt es sich um keinen Statischen Klassennamen:
             String part = expression.substring(0,expression.length() - (1 + parts[parts.length-1].length()));
             receiver = generateLocalOrFieldVarOrClassName(part, offset);
@@ -302,33 +305,45 @@ public class StatementGenerator {
         ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = args.getArguments().stream()
         		.map(x -> TypePlaceholder.fresh(newExpression.getStart()))
         		.collect(Collectors.toCollection(ArrayList::new));
-        return new NewClass(newClass, args, null, argTypes, newExpression.getStart());
+        Statement ret = new NewClass(newClass, args, null, argTypes, newExpression.getStart());
+        ret.setStatement();
+        return ret;
     }
 
     private Statement convert(Java8Parser.PreIncrementExpressionContext stmt) {
     		Expression argument = convert(stmt.unaryExpression());
     		Token offset = stmt.getStart();
-    		return new UnaryExpr(UnaryExpr.Operation.PREINCREMENT, argument, TypePlaceholder.fresh(offset), offset);
-    }
+    		Statement ret =  new UnaryExpr(UnaryExpr.Operation.PREINCREMENT, argument, TypePlaceholder.fresh(offset), offset);
+    		ret.setStatement();
+            return ret;
+        }
 
 	private Statement convert(Java8Parser.PreDecrementExpressionContext stmt) {
-		return new UnaryExpr(UnaryExpr.Operation.PREDECREMENT, convert(stmt.unaryExpression()),
+		Statement ret =  new UnaryExpr(UnaryExpr.Operation.PREDECREMENT, convert(stmt.unaryExpression()),
                 TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
+		ret.setStatement();
+        return ret;
     }
 
     private Statement convert(Java8Parser.PostIncrementExpressionContext stmt) {
-        return new UnaryExpr(UnaryExpr.Operation.POSTINCREMENT, convert(stmt.postfixExpression()),
+    	Statement ret =  new UnaryExpr(UnaryExpr.Operation.POSTINCREMENT, convert(stmt.postfixExpression()),
                 TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
+    	ret.setStatement();
+        return ret;
     }
 
     private Statement convert(Java8Parser.PostDecrementExpressionContext stmt) {
-    		return new UnaryExpr(UnaryExpr.Operation.POSTDECREMENT, convert(stmt.postfixExpression()),
+    	Statement ret =  new UnaryExpr(UnaryExpr.Operation.POSTDECREMENT, convert(stmt.postfixExpression()),
                 TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
+    	ret.setStatement();
+        return ret;
     }
 
     private Statement convert(Java8Parser.AssignmentContext stmt) {
         AssignLeftSide leftHandSide = convert(stmt.leftHandSide());
-        return new Assign(leftHandSide, convert(stmt.expression()), stmt.getStart());
+        Statement ret = new Assign(leftHandSide, convert(stmt.expression()), stmt.getStart());
+        ret.setStatement();
+        return ret;
     }
 
     private AssignLeftSide convert(Java8Parser.LeftHandSideContext leftHandSide) {

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

@@ -185,6 +185,7 @@ public class TypeGenerator {
             }else{
             Pattern p = Pattern.compile("Fun(\\d+)[$][$]");
             Matcher m = p.matcher(name);
+            //ToDo Etienne: Für Type Erasure wichtig?!
             if (m.matches()) {//es ist FunN$$-Type 
                 return new RefType(new JavaClassName(name), convert(typeArguments, reg, generics), offset);
             } else {

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

@@ -36,7 +36,7 @@ public class ASTFactory {
 		List<Method> methoden = new ArrayList<>();
 		List<de.dhbwstuttgart.syntaxtree.Constructor> konstruktoren = new ArrayList<>();
 		for(java.lang.reflect.Constructor constructor : jreClass.getConstructors()){
-			konstruktoren.add(createConstructor(constructor, jreClass));
+			createConstructor(constructor, jreClass).map(c -> konstruktoren.add(c));
 		}
 		Set<java.lang.reflect.Method> allMethods = new HashSet<>(Arrays.asList(jreClass.getMethods()));
 		Set<java.lang.reflect.Method> allDeclaredMethods = new HashSet<>(Arrays.asList(jreClass.getDeclaredMethods()));
@@ -87,7 +87,7 @@ public class ASTFactory {
 	//	return createClass(classType).getType();
 	//}
 
-	private static de.dhbwstuttgart.syntaxtree.Constructor createConstructor(Constructor constructor, Class inClass) {
+	private static Optional<de.dhbwstuttgart.syntaxtree.Constructor> createConstructor(Constructor constructor, Class inClass) {
 		String name = constructor.getName();
 		RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass);
 		Parameter[] jreParams = constructor.getParameters();
@@ -106,10 +106,10 @@ public class ASTFactory {
 		int modifier = constructor.getModifiers();
 
 		if(inClass.equals(java.lang.Object.class)){
-			return null;
+			return Optional.empty();
 		}
 
-		return new de.dhbwstuttgart.syntaxtree.Constructor(modifier, name,returnType, parameterList, block, gtvDeclarations, offset /*, new ArrayList<>() geloescht PL 2018-11-24 */);
+		return Optional.of(new de.dhbwstuttgart.syntaxtree.Constructor(modifier, name,returnType, parameterList, block, gtvDeclarations, offset /*, new ArrayList<>() geloescht PL 2018-11-24 */));
 	}
 
 	public static Method createMethod(java.lang.reflect.Method jreMethod, java.lang.Class inClass, Boolean isInherited){

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

@@ -4,6 +4,16 @@ public class NameGenerator {
 
     private static String strNextName = "A";
     
+    /**
+     * Setzt den zu Beginn der Typinferenz auf "A" zurueck.
+     * Dies ist bei JUnit-Test noetig                       
+     * <code>TypePlaceholder</code>. <br>Author: Martin Pluemicke
+     * @return void
+     */
+    public static void reset() {
+    	strNextName = "A";
+    }
+    
     /**
      * Berechnet einen neuen, eindeutigen Namen f�r eine neue                          
      * <code>TypePlaceholder</code>. <br>Author: J�rg B�uerle

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

@@ -18,6 +18,7 @@ import de.dhbwstuttgart.syntaxtree.type.WildcardType;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.result.PairNoResult;
 import de.dhbwstuttgart.typeinference.result.PairTPHEqualTPH;
 import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
 import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
@@ -208,6 +209,7 @@ public class UnifyTypeFactory {
     }
 
     public static ResultPair convert(UnifyPair mp, Map<String,TypePlaceholder> tphs) {
+    	if (mp == null) { return null;} //kann bei basePairs passieren
         RefTypeOrTPHOrWildcardOrGeneric tl = UnifyTypeFactory.convert(mp.getLhsType(), tphs);
         RefTypeOrTPHOrWildcardOrGeneric tr = UnifyTypeFactory.convert(mp.getRhsType(), tphs);
         if(tl instanceof TypePlaceholder){
@@ -218,7 +220,7 @@ public class UnifyTypeFactory {
                     //Einfach ignorieren TODO: Das hier muss ausgebessert werden:
                     //return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, ASTFactory.createObjectType());
                 }else{
-                    return new PairTPHsmallerTPH((TypePlaceholder)tl, (TypePlaceholder)tr);
+                    return new PairTPHsmallerTPH((TypePlaceholder)tl, (TypePlaceholder)tr, convert(mp.getBasePair(), tphs));
                 }
             }else if(tr instanceof RefType){
                 return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, (RefType) tr);
@@ -227,7 +229,7 @@ public class UnifyTypeFactory {
             }else if(tr instanceof GenericRefType){
                 return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, (GenericRefType) tr);
             }else throw new NotImplementedException();
-        }else throw new NotImplementedException();
+        }else return new PairNoResult(tl, tr);//throw new NotImplementedException();
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs) {

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

@@ -24,13 +24,9 @@ public class MethodCall extends Statement
     
     public final ArgumentList arglist;
     
-    /*
-     * noetig fuer Bytecodegenerierung
-     */
     public RefTypeOrTPHOrWildcardOrGeneric receiverType;
     public final ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes;
     
-
     public MethodCall(RefTypeOrTPHOrWildcardOrGeneric retType, Receiver receiver, String methodName, ArgumentList argumentList, 
     		          RefTypeOrTPHOrWildcardOrGeneric receiverType, ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes, Token offset){
 		super(retType,offset);
@@ -40,6 +36,7 @@ public class MethodCall extends Statement
         this.receiverType = receiverType;
         this.argTypes = argTypes;
 	}
+    
 
     @Override
     public void accept(StatementVisitor visitor) {

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

@@ -6,11 +6,20 @@ import org.antlr.v4.runtime.Token;
 
 public abstract class Statement extends Expression
 {
-    
+	/* zeigt an, dass eine StatementExpression als Statement benutzt wird
+     */
+    private boolean isStatement = false;
     
     public Statement(RefTypeOrTPHOrWildcardOrGeneric type, Token offset)
     {
         super(type, offset);
     }
 
+    public void setStatement() {
+    	isStatement=true;
+    }
+    
+    public boolean getStatement() {
+    	return isStatement;
+    }
 }

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

@@ -38,5 +38,12 @@ public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
 		// TODO Auto-generated method stub
 		return false;
 	}
+	
+	    
+	 @Override
+	public String toString()
+	{
+		 return "GTV " + this.name;
+	}
 }
 

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

@@ -9,6 +9,7 @@ import org.antlr.v4.runtime.Token;
  * 
  */
 
+//ToDo Etienne: Wieso abstrakte Klasse? -> Dadurch keine Inferenz mit ? möglich!
 public abstract class WildcardType extends RefTypeOrTPHOrWildcardOrGeneric {
 	
 	protected RefTypeOrTPHOrWildcardOrGeneric innerType = null;

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

@@ -63,6 +63,7 @@ public class MethodAssumption extends Assumption{
             //Die Generics werden alle zu TPHs umgewandelt.
             params.add(resolver.resolve(new GenericRefType(gtv.getName(), new NullToken())));
         }
+        //ToDo Etienne: Für Type Erasure wichtig?!
         RefTypeOrTPHOrWildcardOrGeneric receiverType;
         if(receiver instanceof FunNClass){
             receiverType = new RefType(new JavaClassName(receiver.getClassName().toString()+"$$"), params, new NullToken()); // new FunN(params);

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

@@ -9,6 +9,12 @@ import java.util.Set;
 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
+	
+	/* es darf kein Constraint für den Return-Type erstellt werden, sonst gibt 
+     * es Probleme beim Generated Generics  
+     */
+    public boolean isStatement = false;
+	
 	private Constraint<A> extendConstraint = null;
 	
 	public Constraint() {
@@ -41,7 +47,7 @@ public class Constraint<A> extends HashSet<A> {
 	}
 
 	public String toString() {
-		return super.toString() + " isInherited = " + isInherited 
+		return super.toString() + "\nisInherited = " + isInherited + "\nisStatement = " + isStatement
 				//" + extendsContraint: "  + (extendConstraint != null ? extendConstraint.toStringBase() : "null" ) 
 				+ "\n" ;
 	}

src/main/java/de/dhbwstuttgart/typeinference/result/PairNoResult.java

@@ -0,0 +1,32 @@
+package de.dhbwstuttgart.typeinference.result;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
+/**
+ * enthaelt alle Paare, die in einem Ergebnis nicht vorkommen koennen
+ * sie sind noetig fuer origPairs in PairTPHsmallerTPH, da hier auch
+ * Paare vorkommen koennen die keine Result sind (z.B. bei FunN$$)
+ */
+public class PairNoResult extends ResultPair<RefTypeOrTPHOrWildcardOrGeneric, RefTypeOrTPHOrWildcardOrGeneric>{
+    //public final TypePlaceholder left;
+    //public final TypePlaceholder right;
+    
+    /*
+     * urspruengliches Paar aus diesem dieses Resultpair erzeugt wurde
+     * wichtig fuer generated Generics
+     */
+    ResultPair origPair;
+
+    public PairNoResult(RefTypeOrTPHOrWildcardOrGeneric left, RefTypeOrTPHOrWildcardOrGeneric right){
+        super(left, right);
+    }
+
+    /* noch nicht implementiert. */
+    @Override
+    public void accept(ResultPairVisitor visitor) {
+    	throw new NotImplementedException();
+        //visitor.visit(this);
+    }
+}

src/main/java/de/dhbwstuttgart/typeinference/result/PairTPHsmallerTPH.java

@@ -9,6 +9,12 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 public class PairTPHsmallerTPH extends ResultPair{
     public final TypePlaceholder left;
     public final TypePlaceholder right;
+    
+    /*
+     * urspruengliches Paar aus diesem dieses Resultpair erzeugt wurde
+     * wichtig fuer generated Generics
+     */
+    ResultPair origPair;
 
     public PairTPHsmallerTPH(TypePlaceholder left, TypePlaceholder right){
         super(left, right);
@@ -16,6 +22,11 @@ public class PairTPHsmallerTPH extends ResultPair{
         this.right = right;
     }
 
+    public PairTPHsmallerTPH(TypePlaceholder left, TypePlaceholder right, ResultPair origPair){
+    	this(left, right);
+    	this.origPair = origPair;
+    }
+    
     @Override
     public void accept(ResultPairVisitor visitor) {
         visitor.visit(this);

src/main/java/de/dhbwstuttgart/typeinference/result/ResultPairVisitor.java

@@ -4,4 +4,7 @@ public interface ResultPairVisitor {
     void visit(PairTPHsmallerTPH p);
     void visit(PairTPHequalRefTypeOrWildcardType p);
     void visit(PairTPHEqualTPH p);
+    
+    //bisher nicht umgesetzt 
+    //void visit(PairNoResult p);
 }

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

@@ -11,6 +11,7 @@ import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.FunNClass;
 import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
@@ -67,6 +68,7 @@ public class TYPEStmt implements StatementVisitor{
         lambdaParams.add(tphRetType);
         //lambdaParams.add(0,tphRetType);
         constraintsSet.addUndConstraint(
+                //ToDo Etienne: Für Type Erasure wichtig?!
                 new Pair(lambdaExpression.getType(),
                 		new RefType(new JavaClassName("Fun"+(lambdaParams.size()-1)+"$$"), lambdaParams, new NullToken()),
                         //new FunN(lambdaParams),
@@ -180,6 +182,7 @@ public class TYPEStmt implements StatementVisitor{
 					        		   ? new Pair(x.TA1, new ExtendsWildcardType(x.TA2, x.TA2.getOffset()), PairOperator.EQUALSDOT)
 					        		   : x)
             		.collect(Collectors.toCollection(() -> new Constraint<Pair>(oneMethodConstraint.isInherited())));
+            extendsOneMethodConstraint.isStatement = oneMethodConstraint.isStatement;
             oneMethodConstraint.setExtendConstraint(extendsOneMethodConstraint);
             extendsOneMethodConstraint.setExtendConstraint(oneMethodConstraint);
             methodConstraints.add(extendsOneMethodConstraint);
@@ -594,9 +597,11 @@ public class TYPEStmt implements StatementVisitor{
         //methodConstraint.add(new Pair(forMethod.receiverType, retType,
         //        PairOperator.EQUALSDOT));
         //Fuer Bytecodegenerierung PL 2020-03-09 wird derzeit nicht benutzt ENDE
-
+        
+      
+        methodConstraint.isStatement = forMethod.getStatement();
         methodConstraint.add(new Pair(assumption.getReturnType(resolver), forMethod.getType(),
-                PairOperator.EQUALSDOT));
+        			PairOperator.EQUALSDOT));
         methodConstraint.addAll(generateParameterConstraints(forMethod, assumption, info, resolver));
         return methodConstraint;
     }

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

@@ -269,6 +269,9 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			System.err.println("no log-File");
 		}
 		if (isUndefinedPairSetSet(res)) { 
+			//fuer debug-Zwecke
+			ArrayList al = res.stream().map(x -> x.stream().collect(Collectors.toCollection(ArrayList::new)))
+					          .collect(Collectors.toCollection(ArrayList::new));
 				throw new TypeinferenceException("Unresolved constraints: " + res.toString(), new NullToken()); //return new HashSet<>(); 
 			}
 		else {
@@ -2181,6 +2184,12 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			
 		Set<Set<UnifyPair>> result = new HashSet<>();
 		
+		if (thetaPrime instanceof ReferenceType && ((ReferenceType)thetaPrime).isGenTypeVar()) {
+			Set<UnifyPair> resultOne = new HashSet<>();
+			resultOne.add(new UnifyPair (a, thetaPrime, PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
+			result.add(resultOne);
+		}     
+		
 		boolean allGen = thetaPrime.getTypeParams().size() > 0;
 		for(UnifyType t : thetaPrime.getTypeParams())
 			if(!(t instanceof PlaceholderType) || !((PlaceholderType) t).isGenerated()) {

src/main/java/de/dhbwstuttgart/typeinference/unify/model/FunNType.java

@@ -21,6 +21,7 @@ public class FunNType extends UnifyType {
 	/**
 	 * Creates a FunN-Type with the specified TypeParameters.
 	 */
+	//ToDo Etienne: Für Type Erasure wichtig?!
 	protected FunNType(TypeParams p) {
 		super("Fun"+(p.size()-1)+"$$", p);
 	}

src/test/java/bytecode/OLFunTest.java

@@ -1,52 +1,65 @@
 package bytecode;
 
-import static org.junit.Assert.assertEquals;
-
 import java.io.File;
-import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
 
-import org.junit.Test;
-
+import general.TestCleanUp;
+import org.junit.*;
 import de.dhbwstuttgart.core.JavaTXCompiler;
+import static org.junit.Assert.*;
 
+/**
+ * Test which only checks if the class {@code OLFun} was correctly compiled.
+ * This is achived by verifying the existence of the three implementations of {@code m}.
+ *
+ * @since Studienarbeit Type Erasure
+ * @author Etienne Zink
+ */
 public class OLFunTest {
 	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 Class<?> classFun1;
 	private static Object instanceOfClass;
+
+	private static String generatedByteCodeDirectory = System.getProperty("user.dir") + "/src/test/resources/testBytecode/generatedBC/";
 	
-	@Test
-	public void generateBC() throws Exception {
+	@BeforeClass
+	public static void setUp() throws Exception {
 		path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/OLFun.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)});
+		compiler.generateBytecode(generatedByteCodeDirectory);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+generatedByteCodeDirectory)});
 		classToTest = loader.loadClass("OLFun");
-		/*
+		classFun1 = loader.loadClass("Fun1$$");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
-
-		Method m = classToTest.getDeclaredMethod("m");
-		Class<?> lambda = m.invoke(instanceOfClass).getClass();
-		Method apply = lambda.getMethod("apply", Object.class);
-
-		// Damit man auf die Methode zugreifen kann
-		apply.setAccessible(true);
-
-		Integer i = 77;
-		
-		Integer result = (Integer) apply.invoke(m.invoke(instanceOfClass), i); 
-
-		assertEquals(77, result);
-		*/
 	}
 
+	@Test
+	public void mExistsWithInteger() throws Exception{
+		Method m = classToTest.getDeclaredMethod("m", classFun1 ,Integer.class);
+		assertNotNull(m);
+	}
 
+	@Test
+	public void mExistsWithString() throws Exception{
+		Method m = classToTest.getDeclaredMethod("m", classFun1 ,String.class);
+		assertNotNull(m);
+	}
+
+	@Test
+	public void mExistsWithDouble() throws Exception{
+		Method m = classToTest.getDeclaredMethod("m", classFun1 ,Double.class);
+		assertNotNull(m);
+	}
+
+	@AfterClass
+	public static void cleanUp(){
+		TestCleanUp.cleanUpDirectory(new File(generatedByteCodeDirectory), f -> f.getName().contains(".class"));
+	}
 }

src/test/java/general/TestCleanUp.java

@@ -0,0 +1,14 @@
+package general;
+
+import java.io.File;
+import java.io.FileFilter;
+
+public class TestCleanUp {
+
+    public static void cleanUpDirectory(File directory, FileFilter fileFilter){
+        if(!directory.isDirectory()) throw new RuntimeException("Directory for bytecode generation is wrong!");
+        for (File file: directory.listFiles(fileFilter)) {
+            file.delete();
+        }
+    }
+}

src/test/java/insertGenerics/TestAny.java

@@ -12,6 +12,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -32,6 +34,11 @@ public class TestAny {
 
     public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
 
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
     @Test
     public void ggFinder() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"TestAny.jav"));
@@ -54,12 +61,12 @@ public class TestAny {
         classConstraintsTest.add(new ClassConstraint("N", "U", Relation.EXTENDS));
         classConstraintsTest.add(new ClassConstraint("U", "O", Relation.EXTENDS));
         classConstraintsTest.add(new ClassConstraint("O", "java/lang/Object", Relation.EXTENDS));
-        HashMap<String, List<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
-        List<MethodConstraint> lmc;
-        lmc = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("R", "java/lang/Object", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH RanyMethod()",  lmc);
-        lmc = new ArrayList<>();
+        lmc = new HashSet<>();
         methodConstraintsWithPositionTest.put("TPH UotherMethod(TPH U)",  lmc);
         
         FamilyOfGeneratedGenerics fogg = compiler.fogg;
@@ -67,8 +74,11 @@ public class TestAny {
         Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
         
         assertEquals(expectedClassCons, computedClassCons);
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
         
-        assertEquals(methodConstraintsWithPositionTest, fogg.methodConstraintsWithPosition);
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
         
         //compiler.generateBytecode(rootDirectory+"xxx.class", results, simplifyResultsForAllSourceFiles);
         for(File f : compiler.sourceFiles.keySet()){

src/test/java/insertGenerics/TestClassField.java

@@ -8,6 +8,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.io.File;
@@ -24,6 +26,11 @@ public class TestClassField {
 
     public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
 
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
     @Test
     public void ggFinder() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"TestClassField.jav"));

src/test/java/insertGenerics/TestContraVariant.java

@@ -0,0 +1,112 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestContraVariant {
+
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"TestContraVariant.jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+        }
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("R", "O", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("O", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Rm(TPH O)",  lmc);
+        lmc = new HashSet<>();
+        //lmc.add(new MethodConstraint("S", "O", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("S", "java/lang/Object", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("R", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Rmain(TPH S)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);
+        
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        
+        //compiler.generateBytecode(rootDirectory+"xxx.class", results, simplifyResultsForAllSourceFiles);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+            System.out.println(ASTTypePrinter.print(sf));
+            System.out.println(ASTPrinter.print(sf));
+            //List<ResultSet> results = compiler.typeInference(); PL 2017-10-03 vor die For-Schleife gezogen
+            assert results.size()>0;
+            Set<String> insertedTypes = new HashSet<>();
+            for(ResultSet resultSet : results){
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
+                assert result.size()>0;
+                String content = readFile(f.getPath(), StandardCharsets.UTF_8);
+                for(TypeInsert tip : result){
+                    insertedTypes.add(tip.insert(content));
+                }
+            }
+            for(String s : insertedTypes){
+                System.out.println(s);
+            }
+        }
+        return new TestResultSet();
+    }
+
+    static String readFile(String path, Charset encoding)
+            throws IOException
+    {
+        byte[] encoded = Files.readAllBytes(Paths.get(path));
+        return new String(encoded, encoding);
+    }
+}

src/test/java/insertGenerics/TestGGFinder.java

@@ -12,6 +12,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -39,7 +41,12 @@ public class TestGGFinder {
     private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	private static String className = "TestGGFinder";
-	
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
     @Test
     public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
         execute(new File(rootDirectory+className+".jav"));
@@ -56,16 +63,16 @@ public class TestGGFinder {
         
         List<ClassConstraint> classConstraintsTest = new ArrayList<>();
         classConstraintsTest.add(new ClassConstraint("S", "java/lang/Object", Relation.EXTENDS));
-        HashMap<String, List<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
-        List<MethodConstraint> lmc;
-        lmc = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("P", "AC", Relation.EXTENDS));
         lmc.add(new MethodConstraint("AC", "java/lang/Object", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH ACid(TPH P)",  lmc);
-        lmc = new ArrayList<>();
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("T", "S", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH SsetA(TPH T)",  lmc);
-        lmc = new ArrayList<>();
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("AC", "Y", Relation.EXTENDS));
         lmc.add(new MethodConstraint("Z", "P", Relation.EXTENDS));
         lmc.add(new MethodConstraint("P", "AC", Relation.EXTENDS));
@@ -78,7 +85,10 @@ public class TestGGFinder {
         
         assertEquals(expectedClassCons, computedClassCons);
         
-        assertEquals(methodConstraintsWithPositionTest, fogg.methodConstraintsWithPosition);
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
         
         compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
         loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});

src/test/java/insertGenerics/TestLocalVarLambda.java

@@ -12,6 +12,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -39,7 +41,12 @@ public class TestLocalVarLambda {
     private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	private static String className = "TestLocalVarLambda";
-	
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
 	@Test
     public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
         execute(new File(rootDirectory+className+".jav"));
@@ -55,31 +62,46 @@ public class TestLocalVarLambda {
         List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
         
         List<ClassConstraint> classConstraintsTest = new ArrayList<>();
-        HashMap<String, List<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
         
         FamilyOfGeneratedGenerics fogg = compiler.fogg;
         
-        List<MethodConstraint> lmc;
-        lmc = new ArrayList<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
         
         if (fogg.allConstraints.contains((new MethodConstraint("O", "ALU", Relation.EXTENDS)))) {
         	lmc.add(new MethodConstraint("O", "ALU", Relation.EXTENDS));
         	lmc.add(new MethodConstraint("DIU", "java/lang/Object", Relation.EXTENDS));
         	lmc.add(new MethodConstraint("ALU", "DIU", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("SY", "java/lang/Object", Relation.EXTENDS));
+        	methodConstraintsWithPositionTest.put("TPH DIUm(TPH O)",  lmc);
         }
-        else {
+        else if (fogg.allConstraints.contains((new MethodConstraint("O", "DIV", Relation.EXTENDS)))) {
+        	lmc.add(new MethodConstraint("O", "DIV", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("N", "java/lang/Object", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("DIV", "N", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("SY", "java/lang/Object", Relation.EXTENDS));
+        	methodConstraintsWithPositionTest.put("TPH Nm(TPH O)",  lmc);
+        }
+        else
+        {
         	lmc.add(new MethodConstraint("O", "DIU", Relation.EXTENDS));
         	lmc.add(new MethodConstraint("N", "java/lang/Object", Relation.EXTENDS));
         	lmc.add(new MethodConstraint("DIU", "N", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("SY", "java/lang/Object", Relation.EXTENDS));
+        	methodConstraintsWithPositionTest.put("TPH Nm(TPH O)",  lmc);
         }
-        methodConstraintsWithPositionTest.put("TPH DIUm(TPH O)",  lmc);
+        
         
         Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
         Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
         
         assertEquals(expectedClassCons, computedClassCons);
         
-        assertEquals(methodConstraintsWithPositionTest, fogg.methodConstraintsWithPosition);
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
         
         compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
         loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});

src/test/java/insertGenerics/TestMutualRecursion.java

@@ -12,6 +12,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -39,7 +41,12 @@ public class TestMutualRecursion {
     private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	private static String className;
-	
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
 	@Test
     public void TestMutualRecursion1() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
         className = "TestMutualRecursion"; 
@@ -49,18 +56,19 @@ public class TestMutualRecursion {
 
 		
 		List<ClassConstraint> classConstraintsTest = new ArrayList<>();
-		HashMap<String, List<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
-		List<MethodConstraint> lmc;
-		lmc = new ArrayList<>();
+		classConstraintsTest.add(new ClassConstraint("N", "java/lang/Object", Relation.EXTENDS));
+		HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+		Set<MethodConstraint> lmc;
+		lmc = new HashSet<>();
 		lmc.add(new MethodConstraint("P", "Q", Relation.EXTENDS));
 		lmc.add(new MethodConstraint("Q", "java/lang/Object", Relation.EXTENDS));
 		lmc.add(new MethodConstraint("AL", "java/lang/Object", Relation.EXTENDS));
 		methodConstraintsWithPositionTest.put("TPH ALid(TPH P)",  lmc);
-		lmc = new ArrayList<>();
+		lmc = new HashSet<>();
 		lmc.add(new MethodConstraint("AL", "java/lang/Object", Relation.EXTENDS));
 		lmc.add(new MethodConstraint("Z", "java/lang/Object", Relation.EXTENDS));
 		methodConstraintsWithPositionTest.put("TPH ALm(TPH ALTPH Z)",  lmc);
-		lmc = new ArrayList<>();
+		lmc = new HashSet<>();
 		lmc.add(new MethodConstraint("AG", "java/lang/Object", Relation.EXTENDS));
 		lmc.add(new MethodConstraint("AH", "java/lang/Object", Relation.EXTENDS));
 		lmc.add(new MethodConstraint("AL", "java/lang/Object", Relation.EXTENDS));
@@ -71,8 +79,11 @@ public class TestMutualRecursion {
         Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
         
         assertEquals(expectedClassCons, computedClassCons);
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
         
-        assertEquals(methodConstraintsWithPositionTest, fogg.methodConstraintsWithPosition);
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
 		
 		compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
         loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});

src/test/java/insertGenerics/TestReturnVar.java

@@ -8,6 +8,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.io.File;
@@ -24,6 +26,11 @@ public class TestReturnVar {
 
     public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
 
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
     @Test
     public void ggFinder() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"TestReturnVar.jav"));

src/test/java/insertGenerics/TestSecondLineOfClassConstraints.java

@@ -8,6 +8,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.io.File;
@@ -24,6 +26,11 @@ public class TestSecondLineOfClassConstraints {
 
     public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
 
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
     @Test
     public void ggFinder() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"TestSecondLineOfClassConstraints.jav"));

src/test/java/insertGenerics/TestTPHsAndGenerics.java

@@ -12,7 +12,9 @@ import de.dhbwstuttgart.core.JavaTXCompiler;
 	import de.dhbwstuttgart.typedeployment.TypeInsert;
 	import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 	import de.dhbwstuttgart.typeinference.result.ResultSet;
-	import org.junit.Test;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
 
@@ -40,7 +42,12 @@ public class TestTPHsAndGenerics {
 	    private static Class<?> classToTest;
 		private static Object instanceOfClass;
 		private static String className = "TestTPHsAndGenerics";
-		
+
+	    @BeforeClass
+	    public static void resetNamesOfTypePlaceholder() {
+	    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+	    }
+	    
 	    @Test
 	    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
 	        execute(new File(rootDirectory+className+".jav"));
@@ -56,12 +63,12 @@ public class TestTPHsAndGenerics {
 	        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
 	        
 	        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
-	        HashMap<String, List<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+	        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
 	        
 	        FamilyOfGeneratedGenerics fogg = compiler.fogg;
 	        
-	        List<MethodConstraint> lmc;
-	        lmc = new ArrayList<>();
+	        Set<MethodConstraint> lmc;
+	        lmc = new HashSet<>();
 	        
 	        if (fogg.allConstraints.contains((new MethodConstraint("DZP", "ETW", Relation.EXTENDS)))) {
 	        	classConstraintsTest.add(new ClassConstraint("UD", "DZP", Relation.EXTENDS));
@@ -70,42 +77,70 @@ public class TestTPHsAndGenerics {
 	        
 	        	lmc.add(new MethodConstraint("AI", "AE", Relation.EXTENDS));
 	        	lmc.add(new MethodConstraint("AD", "AI", Relation.EXTENDS));
-	        	lmc.add(new MethodConstraint("AB", "AM", Relation.EXTENDS));
+	        	//lmc.add(new MethodConstraint("AB", "AM", Relation.EXTENDS));
 	        	lmc.add(new MethodConstraint("AE", "java/lang/Object", Relation.EXTENDS));
-	        	lmc.add(new MethodConstraint("AM", "java/lang/Object", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AB", "java/lang/Object", Relation.EXTENDS));
 	        	methodConstraintsWithPositionTest.put("TPH ABm(TPH ABTPH AD)",  lmc);
-	        	lmc = new ArrayList<>();
+	        	lmc = new HashSet<>();
 	        	lmc.add(new MethodConstraint("V", "UD", Relation.EXTENDS));
 	        	methodConstraintsWithPositionTest.put("TPH ETWid2(TPH V)",  lmc);
-	        	lmc = new ArrayList<>();
+	        	lmc = new HashSet<>();
 	        	lmc.add(new MethodConstraint("AM", "java/lang/Object", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AI", "java/lang/Object", Relation.EXTENDS));
 	        	methodConstraintsWithPositionTest.put("TPH AIm2(TPH AMTPH AI)",  lmc);
-	        }
-	        else {
+	        } else {
+	        if (fogg.allConstraints.contains((new MethodConstraint("DZP", "U", Relation.EXTENDS)))) {
 	        	classConstraintsTest.add(new ClassConstraint("ETW", "DZP", Relation.EXTENDS));
 	        	classConstraintsTest.add(new ClassConstraint("DZP", "U", Relation.EXTENDS));
-	        	classConstraintsTest.add(new ClassConstraint("ETW", "java/lang/Object", Relation.EXTENDS));
+	        	classConstraintsTest.add(new ClassConstraint("U", "java/lang/Object", Relation.EXTENDS));
 	        
 	        	lmc.add(new MethodConstraint("AI", "AE", Relation.EXTENDS));
 	        	lmc.add(new MethodConstraint("AD", "AI", Relation.EXTENDS));
-	        	lmc.add(new MethodConstraint("AB", "AM", Relation.EXTENDS));
+	        	//lmc.add(new MethodConstraint("AB", "AM", Relation.EXTENDS));
 	        	lmc.add(new MethodConstraint("AE", "java/lang/Object", Relation.EXTENDS));
-	        	lmc.add(new MethodConstraint("AM", "java/lang/Object", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AB", "java/lang/Object", Relation.EXTENDS));
 	        	methodConstraintsWithPositionTest.put("TPH ABm(TPH ABTPH AD)",  lmc);
-	        	lmc = new ArrayList<>();
+	        	lmc = new HashSet<>();
 	        	lmc.add(new MethodConstraint("V", "ETW", Relation.EXTENDS));
-	        	methodConstraintsWithPositionTest.put("TPH ETWid2(TPH V)",  lmc);
-	        	lmc = new ArrayList<>();
+	        	methodConstraintsWithPositionTest.put("TPH Uid2(TPH V)",  lmc);
+	        	lmc = new HashSet<>();
 	        	lmc.add(new MethodConstraint("AM", "java/lang/Object", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AI", "java/lang/Object", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH AIm2(TPH AMTPH AI)",  lmc);
+	        } else {
+	        if (fogg.allConstraints.contains((new MethodConstraint("EIM", "FEA", Relation.EXTENDS)))) {
+	        	classConstraintsTest.add(new ClassConstraint("VK", "EIM", Relation.EXTENDS));
+	        	classConstraintsTest.add(new ClassConstraint("EIM", "FEA", Relation.EXTENDS));
+	        	classConstraintsTest.add(new ClassConstraint("FEA", "java/lang/Object", Relation.EXTENDS));
+	        
+	        	lmc.add(new MethodConstraint("AI", "AE", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AD", "AI", Relation.EXTENDS));
+	        	//lmc.add(new MethodConstraint("AB", "AM", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AE", "java/lang/Object", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AB", "java/lang/Object", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH ABm(TPH ABTPH AD)",  lmc);
+	        	lmc = new HashSet<>();
+	        	lmc.add(new MethodConstraint("V", "VK", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH FEAid2(TPH V)",  lmc);
+	        	lmc = new HashSet<>();
+	        	lmc.add(new MethodConstraint("AM", "java/lang/Object", Relation.EXTENDS));
+				lmc.add(new MethodConstraint("AI", "java/lang/Object", Relation.EXTENDS));
 	        	methodConstraintsWithPositionTest.put("TPH AIm2(TPH AMTPH AI)",  lmc);
 	        }
+	        }
+	        	
+	        }
+
 	        
 	        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
 	        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
 	        
 	        assertEquals(expectedClassCons, computedClassCons);
 	        
-	        assertEquals(methodConstraintsWithPositionTest, fogg.methodConstraintsWithPosition);
+	        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+	        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+	        
+	        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
 	        
 	        /*
 	        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);

src/test/java/insertGenerics/TestTPHsAndGenerics2.java

@@ -8,6 +8,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.io.File;
@@ -24,6 +26,11 @@ public class TestTPHsAndGenerics2 {
 
     public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
 
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
     @Test
     public void ggFinder() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"TestTPHSAndGenerics2.jav"));

src/test/java/insertGenerics/TestThreeArgs.java

@@ -0,0 +1,99 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestThreeArgs {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className = "TestThreeArgs";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+	@Test
+    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        execute(new File(rootDirectory+className+".jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        classConstraintsTest.add(new ClassConstraint("N", "java/lang/Object", Relation.EXTENDS));
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("P", "AF", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("Q", "java/lang/Object", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AF", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH AFid(TPH P)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("AF", "W", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AB", "P", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("P", "AF", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AC", "java/lang/Object", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("W", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Wm(TPH WTPH ABTPH AC)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);
+        
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+        //liefert Fehler, da Variable "a" nicht initialisiert ist.
+		//instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestTransitiveClosure.java

@@ -21,8 +21,8 @@ public class TestTransitiveClosure {
 
     @Test
     public void genericTest() {
-        List<TPHConstraint> testCons = FamilyOfGeneratedGenerics.buildTransitiveClosure(fillList());
-        System.out.println(testCons);
+        //List<TPHConstraint> testCons = FamilyOfGeneratedGenerics.buildTransitiveClosure(fillList());
+        //System.out.println(testCons);
 
     }
 }

src/test/java/insertGenerics/TestTwoArgs.java

@@ -15,6 +15,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.io.File;
@@ -40,7 +42,12 @@ public class TestTwoArgs {
     private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	private static String className = "TestTwoArgs";
-	
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
 	@Test
     public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
         execute(new File(rootDirectory+className+".jav"));
@@ -61,32 +68,39 @@ public class TestTwoArgs {
         classConstraintsTest.add(new ClassConstraint("P", "AL", Relation.EXTENDS));
         classConstraintsTest.add(new ClassConstraint("AL", "AF", Relation.EXTENDS));
         classConstraintsTest.add(new ClassConstraint("AF", "java/lang/Object", Relation.EXTENDS));
-        HashMap<String, List<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
-        List<MethodConstraint> lmc;
-        lmc = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("P", "AL", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AL", "java/lang/Object", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH ALid(TPH P)",  lmc);
-        lmc = new ArrayList<>();
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("AL", "AF", Relation.EXTENDS));
         lmc.add(new MethodConstraint("Z", "P", Relation.EXTENDS));
         lmc.add(new MethodConstraint("P", "AL", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AF", "java/lang/Object", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH AFm(TPH AFTPH Z)",  lmc);
-        lmc = new ArrayList<>();
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("T", "AP", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH APsetA(TPH T)",  lmc);
-        lmc = new ArrayList<>();
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("AG", "P", Relation.EXTENDS));
         lmc.add(new MethodConstraint("AH", "T", Relation.EXTENDS));
         lmc.add(new MethodConstraint("T", "AP", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AL", "AF", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("P", "AL", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH AFmain(TPH AGTPH AH)",  lmc);
         
         FamilyOfGeneratedGenerics fogg = compiler.fogg;
         Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
         Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
         
-        assertEquals(expectedClassCons, computedClassCons);
+        assertEquals(expectedClassCons, computedClassCons);       
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
         
-        assertEquals(methodConstraintsWithPositionTest, fogg.methodConstraintsWithPosition);
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
         
         compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
         loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});

src/test/java/insertGenerics/TestTwoArgs2.java

@@ -12,6 +12,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -39,7 +41,12 @@ public class TestTwoArgs2 {
     private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	private static String className = "TestTwoArgs2";
-	
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
 	@Test
     public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
         execute(new File(rootDirectory+className+".jav"));
@@ -56,15 +63,15 @@ public class TestTwoArgs2 {
         
         List<ClassConstraint> classConstraintsTest = new ArrayList<>();
         classConstraintsTest.add(new ClassConstraint("N", "java/lang/Object", Relation.EXTENDS));
-        HashMap<String, List<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
-        List<MethodConstraint> lmc;
-        lmc = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("AG", "AA", Relation.EXTENDS));
         lmc.add(new MethodConstraint("U", "P", Relation.EXTENDS));
         lmc.add(new MethodConstraint("P", "AG", Relation.EXTENDS));
         lmc.add(new MethodConstraint("AA", "java/lang/Object", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH AAm(TPH AATPH U)",  lmc);
-        lmc = new ArrayList<>();
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("AB", "P", Relation.EXTENDS));
         lmc.add(new MethodConstraint("AC", "U", Relation.EXTENDS));
         lmc.add(new MethodConstraint("AB", "AA", Relation.EXTENDS));
@@ -73,7 +80,7 @@ public class TestTwoArgs2 {
         lmc.add(new MethodConstraint("U", "AA", Relation.EXTENDS));
         lmc.add(new MethodConstraint("P", "AG", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH AAmain(TPH ABTPH AC)",  lmc);
-        lmc = new ArrayList<>();
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("P", "AG", Relation.EXTENDS));
         lmc.add(new MethodConstraint("AG", "java/lang/Object", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH AGid(TPH P)",  lmc);
@@ -84,7 +91,10 @@ public class TestTwoArgs2 {
         
         assertEquals(expectedClassCons, computedClassCons);
         
-        assertEquals(methodConstraintsWithPositionTest, fogg.methodConstraintsWithPosition);
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
         
         compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
         loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});

src/test/java/insertGenerics/TestTwoCalls.java

@@ -12,6 +12,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -39,7 +41,12 @@ public class TestTwoCalls {
     private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	private static String className = "TestTwoCalls";
-	
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
 	@Test
     public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
         execute(new File(rootDirectory+className+".jav"));
@@ -55,16 +62,17 @@ public class TestTwoCalls {
         List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
         
         List<ClassConstraint> classConstraintsTest = new ArrayList<>();
-        HashMap<String, List<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
-        List<MethodConstraint> lmc;
-        lmc = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("O", "R", Relation.EXTENDS));
         lmc.add(new MethodConstraint("R", "java/lang/Object", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH Rid(TPH O)",  lmc);
-        lmc = new ArrayList<>();
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("T", "O", Relation.EXTENDS));
         lmc.add(new MethodConstraint("O", "R", Relation.EXTENDS));
         lmc.add(new MethodConstraint("R", "java/lang/Object", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("S", "java/lang/Object", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH Rmain(TPH STPH T)",  lmc);
         
         FamilyOfGeneratedGenerics fogg = compiler.fogg;
@@ -72,8 +80,12 @@ public class TestTwoCalls {
         Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
         
         assertEquals(expectedClassCons, computedClassCons);
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
         
-        assertEquals(methodConstraintsWithPositionTest, fogg.methodConstraintsWithPosition);
         compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
         loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
         classToTest = loader.loadClass(className);

src/test/java/insertGenerics/TestVector.java

@@ -12,6 +12,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -39,7 +41,12 @@ public class TestVector {
     private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	private static String className = "TestVector";
-	
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
     @Test
     public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
         execute(new File(rootDirectory+className+".jav"));
@@ -55,14 +62,14 @@ public class TestVector {
         List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
         
         List<ClassConstraint> classConstraintsTest = new ArrayList<>();
-        HashMap<String, List<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
-        List<MethodConstraint> lmc;
-        lmc = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("T", "W", Relation.EXTENDS));
         lmc.add(new MethodConstraint("W", "ZU", Relation.EXTENDS));
         lmc.add(new MethodConstraint("ZU", "java/lang/Object", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("voidm(java/util/Vectorjava/util/Vector)",  lmc);
-        lmc = new ArrayList<>();
+        lmc = new HashSet<>();
         lmc.add(new MethodConstraint("W", "java/lang/Object", Relation.EXTENDS));
         methodConstraintsWithPositionTest.put("TPH Wid(TPH W)",  lmc);
         
@@ -70,9 +77,12 @@ public class TestVector {
         Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
         Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
         
-        assertEquals(expectedClassCons, computedClassCons);
+        assertEquals(expectedClassCons, computedClassCons);     
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
         
-        assertEquals(methodConstraintsWithPositionTest, fogg.methodConstraintsWithPosition);
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
         compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
         loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
         classToTest = loader.loadClass(className);

src/test/java/insertGenerics/TestVectorArg.java

@@ -0,0 +1,92 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestVectorArg {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className = "TestVectorArg";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        execute(new File(rootDirectory+className+".jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("T", "W", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("W", "ZU", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("ZU", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("voidm(java/util/Vectorjava/util/Vector)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("W", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Wid(TPH W)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        //assertEquals(expectedClassCons, computedClassCons);     
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        //assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestVoidMeth.java

@@ -8,6 +8,8 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.io.File;
@@ -24,6 +26,11 @@ public class TestVoidMeth {
 
     public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
 
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
     @Test
     public void ggFinder() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"TestVoidMeth.jav"));

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

@@ -3,7 +3,7 @@ import java.lang.Integer;
 
 public class Fac  {
 	
-	getFac(java.lang.Integer n){
+	getFac(n){
 		var res = 1;
 		var i = 1;
 		while(i<=n) {

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

@@ -10,7 +10,6 @@ import java.lang.Boolean;
 public class OLFun    {
 
 	//f = x -> {return x + x;};
-	
 	m(f, x) {
 		x = f.apply(x+x);
 	}

src/test/resources/insertGenericsJav/TestContraVariant.jav

@@ -0,0 +1,12 @@
+public class TestContraVariant {
+
+    m(x) {
+        var y;
+        x = y;
+        return y;
+    }
+    
+    main(x) {
+    	return m(x);
+    }
+}

src/test/resources/insertGenericsJav/TestMutualRecursionWithField2.jav

@@ -0,0 +1,22 @@
+public class TestMutualRecursionWithField2 {
+    a;
+
+    id(b) {
+        var c = b;
+        return main(b,c);
+    }
+
+    setA(x) {
+        a = x;
+        return a;
+    }
+
+    m(x,y) {
+        x = id(y);
+        return x;
+    }
+    
+    main(x,y) {
+    	return m(setA(x),id(y));
+    }
+}

src/test/resources/insertGenericsJav/TestMutualRecursionWithField3.jav

@@ -0,0 +1,23 @@
+public class TestMutualRecursionWithField3 {
+    a;
+
+    id(b) {
+        var c = b;
+        return main(b,c);
+    }
+
+    setA(x) {
+        a = x;
+        return a;
+    }
+
+    m(x,y) {
+        x = id(y);
+        return x;
+    }
+    
+    main(x,y) {
+    	var z = m(setA(x),id(y));
+    	return z;
+    }
+}

src/test/resources/insertGenericsJav/TestVectorArg.jav

@@ -0,0 +1,12 @@
+import java.util.Vector;
+
+public class TestVectorArg {
+
+    add(v, e) {
+		v.addElement(e);
+    }
+
+    main(v, e) {
+		add(v, e);
+    }
+}

src/test/resources/javFiles/packageTest/Pair2.jav

@@ -0,0 +1,14 @@
+import de.test.Pair;
+
+class Pairs {
+    setfst(fst) {
+	  return new Pair<>(snd, fst);
+      }
+
+    swap () {
+	return new Pair<> (snd, fst); }
+
+    polyrec(p) {
+	return polyrec (p.swap());
+    }
+}

src/test/resources/javFiles/packageTest/de/test/Pair.jav

@@ -0,0 +1,12 @@
+package de.test;
+
+class Pair {
+    fst;
+    snd;
+
+    Pair(fst, snd) {
+      this.fst = fst;
+	  this.snd = snd; 
+	}
+}
+