modified: ../../../main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java

Bildung von newOderConstraints wieder rueckgaengig gemacht

	modified:   ../../resources/bytecode/javFiles/MatrixOP.jav

pom.xml

@@ -7,7 +7,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 	<artifactId>JavaTXcompiler</artifactId>
 	<packaging>jar</packaging>
 
-	<version>0.2</version>
+	<version>0.1</version>
 	<name>JavaTXcompiler</name>
 	<url>http://maven.apache.org</url>
 	<dependencies>
@@ -55,14 +55,6 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 		<finalName>${project.artifactId}-${project.version}</finalName>
 		<testOutputDirectory>target/test-classes</testOutputDirectory>
 		<plugins>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.0.0-M3</version>
-				<configuration>
-					<skipTests>true</skipTests>
-				</configuration>
-			</plugin>
 			<plugin>
 				<groupId>org.antlr</groupId>
 				<artifactId>antlr4-maven-plugin</artifactId>
@@ -127,7 +119,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 								<!-- specify your depencies here -->
 								<!-- groupId:artifactId:version -->
 								<artifact>
-									<id>de.dhbwstuttgart:JavaTXcompiler:0.2</id>
+									<id>de.dhbwstuttgart:JavaTXcompiler:0.1</id>
 								</artifact>
 								<artifact>
 									<id>org.reflections:reflections:0.9.11</id>
@@ -146,6 +138,10 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 					</execution>
 				</executions>
 			</plugin>
+			<!-- plugin> <groupId>org.eclipse.tycho</groupId> <artifactId>tycho-p2-repository-plugin</artifactId> 
+				<version>${tycho.version}</version> <executions> <execution> <phase>package</phase> 
+				<goals> <goal>archive-repository</goal> </goals> </execution> </executions> 
+				</plugin -->
 		</plugins>
 	</build>
 	<pluginRepositories>
@@ -173,3 +169,5 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 		</repository>
 	</distributionManagement>
 </project>
+
+

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

@@ -17,7 +17,6 @@ import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 
-import de.dhbwstuttgart.bytecode.Exception.BytecodeGeneratorError;
 import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
@@ -30,7 +29,6 @@ import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
 import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
 import de.dhbwstuttgart.bytecode.utilities.Simplify;
-import de.dhbwstuttgart.bytecode.utilities.SimplifyResult;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.Literal;
@@ -46,11 +44,11 @@ import de.dhbwstuttgart.typeinference.result.ResultPair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
 public class BytecodeGen implements ASTVisitor {
-
-	ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
-
+	
+	ClassWriter cw =new ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS);
+	
 	String type;
-
+	
 	public static RefTypeOrTPHOrWildcardOrGeneric THISTYPE = null;
 	String className;
 	private boolean isInterface;
@@ -58,222 +56,185 @@ public class BytecodeGen implements ASTVisitor {
 	private ResultSet resultSet;
 	private SourceFile sf;
 	private String path;
-
+	
 	private Optional<Constructor> fieldInitializations;
-
+	
 	private int indexOfFirstParam = 0;
-
+	
 	private String superClass;
-
-	private ArrayList<String> tphsClass;
-
-	// stores parameter, local vars and the next index on the local variable table,
-	// which use for aload_i, astore_i,...
+	
+	private ArrayList<TypePlaceholder> tphsClass;
+	
+	// stores parameter, local vars and the next index on the local variable table, which use for aload_i, astore_i,...
 	HashMap<String, Integer> paramsAndLocals = new HashMap<>();
 	// stores generics and their bounds of class
 	HashMap<String, String> genericsAndBounds = new HashMap<>();
-
+	
 	private int constructorPos = 0;
-
+	
 	private final TPHExtractor tphExtractor = new TPHExtractor();
 	private final ArrayList<GenericInsertPair> commonPairs = new ArrayList<>();
-
-	HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
+	
+	HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
 	byte[] bytecode;
-	HashMap<String, byte[]> classFiles;
-
-	private final ArrayList<String> methodNameAndParamsT = new ArrayList<>();
-	private final ArrayList<String> fieldNameAndParamsT = new ArrayList<>();
-
-	private HashMap<String, SimplifyResult> simplifyResults = new HashMap<>();
-	private List<HashMap<String, SimplifyResult>> simplifyResultsList = new ArrayList<>();
-
-	private final ArrayList<String> fieldNameSignature = new ArrayList<>();
-
-	public List<HashMap<String, SimplifyResult>> getSimplifyResultsList() {
-		return simplifyResultsList;
-	}
-
-	public void setSimplifyResultsList(List<HashMap<String, SimplifyResult>> simplifyResultsList) {
-		this.simplifyResultsList = simplifyResultsList;
-	}
-
-	public BytecodeGen(HashMap<String, byte[]> classFiles, List<ResultSet> listOfResultSets, SourceFile sf,
-			String path) {
+	HashMap<String,byte[]> classFiles;
+	
+	ArrayList<String> methodNameAndParamsT = new ArrayList<>();
+	
+	public BytecodeGen(HashMap<String,byte[]> classFiles, List<ResultSet> listOfResultSets,SourceFile sf ,String path) {
 		this.classFiles = classFiles;
 		this.listOfResultSets = listOfResultSets;
 		this.sf = sf;
 		this.path = path;
 	}
-
+	
 	@Override
 	public void visit(SourceFile sourceFile) {
-		for (ClassOrInterface cl : sourceFile.getClasses()) {
+		for(ClassOrInterface cl : sourceFile.getClasses()) {
 			System.out.println("in Class: " + cl.getClassName().toString());
 			BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets, sf, path);
 			cl.accept(classGen);
-			simplifyResultsList.add(classGen.getSimplifyResults());
 			classGen.writeClass(cl.getClassName().toString());
 		}
 	}
-
+	
 	/**
-	 * Associates the bytecode of the class that was build with the classWriter
-	 * {@link #cw} with the class name in the map {@link #classFiles}
+	 * Associates the bytecode of the class that was build with the classWriter {@link #cw}
+	 * with the class name in the map {@link #classFiles}
 	 * 
 	 * @param name name of the class with which the the bytecode is to be associated
 	 */
 	private void writeClass(String name) {
 		bytecode = cw.toByteArray();
 		classFiles.put(name, bytecode);
-
+		
 	}
-
-	public HashMap<String, byte[]> getClassFiles() {
+	
+	public HashMap<String,byte[]> getClassFiles() {
 		return classFiles;
 	}
-
+	
+	
 	@Override
 	public void visit(ClassOrInterface classOrInterface) {
-
+		
 		className = classOrInterface.getClassName().toString();
+		
+		cw.visitSource(className +".jav", null);
+		
+		isInterface = (classOrInterface.getModifiers()&512)==512;
 
-		cw.visitSource(className + ".jav", null);
-
-		isInterface = (classOrInterface.getModifiers() & 512) == 512;
-
-		int acc = isInterface ? classOrInterface.getModifiers() + Opcodes.ACC_ABSTRACT
-				: classOrInterface.getModifiers() + Opcodes.ACC_SUPER;
-
+		int acc = isInterface?classOrInterface.getModifiers()+Opcodes.ACC_ABSTRACT:classOrInterface.getModifiers()+Opcodes.ACC_SUPER;
+		
 		fieldInitializations = classOrInterface.getfieldInitializations();
-
+		
 //		resultSet = listOfResultSets.get(0);
 		boolean isConsWithNoParamsVisited = false;
 		boolean isVisited = false;
-		for (ResultSet rs : listOfResultSets) {
+		for(ResultSet rs : listOfResultSets) {
 			superClass = classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor());
 			resultSet = rs;
 			tphExtractor.setResultSet(resultSet);
-
+			
 			// Nur einmal ausführen!!
-			if (!isVisited) {
+			if(!isVisited) {
 				classOrInterface.accept(tphExtractor);
 
 				getCommonTPHS(tphExtractor);
-
+				
 				tphsClass = new ArrayList<>();
-				for (String t : tphExtractor.allTPHS.keySet()) {
-					if (!tphExtractor.allTPHS.get(t))
+				for(TypePlaceholder t : tphExtractor.allTPHS.keySet()) {
+					if(!tphExtractor.allTPHS.get(t))
 						tphsClass.add(t);
 				}
-
-				String sig = null;
-				/*
-				 * if class has generics then creates signature Signature looks like:
-				 * <E:Ljava/...>Superclass
-				 */
-				if (classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty()
-						|| classOrInterface.getSuperClass().acceptTV(new TypeToSignature()).contains("<")
-						|| !tphsClass.isEmpty()) {
-					HashMap<TPHConstraint, HashSet<String>> constraints = Simplify
-							.simplifyConstraintsClass(tphExtractor, tphsClass);
-					ArrayList<TPHConstraint> consClass = new ArrayList<>();
-					for (TPHConstraint cons : constraints.keySet()) {
-						String right = null;
-						boolean isToAdd = false;
-						for (String tph : tphsClass) {
-							if (cons.getLeft().equals(tph)) {
-
-								consClass.add(cons);
-								try {
-									right = getTPH(cons.getRight());
-									isToAdd = true;
-								} catch (NoSuchElementException e) {
-									continue;
-								}
-
-							}
+				
+				ArrayList<TPHConstraint> consClass = new ArrayList<>();
+				for(TPHConstraint cons : tphExtractor.allCons) {
+					TypePlaceholder right = null;
+					for(TypePlaceholder tph : tphsClass) {
+						if(cons.getLeft().equals(tph.getName())) {
+							
+							consClass.add(cons);
+							right = getTPH(cons.getRight());
 						}
-						if (isToAdd) {
-							tphsClass.add(right);
-							removeFromMethod(right);
-							right = null;
-							isToAdd = false;
-						}
-//						if(right != null) {
-//							tphsClass.add(right);
-//							removeFromMethod(right);
-//							right = null;
-//						}
 					}
-
-					SimplifyResult sRes = new SimplifyResult(consClass, tphsClass, new HashMap<>());
-					simplifyResults.put(className, sRes);
-
-					Signature signature = new Signature(classOrInterface, genericsAndBounds, commonPairs, tphsClass,
-							consClass);
+					if(right != null) {
+						tphsClass.add(right);
+						removeFromMethod(right.getName());
+						right = null;
+					}
+				}
+				String sig = null;
+				/* if class has generics then creates signature
+				 * Signature looks like:
+				 * <E:Ljava/...>Superclass 
+				 */
+				if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty() || 
+						classOrInterface.getSuperClass().acceptTV(new TypeToSignature()).contains("<")
+						|| !tphsClass.isEmpty()) {
+					Signature signature = new Signature(classOrInterface, genericsAndBounds,commonPairs,tphsClass, consClass);
 					sig = signature.toString();
 					System.out.println("Signature: => " + sig);
 				}
-
-				cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString(), sig,
-						classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
-
+				
+				cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
+						, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
+				
 				isVisited = true;
 			}
-
-			for (Field f : classOrInterface.getFieldDecl()) {
+			
+			for(Field f : classOrInterface.getFieldDecl()) {
 				f.accept(this);
 			}
-
-			for (Constructor c : classOrInterface.getConstructors()) {
+			
+			for(Constructor c : classOrInterface.getConstructors()) {
 //				if(!isConsWithNoParamsVisited) {
-				c.accept(this);
+					c.accept(this);
 //				}
-
+					
 //				if(!c.getParameterList().iterator().hasNext())
 //					isConsWithNoParamsVisited = true;
 			}
-
-			for (Method m : classOrInterface.getMethods()) {
+			
+			for(Method m : classOrInterface.getMethods()) {
 				m.accept(this);
 			}
-
+		
 		}
-
+		
 	}
 
 	private void removeFromMethod(String name) {
-		for (MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) {
+		for(MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) {
 			ArrayList<String> toRemove = new ArrayList<>();
-			for (String tph : m.getTphs()) {
-				if (tph.equals(name)) {
+			for(String tph : m.getTphs()) {
+				if(tph.equals(name)) {
 					toRemove.add(tph);
 				}
 			}
-
-			if (!toRemove.isEmpty()) {
+			
+			if(!toRemove.isEmpty()) {
 				m.getTphs().removeAll(toRemove);
 				return;
 			}
 		}
-
+		
 	}
 
-	private String getTPH(String name) {
-		for (String tph : tphExtractor.allTPHS.keySet()) {
-			if (tph.equals(name))
+	private TypePlaceholder getTPH(String name) {
+		for(TypePlaceholder tph: tphExtractor.allTPHS.keySet()) {
+			if(tph.getName().equals(name))
 				return tph;
 		}
-		throw new NoSuchElementException("TPH " + name + " does not exist");
+		throw new NoSuchElementException("TPH "+name +" does not exist");
 	}
 
 	private void getCommonTPHS(TPHExtractor tphExtractor) {
 		// Gemeinsame TPHs
-		ArrayList<String> cTPHs = new ArrayList<>();
+		ArrayList<TypePlaceholder> cTPHs = new ArrayList<>();
 		// Alle TPHs der Felder speichern
-		for (String tph : tphExtractor.allTPHS.keySet()) {
-			if (!tphExtractor.allTPHS.get(tph))
+		for(TypePlaceholder tph : tphExtractor.allTPHS.keySet()) {
+			if(!tphExtractor.allTPHS.get(tph))
 				cTPHs.add(tph);
 		}
 	}
@@ -281,179 +242,156 @@ public class BytecodeGen implements ASTVisitor {
 	@Override
 	public void visit(Constructor field) {
 		System.out.println("ResultSet: ");
-		resultSet.results.forEach(a -> {
+		resultSet.results.forEach(a->{
 			System.out.println(a.getLeft().toString() + " = " + a.getRight().toString());
 		});
 		System.out.println("---------------");
-
+		
 		// stores generics and their bounds of method
 		HashMap<String, String> genericsAndBoundsMethod = new HashMap<>();
-
+		
 		field.getParameterList().accept(this);
-
-		String methParamTypes = field.name + "%%";
-
+		
+		String methParamTypes = field.name+"%%";
+		
 		Iterator<FormalParameter> itr = field.getParameterList().iterator();
-		while (itr.hasNext()) {
+		while(itr.hasNext()) {
 			FormalParameter fp = itr.next();
-			methParamTypes += resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()) + ";";
+			methParamTypes += resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
 //			methParamTypes += resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToSignature())+";";
 		}
-
-		if (methodNameAndParamsT.contains(methParamTypes)) {
-			System.out.println("ignore - Method: " + field.name + " , paramsType: " + methParamTypes);
+		
+		if(methodNameAndParamsT.contains(methParamTypes)) {
+			System.out.println("ignore - Method: "+field.name +" , paramsType: "+methParamTypes);
 			return;
 		}
 		methodNameAndParamsT.add(methParamTypes);
-		System.out.println("Method: " + field.name + " , paramsType: " + methParamTypes);
-
+		System.out.println("Method: "+field.name +" , paramsType: "+methParamTypes);
+		
 		String desc = null;
 		boolean hasGen = false;
-
-		for (String paramName : methodParamsAndTypes.keySet()) {
+		
+		for(String paramName : methodParamsAndTypes.keySet()) {
 			String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
 			System.out.println(typeOfParam);
-			if (genericsAndBounds.containsKey(typeOfParam) || typeOfParam.contains("$") || typeOfParam.contains("<")) {
+			if(genericsAndBounds.containsKey(typeOfParam) ||typeOfParam.contains("$")
+					|| typeOfParam.contains("<")) {
 				hasGen = true;
 				break;
 			}
 		}
 		String sig = null;
-		if (hasGen) {
-			HashMap<TPHConstraint, HashSet<String>> constraints = Simplify.simplifyConstraints(field.name, tphExtractor,
-					tphsClass);
-			Signature signature = new Signature(field, genericsAndBounds, methodParamsAndTypes, resultSet, constraints);
+		if(hasGen) {
+			HashMap<TPHConstraint, HashSet<String>> constraints = Simplify.simplifyConstraints(field.name, tphExtractor,tphsClass);
+			Signature signature = new Signature(field, genericsAndBounds,methodParamsAndTypes,resultSet,constraints);
 			sig = signature.toString();
 		}
-		if (field.getParameterList().iterator().hasNext())
+		if(field.getParameterList().iterator().hasNext())
 			System.out.println(field.getParameterList().iterator().next().getType().acceptTV(new TypeToDescriptor()));
-
-		NormalConstructor constructor = new NormalConstructor(field, genericsAndBounds, hasGen);
+		
+		NormalConstructor constructor = new NormalConstructor(field,genericsAndBounds,hasGen);
 		desc = constructor.accept(new DescriptorToString(resultSet));
-		System.out.println("Constructor: " + field.getName() + " Sig: " + sig + " Desc: " + desc);
+		System.out.println("Constructor: " + field.getName() + " Sig: "+ sig + " Desc: " + desc);
 		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", desc, sig, null);
-		mv.visitCode();
-
+		mv.visitCode();	
+		
 		Block block = fieldInitializations.get().block;
-
+		
 		constructorPos += 1;
-
-		BytecodeGenMethod gen = new BytecodeGenMethod(className, superClass, resultSet, field, mv, paramsAndLocals, cw,
-				genericsAndBoundsMethod, genericsAndBounds, isInterface, classFiles, sf, path, block, constructorPos);
-		if (!field.getParameterList().iterator().hasNext()
-				&& !(field.block.statements.get(field.block.statements.size() - 1) instanceof ReturnVoid)) {
+		
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,field, mv,paramsAndLocals,cw,
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, sf,path, block, constructorPos);
+		if(!field.getParameterList().iterator().hasNext() && !(field.block.statements.get(field.block.statements.size()-1) instanceof ReturnVoid)) {
 			mv.visitInsn(Opcodes.RETURN);
 		}
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();
 	}
-
+	
 	@Override
 	public void visit(Method method) {
-		// TODO: check if the method is static => if static then the first param will be
-		// stored in pos 0
+		// TODO: check if the method is static => if static then the first param will be stored in pos 0
 		// else it will be stored in pos 1 and this will be stored in pos 0
 		String retType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
 //		String retType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
-		String methParamTypes = retType + method.name + "%%";
+		String methParamTypes = retType+method.name+"%%";
 		method.getParameterList().accept(this);
 
 		Iterator<FormalParameter> itr = method.getParameterList().iterator();
-		while (itr.hasNext()) {
+		while(itr.hasNext()) {
 			FormalParameter fp = itr.next();
-			methParamTypes += resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()) + ";";
+			methParamTypes += resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
 //			methParamTypes += resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToSignature())+";";
 		}
-
-		if (methodNameAndParamsT.contains(methParamTypes)) {
+		
+		if(methodNameAndParamsT.contains(methParamTypes)) {
 			return;
 		}
 		methodNameAndParamsT.add(methParamTypes);
-		System.out.println("Method: " + method.name + " , paramsType: " + methParamTypes);
+		System.out.println("Method: "+method.name +" , paramsType: "+methParamTypes);
 		// stores generics and their bounds of method
 		HashMap<String, String> genericsAndBoundsMethod = new HashMap<>();
 		String methDesc = null;
-
+		
 		// Method getModifiers() ?
-		int acc = isInterface ? Opcodes.ACC_ABSTRACT : method.modifier;
+		int acc = isInterface?Opcodes.ACC_ABSTRACT:method.modifier;
 		System.out.println(acc);
-
-		/* Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist */
-		boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.contains("TPH ")
-				|| resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature())
-						.contains("<");
-		/*
-		 * Wenn die Rückgabe-Type eine Typ-variable ist, erzeuge direkt die Signature,
-		 * wenn nicht, prüfe, ob einer der Parameter Typ-Variable als Typ hat
-		 */
-		if (!hasGenInParameterList) {
-			for (String paramName : methodParamsAndTypes.keySet()) {
+		
+		/*Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist*/
+		boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.subSequence(0, 4).equals("TPH ") ||
+										resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature()).contains("<");
+		/*Wenn die Rückgabe-Type eine Typ-variable ist, erzeuge direkt die Signature, wenn nicht,
+		 * prüfe, ob einer der Parameter Typ-Variable als Typ hat*/
+		if(!hasGenInParameterList) {
+			for(String paramName : methodParamsAndTypes.keySet()) {
 				String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
 				String sigOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
-				if (genericsAndBounds.containsKey(typeOfParam) || typeOfParam.contains("TPH ")
-						|| sigOfParam.contains("<")) {
+				if(genericsAndBounds.containsKey(typeOfParam)||typeOfParam.substring(0, 4).equals("TPH ")||sigOfParam.contains("<")) {
 					hasGenInParameterList = true;
 					break;
 				}
 			}
 		}
-		// TODO: Test if the return-type or any of the parameter is a parameterized
-		// type. (VP)
-		// then create the descriptor with the new syntax.
-
+		//TODO: Test if the return-type or any of the parameter is a parameterized type. (VP)
+		//then create the descriptor with the new syntax.
+		
 		String sig = null;
-		/*
-		 * method.getGenerics: <....> RT method(..)
-		 */
+		/* method.getGenerics: <....> RT method(..) 
+		 * */
 		boolean hasGen = method.getGenerics().iterator().hasNext() || hasGenInParameterList;
 		/* if method has generics or return type is TPH, create signature */
 		// zwite operand muss weggelassen werden
-		if (hasGen || resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToString())
-				.equals("TPH")) {
+		if(hasGen||resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToString()).equals("TPH")) {
 			System.out.println("ALL CONST: " + tphExtractor.allCons.size());
-			tphExtractor.allCons.forEach(c -> System.out.println(c.toString()));
+			tphExtractor.allCons.forEach(c->System.out.println(c.toString()));
 			System.out.println("----------------");
-			HashMap<TPHConstraint, HashSet<String>> constraints = Simplify.simplifyConstraints(method.name,
-					tphExtractor, tphsClass);
+			HashMap<TPHConstraint, HashSet<String>> constraints = Simplify.simplifyConstraints(method.name, tphExtractor, tphsClass);
 //			ArrayList<GenericInsertPair> pairs = simplifyPairs(method.name,tphExtractor.allPairs,tphExtractor.allCons);
-			Signature signature = new Signature(method, genericsAndBoundsMethod, genericsAndBounds,
-					methodParamsAndTypes, resultSet, constraints);
+			Signature signature = new Signature(method, genericsAndBoundsMethod, genericsAndBounds,methodParamsAndTypes,resultSet,constraints);
 			sig = signature.toString();
-			if (simplifyResults.containsKey(className)) {
-				simplifyResults.get(className).getMethodsConstraints().put(methParamTypes, constraints);
-			} else {
-				SimplifyResult sRes = new SimplifyResult(new ArrayList<>(), new ArrayList<>(), new HashMap<>());
-				sRes.getMethodsConstraints().put(methParamTypes, constraints);
-				simplifyResults.put(className, sRes);
-			}
-
 		}
-		System.out.println(method.getName() + " ==> " + sig);
-		NormalMethod meth = new NormalMethod(method, genericsAndBounds, genericsAndBoundsMethod, hasGen);
+		System.out.println(method.getName()+" ==> "+sig);
+		NormalMethod meth = new NormalMethod(method,genericsAndBounds,genericsAndBoundsMethod,hasGen);
 		methDesc = meth.accept(new DescriptorToString(resultSet));
-
+		
 //		System.out.println(methDesc);
-		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC + acc, method.getName(), methDesc, sig, null);
-
-		mv.visitCode();
-		BytecodeGenMethod gen = new BytecodeGenMethod(className, superClass, resultSet, method, mv, paramsAndLocals, cw,
-				genericsAndBoundsMethod, genericsAndBounds, isInterface, classFiles, sf, path);
+		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC+acc, method.getName(), methDesc, sig, null);
 
+		mv.visitCode();		
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,method, mv,paramsAndLocals,cw,
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, sf,path);
+		
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();
 	}
-
-	public HashMap<String, SimplifyResult> getSimplifyResults() {
-		return simplifyResults;
-	}
-
+	
 	@Override
 	public void visit(ParameterList formalParameters) {
 		paramsAndLocals = new HashMap<>();
 		methodParamsAndTypes = new HashMap<>();
 		Iterator<FormalParameter> itr = formalParameters.iterator();
 		int i = 1;
-		while (itr.hasNext()) {
+		while(itr.hasNext()) {
 			FormalParameter fp = itr.next();
 			paramsAndLocals.put(fp.getName(), i);
 			methodParamsAndTypes.put(fp.getName(), resultSet.resolveType(fp.getType()).resolvedType);
@@ -461,39 +399,39 @@ public class BytecodeGen implements ASTVisitor {
 			i++;
 		}
 	}
-
+	
 	@Override
 	public void visit(FormalParameter formalParameter) {
 		formalParameter.getType().accept(this);
 	}
-
+	
 	@Override
 	public void visit(RefType refType) {
-		type = "L" + refType.toString() + ";";
+		type = "L"+refType.toString()+";";
 	}
 
 	@Override
 	public void visit(SuperWildcardType superWildcardType) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(TypePlaceholder typePlaceholder) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(ExtendsWildcardType extendsWildcardType) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(GenericRefType genericRefType) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	// ??
@@ -501,51 +439,41 @@ public class BytecodeGen implements ASTVisitor {
 	public void visit(FieldVar fieldVar) {
 		System.out.println("In FieldVar ---");
 //		cw.newField(fieldVar.receiver.toString(), fieldVar.fieldVarName.toString(), fieldVar.getType().toString());
-		FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE, fieldVar.fieldVarName, "L" + fieldVar.getType() + ";",
-				null, null);
+		FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE, fieldVar.fieldVarName, "L"+fieldVar.getType()+";", null, null);
 		fv.visitEnd();
 	}
-
+	
 	@Override
 	public void visit(Field field) {
 		System.out.println("In Field ---");
 		String des = "L";
-		if (resultSet.resolveType(field.getType()).resolvedType instanceof TypePlaceholder) {
+		if(resultSet.resolveType(field.getType()).resolvedType instanceof TypePlaceholder) {
 			des += Type.getInternalName(Object.class);
 		} else {
 			des += resultSet.resolveType(field.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 		}
-		des += ";";
+		des +=";";
 		System.out.println(des);
 		String sig = resultSet.resolveType(field.getType()).resolvedType.acceptTV(new TypeToSignature());
 		System.out.println(sig);
-		if (sig.charAt(sig.length() - 1) != (";").charAt(0)) {
-			sig += ";";
+		if(sig.charAt(sig.length()-1) != (";").charAt(0)) {
+			sig +=";";
 		}
-		String nameAndDesc = field.getName() + "%%" + des;
-		String nameAndSig = field.getName() + "%%" + sig;
-		if (fieldNameAndParamsT.contains(nameAndDesc)) {
-			if (fieldNameSignature.contains(nameAndSig)) {
-				return;
-			}
-			throw new BytecodeGeneratorError("Bytecode generation aborted due to duplicate field name&signature");
-		}
-		fieldNameAndParamsT.add(nameAndDesc);
-		fieldNameSignature.add(nameAndSig);
-
-		cw.visitField(field.modifier, field.getName(), des, sig, null);
+		cw.visitField(field.modifier, field.getName(),
+				des, sig, 
+				null);
 	}
 
 	@Override
 	public void visit(LambdaExpression lambdaExpression) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(Assign assign) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
@@ -556,151 +484,151 @@ public class BytecodeGen implements ASTVisitor {
 	@Override
 	public void visit(Block block) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(CastExpr castExpr) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(EmptyStmt emptyStmt) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(ForStmt forStmt) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(IfStmt ifStmt) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(InstanceOf instanceOf) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(LocalVar localVar) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(LocalVarDecl localVarDecl) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(MethodCall methodCall) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(NewClass methodCall) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(NewArray newArray) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(Return aReturn) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(ReturnVoid aReturn) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(StaticClassName staticClassName) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(Super aSuper) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(This aThis) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(WhileStmt whileStmt) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(DoStmt whileStmt) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	// ???
 	@Override
 	public void visit(Literal literal) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(ArgumentList argumentList) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(GenericTypeVar genericTypeVar) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(GenericDeclarationList genericTypeVars) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(AssignToField assignLeftSide) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(AssignToLocal assignLeftSide) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 	@Override
 	public void visit(SuperCall superCall) {
-
+		
 	}
 
 	@Override
@@ -713,5 +641,6 @@ public class BytecodeGen implements ASTVisitor {
 	public void visit(UnaryExpr unaryExpr) {
 		throw new NotImplementedException();
 	}
+	
 
 }

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

@@ -33,14 +33,12 @@ import org.objectweb.asm.Type;
 import org.objectweb.asm.signature.SignatureVisitor;
 import org.objectweb.asm.signature.SignatureWriter;
 
-import de.dhbwstuttgart.bytecode.Exception.NotInCurrentPackageException;
 import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
 import de.dhbwstuttgart.bytecode.signature.Signature;
 import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
 import de.dhbwstuttgart.bytecode.utilities.KindOfLambda;
 import de.dhbwstuttgart.bytecode.utilities.Lambda;
-import de.dhbwstuttgart.bytecode.utilities.MethodCallHelper;
 import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
 import de.dhbwstuttgart.bytecode.utilities.SamMethod;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
@@ -54,7 +52,6 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
-import javassist.NotFoundException;
 
 public class BytecodeGenMethod implements StatementVisitor {
 
@@ -143,8 +140,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	}
 
 	public BytecodeGenMethod(LambdaExpression lambdaExpression, ArrayList<String> usedVars, ResultSet resultSet, MethodVisitor mv,
-			int indexOfFirstParamLam, boolean isInterface, HashMap<String, byte[]> classFiles, String path, int lamCounter, SourceFile sf,HashMap<String, String> genericsAndBoundsMethod,
-			HashMap<String, String> genericsAndBounds) {
+			int indexOfFirstParamLam, boolean isInterface, HashMap<String, byte[]> classFiles, String path, int lamCounter, SourceFile sf) {
 
 		this.resultSet = resultSet;
 		this.mv = mv;
@@ -153,9 +149,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 		this.path = path;
 		this.lamCounter = lamCounter;
 		this.sf = sf;
-		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
-		this.genericsAndBounds = genericsAndBounds;
-		
 		Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
 		int i = indexOfFirstParamLam;
 		
@@ -651,8 +644,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 			ArrayList<String> usedVars = kindOfLambda.getUsedVars();
 			
 			new BytecodeGenMethod(lambdaExpression, usedVars,this.resultSet, mvLambdaBody, indexOfFirstParamLam, isInterface,
-					classFiles,this.path, lamCounter, sf, genericsAndBoundsMethod,
-					genericsAndBounds);
+					classFiles,this.path, lamCounter, sf);
 	
 			mvLambdaBody.visitMaxs(0, 0);
 			mvLambdaBody.visitEnd();
@@ -678,7 +670,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		}
 		methSig.visitReturnType().visitTypeVariable("R");
 		// ")"+lam.getReturn.getBounds
-		Signature sig = new Signature(numberOfParams);
+		Signature sig = new Signature(lambdaExpression, numberOfParams);
 		String name = "Fun" + numberOfParams + "$$";
 		classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC+Opcodes.ACC_INTERFACE + Opcodes.ACC_ABSTRACT, name, sig.toString(),
 				Type.getInternalName(Object.class), null);
@@ -752,13 +744,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 		statement = new IfStatement(ifStmt.expr, ifStmt.then_block, ifStmt.else_block);
 		isBinaryExp = statement.isExprBinary();
 		ifStmt.expr.accept(this);
-		if(!(ifStmt.expr instanceof BinaryExpr)) {
-			doUnboxing(getResolvedType(ifStmt.expr.getType()));
-			Label branchLabel = new Label();
-			Label endLabel = new Label();
-			mv.visitJumpInsn(Opcodes.IFEQ, branchLabel);
-			statement.genBCForRelOp(mv, branchLabel, endLabel, this);
-		}
 		statement = null;
 	}
 
@@ -766,112 +751,105 @@ public class BytecodeGenMethod implements StatementVisitor {
 	public void visit(InstanceOf instanceOf) {
 
 	}
-	
+
 	@Override
 	public void visit(MethodCall methodCall) {
 		boolean parentBinary = isParentBinary;
 		System.out.println("In MethodCall = " + methodCall.name);
 		String receiverName = getResolvedType(methodCall.receiver.getType());
 		System.out.println("Methods of " + receiverName + " ");
-		java.lang.reflect.Method methodRefl = null;
-		String clazz = receiverName.replace("/", ".");
-		
-		String mDesc = "";
-		
-		MethodCallHelper helper = new MethodCallHelper(methodCall, sf, resultSet, path);
-		
-		boolean toCreate = false;
-
 		ClassLoader cLoader = ClassLoader.getSystemClassLoader();
 		// This will be used if the class is not standard class (not in API)
 		ClassLoader cLoader2;
-
+		java.lang.reflect.Method methodRefl = null;
+		String clazz = receiverName.replace("/", ".");
 		String methCallType = resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 		String[] typesOfParams = getTypes(methodCall.arglist.getArguments());
 		try {
-			if (receiverName.contains("<")) {
+			if(receiverName.contains("<")) {
 				clazz = clazz.substring(0, receiverName.indexOf("<"));
 			}
-
+			
 			java.lang.reflect.Method[] methods = cLoader.loadClass(clazz).getMethods();
 			System.out.println("Methods of " + receiverName + " ");
-			methodRefl = getMethod(methodCall.name, methodCall.arglist.getArguments().size(), methods);
-
-			} catch (Exception e) {
-					String superClass = "";
-					while(true) {
-						try {
-							superClass = helper.getSuperClass(receiverName);
-							
-							try {
-								String superClazz = superClass.replace("/", ".");
-								if(superClass.contains("<")) {
-									superClazz = superClazz.substring(0, superClass.indexOf("<"));
-								}
-								java.lang.reflect.Method[] methods = cLoader.loadClass(superClazz).getMethods();
-								System.out.println("Methods of " + superClass + " ");
-								
-								for(java.lang.reflect.Method m : methods) {
-									if(methodCall.name.equals(m.getName())) {
-										methodRefl = m;
-										break;
-									}
-								}
-								
-								break;
-							} catch (Exception e3) {
-								receiverName = superClass;
-								continue;
-							}
-						} catch (NotInCurrentPackageException e2) {
+			methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methods);
+			
+		} catch (Exception e) {
+//			try {
+//				cLoader2 = new URLClassLoader(new URL[] {new URL("file://"+path)});
+//				java.lang.reflect.Method[] methods = cLoader2.loadClass(clazz).getMethods();
+//				System.out.println("Methods of " + receiverName + " ");
+//				for(int i = 0; i<methods.length; i++) {
+//					System.out.println(methods[i]);
+//				}
+//				methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methCallType, typesOfParams,methods);
+//			}catch (Exception e2) {
+				String superClass = "";
+				// TODO: Test SubMatrix.jav
+				while(true) {
+					for(ClassOrInterface cl : sf.getClasses()) {
+						if(receiverName.equals(cl.getClassName().toString())) {
+							superClass = cl.getSuperClass().getName().toString();
 							break;
 						}
-						
 					}
-				
-			}
-			
-			if(methodRefl == null) {
-				toCreate = !receiverName.equals(className) && helper.isInCurrPkg(clazz);
-				if(toCreate) {
+					System.out.println(superClass);
+					
+					if(superClass.equals(""))
+						break;
+					
 					try {
-						mDesc = helper.getDesc(clazz);
-					} catch (NotInCurrentPackageException | NotFoundException e) {
-						e.printStackTrace();
-					}
-				} else if(!helper.isInCurrPkg(clazz)){
-					if(clazz.contains("$$")) {
-						mDesc = helper.generateBCForFunN();
-					}else {
-						try {
-							cLoader2 = new URLClassLoader(new URL[] {new URL("file://"+path)});
-							java.lang.reflect.Method[] methods = cLoader2.loadClass(clazz).getMethods();
-							System.out.println("Methods of " + receiverName + " ");
-							for(int i = 0; i<methods.length; i++) {
-								System.out.println(methods[i]);
+						String superClazz = superClass.replace("/", ".");
+						if(superClass.contains("<")) {
+							superClazz = superClazz.substring(0, superClass.indexOf("<"));
+						}
+						java.lang.reflect.Method[] methods = cLoader.loadClass(superClazz).getMethods();
+						System.out.println("Methods of " + superClass + " ");
+						
+						for(java.lang.reflect.Method m : methods) {
+							if(methodCall.name.equals(m.getName())) {
+								methodRefl = m;
+								break;
 							}
-							methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methCallType, typesOfParams,methods);
-						}
-						catch (Exception e2) {
-							e2.printStackTrace();
 						}
+						
+						break;
+					} catch (Exception e3) {
+						receiverName = superClass;
+						continue;
 					}
 				}
-				
-			}
+//			}
+			
+		}
 		
+		if(methodRefl == null) {
+			try {
+				cLoader2 = new URLClassLoader(new URL[] {new URL("file://"+path)});
+				java.lang.reflect.Method[] methods = cLoader2.loadClass(clazz).getMethods();
+				System.out.println("Methods of " + receiverName + " ");
+				for(int i = 0; i<methods.length; i++) {
+					System.out.println(methods[i]);
+				}
+				methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methCallType, typesOfParams,methods);
+			}
+			catch (Exception e2) {
+				System.out.println("");
+				//do nothing
+			}
+		}
 		methodCall.receiver.accept(this);
 		
 		System.out.println("Methodcall type : " + resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor()));
+		String mDesc = "";
 		List<Boolean> argListMethCall = new LinkedList<>();
 		String receiverRefl="";
-		if(methodRefl == null && receiverName.equals(className)) {
+		if(methodRefl == null) {
 			MethodFromMethodCall method = new MethodFromMethodCall(methodCall.arglist, methodCall.getType(),
 					receiverName, genericsAndBoundsMethod, genericsAndBounds);
 			mDesc = method.accept(new DescriptorToString(resultSet));
 			methodCall.arglist.accept(this);
-		} else if(methodRefl != null) {
-			System.out.println(methodCall.name + " -> Refl != null");
+		} else {
 			receiverRefl = methodRefl.getAnnotatedReceiverType().getType().toString();
 			for(Parameter p:methodRefl.getParameters()) {
 				System.out.println(p.getName() + " und is Primitive = " + p.getType().isPrimitive());
@@ -885,11 +863,9 @@ public class BytecodeGenMethod implements StatementVisitor {
 				al.accept(argV);
 				statement = null;
 			}
-		} else {
-			methodCall.arglist.accept(this);
 		}
 		
-		System.out.println("Methodcall ("+ methodCall.name +") Desc : " + mDesc);
+		System.out.println("Methodcall Desc : " + mDesc);
 		
 		
 //		methodCall.arglist.accept(this);
@@ -924,19 +900,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 		
 	}
 	
-	private String getDescForMethInCurrPkg(String name) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-	private boolean isInCurrPkg(String superClass) {
-		for(ClassOrInterface cl : sf.KlassenVektor) {
-			if(superClass.equals(cl.getClassName().toString()))
-				return true;
-		}
-		return false;
-	}
-
 	private String[] getTypes(List<Expression> arguments) {
 		String[] types = new String[arguments.size()];
 		for(int i = 0; i<arguments.size(); ++i) {
@@ -1234,7 +1197,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 			break;
 		case "java/lang/Boolean":
-			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false);
 			break;
 		case "java/lang/Byte":
 			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B", false);
@@ -1272,16 +1234,10 @@ public class BytecodeGenMethod implements StatementVisitor {
 			visitBooleanLiteral((Boolean) value);
 			break;
 		case "java/lang/Byte":
-			if(value instanceof Double)
-				visitByteLiteral(((Double) value).byteValue(), false);
-			if(value instanceof Integer)
-				visitByteLiteral(((Integer) value).byteValue(), false);
+			visitByteLiteral(((Double) value).byteValue(), false);
 			break;
 		case "java/lang/Short":
-			if(value instanceof Double)
-				visitShortLiteral(((Double) value).shortValue(), false);
-			if(value instanceof Integer)
-				visitShortLiteral(((Integer) value).shortValue(), false);
+			visitShortLiteral(((Double) value).shortValue(), false);
 			break;
 		case "java/lang/Integer":
 			// zweite Argument isLong
@@ -1292,16 +1248,10 @@ public class BytecodeGenMethod implements StatementVisitor {
 				visitIntegerLiteral(((Integer) value).intValue(), false);
 			break;
 		case "java/lang/Long":
-			if(value instanceof Double)
-				visitLongLiteral(((Double) value).longValue(), true);
-			if(value instanceof Integer)
-				visitLongLiteral(((Integer) value).longValue(), true);
+			visitLongLiteral(((Integer) value).longValue(), true);
 			break;
 		case "java/lang/Float":
-			if(value instanceof Double)
-				visitFloatLiteral(((Double) value).floatValue());
-			if(value instanceof Integer)
-				visitFloatLiteral(((Integer) value).floatValue());
+			visitFloatLiteral(((Double) value).floatValue());
 			break;
 		case "java/lang/Double":
 			if(value instanceof Double)

src/main/java/de/dhbwstuttgart/bytecode/Exception/BytecodeGeneratorError.java

@@ -1,19 +0,0 @@
-/**
- * 
- */
-package de.dhbwstuttgart.bytecode.Exception;
-
-/**
- * @author fayez
- *
- */
-public class BytecodeGeneratorError extends RuntimeException {
-
-	/**
-	 * @param message
-	 */
-	public BytecodeGeneratorError(String message) {
-		super(message);
-	}
-	
-}

src/main/java/de/dhbwstuttgart/bytecode/Exception/NotFoundException.java

@@ -1,25 +0,0 @@
-/**
- * 
- */
-package de.dhbwstuttgart.bytecode.Exception;
-
-/**
- * @author fayez
- *
- */
-public class NotFoundException extends Exception {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-
-	/**
-	 * @param message
-	 */
-	public NotFoundException(String message) {
-		super(message);
-	}	
-	
-
-}

src/main/java/de/dhbwstuttgart/bytecode/Exception/NotInCurrentPackageException.java

@@ -1,26 +0,0 @@
-/**
- * 
- */
-package de.dhbwstuttgart.bytecode.Exception;
-
-/**
- * @author fayez
- *
- */
-public class NotInCurrentPackageException extends Exception {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-
-	/**
-	 * @param message
-	 */
-	public NotInCurrentPackageException(String message) {
-		super(message);
-	}
-	
-	
-
-}

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

@@ -5,151 +5,67 @@ package de.dhbwstuttgart.bytecode;
 
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
 import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
-import de.dhbwstuttgart.syntaxtree.Constructor;
-import de.dhbwstuttgart.syntaxtree.Field;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.Method;
-import de.dhbwstuttgart.syntaxtree.ParameterList;
-import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
-import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl;
-import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
-import de.dhbwstuttgart.typeinference.result.ResultPair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
 /**
  * @author Fayez Abu Alia
  *
  */
-public class TPHExtractor extends AbstractASTWalker {
+public class TPHExtractor extends AbstractASTWalker{
 	// Alle TPHs der Felder werden iKopf der Klasse definiert
 	// alle TPHs der Klasse: (TPH, is in Method?)
-	final HashMap<String, Boolean> allTPHS = new HashMap<>();
+	final HashMap<TypePlaceholder,Boolean> allTPHS = new HashMap<>();
 	MethodAndTPH methodAndTph;
-
 	Boolean inMethod = false;
-	boolean inLocalOrParam = false;
-
 	public final ArrayList<MethodAndTPH> ListOfMethodsAndTph = new ArrayList<>();
-	final ArrayList<ResultPair<TypePlaceholder, TypePlaceholder>> allPairs = new ArrayList<>();
+	final ArrayList<GenericInsertPair> allPairs = new ArrayList<>();
 	public final ArrayList<TPHConstraint> allCons = new ArrayList<>();
 	private ResultSet resultSet;
-
+	
 	public TPHExtractor() {
-
+		
 	}
-
+	
 	public void setResultSet(ResultSet resultSet) {
 		this.resultSet = resultSet;
 	}
-
+	
 	@Override
 	public void visit(TypePlaceholder tph) {
-		if (resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) {
+		if(resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) {
 			TypePlaceholder resolvedTPH = (TypePlaceholder) resultSet.resolveType(tph).resolvedType;
-			if (inMethod) {
+			if(inMethod)
 				methodAndTph.getTphs().add(resolvedTPH.getName());
-				if (inLocalOrParam)
-					methodAndTph.getLocalTphs().add(resolvedTPH.getName());
-			}
-
-			allTPHS.put(resolvedTPH.getName(), inMethod);
-//			final List<TPHConstraint> cons = new ArrayList<>();
-//			resultSet.resolveType(tph).additionalGenerics.forEach(ag -> {
-//				TPHConstraint con = new ExtendsConstraint(ag.TA1.getName(), ag.TA2.getName(), Relation.EXTENDS);
-//				cons.add(con);
-//			});
-//			
-//			Map<TPHConstraint, Boolean> visitMap = new HashMap<>();
-//			for(TPHConstraint cc : cons) {
-//				visitMap.put(cc, false);
-//			}
-//			
-//			String left = resolvedTPH.getName();
-//			for (TPHConstraint cc : visitMap.keySet()) {
-//				
-//				if(visitMap.get(cc))
-//					continue;
-//				
-//				if (cc.getLeft().equals(left)) {
-//					allCons.add(cc);
-//					List<TPHConstraint> toVisit = getToVisitCons(cons,cc.getRight(), visitMap);
-//				}
-//			}
-
-			//resultSet.resolveType(tph).getAdditionalGenerics().forEach(ag -> {
-			resultSet.genIns.forEach(ag -> {
-
-//				if (ag.contains(resolvedTPH) /* && ag.TA1.equals(resolvedTPH) */ && !contains(allPairs, ag)) {
-					if (inMethod)
+			
+			allTPHS.put(resolvedTPH,inMethod);
+			resultSet.resolveType(tph).additionalGenerics.forEach(ag ->{
+				if(ag.contains(resolvedTPH)&&ag.TA1.equals(resolvedTPH)&&!contains(allPairs,ag)) {
+					if(inMethod)
 						methodAndTph.getPairs().add(ag);
 					allPairs.add(ag);
-					TPHConstraint con = new ExtendsConstraint(ag.getLeft().getName(), ag.getRight().getName(), Relation.EXTENDS);
-					if(!containsConstraint(allCons,con))
-						allCons.add(con);
-//				}
+					TPHConstraint con = new ExtendsConstraint(ag.TA1.getName(), ag.TA2.getName(), Relation.EXTENDS);
+					allCons.add(con);
+				}
 			});
-		} else if (resultSet.resolveType(tph).resolvedType instanceof RefType) {
-			RefType rt = (RefType) resultSet.resolveType(tph).resolvedType;
-			rt.accept(this);
 		}
 	}
-
-	private static boolean containsConstraint(ArrayList<TPHConstraint> allCons, TPHConstraint c) {
-		for(TPHConstraint con:allCons) {
-			if(c.getLeft().equals(con.getLeft()) && c.getRight().equals(c.getRight())) {
-				return true;
-			}
-		}
-		return false;
-	}
-	
-	private List<TPHConstraint> getToVisitCons(List<TPHConstraint> cons, String right, Map<TPHConstraint, Boolean> visitMap) {
-		List<TPHConstraint> res = new ArrayList<>();
-		for(TPHConstraint cc : cons) {
-			if(cc.getLeft().equals(right)) {
-				res.add(cc);
-				if(visitMap.get(cc))
-					visitMap.replace(cc, false);
-			}
-		}
-		return res;
-	}
-
-	@Override
-	public void visit(GenericRefType genericRefType) {
-		String name = genericRefType.getParsedName();
-		if (inMethod) {
-			methodAndTph.getLocalTphs().add(name);
-			if (inLocalOrParam)
-				methodAndTph.getLocalTphs().add(name);
-		}
-		allTPHS.put(name, inMethod);
-	}
-
 	private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
-		for (int i = 0; i < pairs.size(); ++i) {
+		for(int i=0; i<pairs.size();++i) {
 			GenericInsertPair p = pairs.get(i);
-			if (p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
+			if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
 				return true;
 		}
 		return false;
 	}
-
 	@Override
 	public void visit(Method method) {
 		inMethod = true;
@@ -158,33 +74,5 @@ public class TPHExtractor extends AbstractASTWalker {
 		inMethod = false;
 		ListOfMethodsAndTph.add(methodAndTph);
 	}
-
-	@Override
-	public void visit(Constructor cons) {
-		inMethod = false;
-		super.visit(cons);
-		inMethod = true;
-	}
-
-	@Override
-	public void visit(LocalVarDecl localVarDecl) {
-		inLocalOrParam = true;
-		super.visit(localVarDecl);
-		inLocalOrParam = false;
-	}
-
-	@Override
-	public void visit(LocalVar localVar) {
-		inLocalOrParam = true;
-		super.visit(localVar);
-		inLocalOrParam = false;
-	}
-
-	@Override
-	public void visit(ParameterList formalParameters) {
-		inLocalOrParam = true;
-		super.visit(formalParameters);
-		inLocalOrParam = false;
-	}
-
+	
 }

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.bytecode.descriptor;
 
-import java.util.HashMap;
 import java.util.Iterator;
 
 import org.objectweb.asm.Type;
@@ -45,28 +44,17 @@ public class DescriptorToString implements DescriptorVisitor{
 			if(method.hasGen()) {
 				String fpDesc = fp.getType().acceptTV(new TypeToDescriptor());
 				if(method.getGenericsAndBoundsMethod().containsKey(fpDesc)) {
-					String bound = getBound(fpDesc, method.getGenericsAndBoundsMethod());
-					desc += "L"+bound+ ";";
+					desc += "L"+method.getGenericsAndBoundsMethod().get(fpDesc)+ ";";
 				}else if(method.getGenericsAndBounds().containsKey(fpDesc)){
-					String bound = getBound(fpDesc, method.getGenericsAndBounds());
-					desc += "L"+bound+ ";";
+					desc += "L"+method.getGenericsAndBounds().get(fpDesc)+ ";";
 				}else {
 //					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
 					String resType = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
-					if(resType.contains("TPH ")/*resType.subSequence(0, 4).equals("TPH ")*/) {
+					if(resType.subSequence(0, 4).equals("TPH ")) {
 						// Bound ist immer Object
 						desc += "L"+Type.getInternalName(Object.class)+ ";";
 					} else {
-						// TODO::
-						if(method.getGenericsAndBounds().containsKey(resType)) {
-							String bound = getBound(resType, method.getGenericsAndBounds());
-							desc += "L"+bound+ ";";
-						}else if(method.getGenericsAndBoundsMethod().containsKey(resType)) {
-							String bound = getBound(resType, method.getGenericsAndBoundsMethod());
-							desc += "L"+bound+ ";";
-						} else {
-							desc += "L"+resType+ ";";
-						}
+						desc += "L"+resType+ ";";
 					}
 				}
 			}
@@ -90,21 +78,11 @@ public class DescriptorToString implements DescriptorVisitor{
 					desc += ")L"+method.getGenericsAndBounds().get(ret)+ ";";
 				}else {
 					String resType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
-					if(resType.contains("TPH ")/*resType.subSequence(0, 4).equals("TPH ")*/) {
+					if(resType.subSequence(0, 4).equals("TPH ")) {
 //						desc += ")" + "L"+method.getGenericsAndBoundsMethod().get(resType.substring(4)+"$")+ ";";
 						desc += ")" + "L"+Type.getInternalName(Object.class)+ ";";
 					} else {
-						// TODO::
-						if(method.getGenericsAndBounds().containsKey(resType)) {
-							String bound = getBound(resType, method.getGenericsAndBounds());
-							desc += ")L"+bound+ ";";
-						}else if(method.getGenericsAndBoundsMethod().containsKey(resType)) {
-							String bound = getBound(resType, method.getGenericsAndBoundsMethod());
-							desc += ")L"+bound+ ";";
-						} else {
-							desc += ")L"+resType+ ";";
-						}
-//						desc += ")" + "L"+resType+ ";";
+						desc += ")" + "L"+resType+ ";";
 					}
 				}
 			}else {
@@ -115,15 +93,6 @@ public class DescriptorToString implements DescriptorVisitor{
 		return desc;
 	}
 
-	private String getBound(String fpDesc, HashMap<String, String> genericsAndBounds) {
-		String start = genericsAndBounds.get(fpDesc);
-		while(genericsAndBounds.containsKey(start)) {
-			start = genericsAndBounds.get(start);
-		}
-		
-		return start;
-	}
-
 	@Override
 	public String visit(NormalConstructor constructor) {
 		String desc = "(";
@@ -162,7 +131,7 @@ public class DescriptorToString implements DescriptorVisitor{
 		while(itr.hasNext()) {
 			FormalParameter fp = itr.next();
 			String d = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
-			if(d.contains("TPH ") ||d.contains("<")) {
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
 				desc = desc + "L"+ d + ";";
@@ -171,7 +140,7 @@ public class DescriptorToString implements DescriptorVisitor{
 		
 		String retType = resultSet.resolveType(lambdaExpression.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
 		
-		if(retType.contains("TPH ")|| retType.contains("<")){
+		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
 			desc = desc + ")"+"L"+retType+";";
@@ -187,7 +156,7 @@ public class DescriptorToString implements DescriptorVisitor{
 			RefTypeOrTPHOrWildcardOrGeneric rt = itr.next();
 			String d = resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor());
 			
-			if(d.contains("TPH ") ||d.contains("<")) {
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
 				desc += "L"+ d + ";";
@@ -196,7 +165,7 @@ public class DescriptorToString implements DescriptorVisitor{
 		}
 		String retType = resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
 		
-		if(retType.contains("TPH ")|| retType.contains("<")){
+		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
 			desc = desc + ")"+"L"+retType+";";
@@ -210,7 +179,7 @@ public class DescriptorToString implements DescriptorVisitor{
 		for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
 			String d = resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 			
-			if(d.contains("TPH ") ||d.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")) {
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
 				if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
@@ -227,7 +196,7 @@ public class DescriptorToString implements DescriptorVisitor{
 		System.out.println("DescriptorToString retType = " + retType);
 		if(retType.equals("void")) {
 			desc += ")V";
-		}else if(retType.contains("TPH ")|| retType.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")){
+		}else if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
 			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(retType)) {

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

@@ -41,11 +41,11 @@ public class Signature {
 	private ResultSet resultSet;
 	private ArrayList<GenericInsertPair> commonPairs;
 	private HashMap<TPHConstraint,HashSet<String>> methodConstraints;
-	private ArrayList<String> tphsClass;
+	private ArrayList<TypePlaceholder> tphsClass;
 	private ArrayList<TPHConstraint> consClass;
 	
 	public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds,
-			ArrayList<GenericInsertPair> commonPairs, ArrayList<String> tphsClass, ArrayList<TPHConstraint> consClass) {
+			ArrayList<GenericInsertPair> commonPairs, ArrayList<TypePlaceholder> tphsClass, ArrayList<TPHConstraint> consClass) {
 		this.classOrInterface = classOrInterface;
 		this.genericsAndBounds = genericsAndBounds;
 		this.commonPairs = commonPairs;
@@ -80,12 +80,12 @@ public class Signature {
 		createSignatureForConsOrMethod(this.method,false);
 	}
 	
-	public Signature(int numberOfParams) {
+	public Signature(LambdaExpression lambdaExpression,int numberOfParams) {
 		sw = new SignatureWriter();
-		createSignatureForFunN(numberOfParams);
+		createSignatureForFunN(lambdaExpression, numberOfParams);
 	}
 
-	private void createSignatureForFunN(int numberOfParams) {
+	private void createSignatureForFunN(LambdaExpression lambdaExpression, int numberOfParams) {
 		
 //		sw.visitClassBound().visitEnd();
 		for(int i = 0;i<numberOfParams;i++) {
@@ -235,9 +235,8 @@ public class Signature {
 			
 			RefTypeOrTPHOrWildcardOrGeneric resolved = resType.resolvedType;
 			if(resolved instanceof TypePlaceholder) {
-				//resType.getAdditionalGenerics().forEach(ag ->{
-				resultSet.genIns.forEach(ag ->{
-					TPHConstraint constr = new ExtendsConstraint(ag.getLeft().getName(), ag.getRight().getName(), Relation.EXTENDS);
+				resType.additionalGenerics.forEach(ag ->{
+					TPHConstraint constr = new ExtendsConstraint(ag.TA1.getName(), ag.TA2.getName(), Relation.EXTENDS);
 					if(!contains(res,constr)) {
 						res.add(constr);
 					}
@@ -247,9 +246,8 @@ public class Signature {
 				WildcardType resWC = (WildcardType) resolved;
 				ResolvedType resType2 = resultSet.resolveType(resWC.getInnerType());
 				if(resType2.resolvedType instanceof TypePlaceholder) {
-					//resType2.getAdditionalGenerics().forEach(ag ->{
-					resultSet.genIns.forEach(ag ->{
-						TPHConstraint constr = new ExtendsConstraint(ag.getLeft().getName(), ag.getRight().getName(), Relation.EXTENDS);
+					resType2.additionalGenerics.forEach(ag ->{
+						TPHConstraint constr = new ExtendsConstraint(ag.TA1.getName(), ag.TA2.getName(), Relation.EXTENDS);
 						if(!contains(res,constr)) {
 							res.add(constr);
 						}
@@ -292,8 +290,7 @@ public class Signature {
 			break;
 		case "GRT":
 			GenericRefType g = (GenericRefType) t;
-//			sv.visitTypeVariable(g.acceptTV(new TypeToSignature()).substring(1));
-			sv.visitTypeVariable(g.acceptTV(new TypeToSignature()));
+			sv.visitTypeVariable(g.acceptTV(new TypeToSignature()).substring(1));
 			break;
 		case "TPH":
 			RefTypeOrTPHOrWildcardOrGeneric r = resultSet.resolveType(t).resolvedType;
@@ -304,27 +301,16 @@ public class Signature {
 			// das braucht man nicht es reicht: sv.visitTypeVariable(r.acceptTV(new TypeToSignature())
 			// 
 			String sig2 = r.acceptTV(new TypeToSignature());
-			if(r instanceof GenericRefType) {
-				sv.visitTypeVariable(sig2);
-			}else if(!(r instanceof TypePlaceholder)) {
+			String eqTPH = getEqualTPH(methodConstraints, sig2.substring(1, sig2.length()-1))+"$";
+			if(!(r instanceof TypePlaceholder)) {
 				if(sig2.contains("$$")) {
 					System.out.println(" Signature FUN$$: "+r);
 					sv.visitInterface().visitClassType(sig2.substring(1, sig2.length()));
 				} else {
-					// Kann zwischen GenericRefType und RefType nicht unterscheiden
-					// Deswegen wird immer geprüft, ob der Name in Generic Maps liegt
-					String n = sig2.substring(1, sig2.length()-1);
-//					if(genericsAndBoundsMethod.containsKey(n) || genericsAndBounds.containsKey(n)) {
-//						sv.visitTypeVariable(n);
-//					} else {
-						sv.visitClassType(n);
-						sv.visitEnd();
-//					}
-//					sv.visitClassType(n);
+					sv.visitClassType(sig2.substring(1, sig2.length()));
 				}
 				
 			} else {
-				String eqTPH = getEqualTPH(methodConstraints, sig2.substring(1, sig2.length()-1))+"$";
 				System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
 				sv.visitTypeVariable(eqTPH);
 			}
@@ -405,7 +391,7 @@ public class Signature {
 			}
 			
 			for(TPHConstraint cons : consClass) {
-				if(!types.contains(cons.getRight()) && !genericsAndBounds.keySet().contains(cons.getRight()+"$")) {
+				if(!types.contains(cons.getRight())) {
 					String t = cons.getRight()+"$";
 					String bound = Type.getInternalName(Object.class);
 					sw.visitFormalTypeParameter(t);
@@ -470,15 +456,10 @@ public class Signature {
 			String boundDesc = b.acceptTV(new TypeToDescriptor());
 //			System.out.println("GetBounds: " + boundDesc);
 			// Ensure that <...> extends java.lang.Object OR ...
-			if(b instanceof GenericRefType) {
-				sw.visitClassBound().visitTypeVariable(boundDesc);
-			} else {
-				sw.visitClassBound().visitClassType(boundDesc);
-				sw.visitClassBound().visitEnd();
-			}
+			sw.visitClassBound().visitClassType(boundDesc);
 			genAndBounds.put(g.getName(), boundDesc);
 		}
-//		sw.visitClassBound().visitEnd();
+		sw.visitClassBound().visitEnd();
 	}
 	
 	public String toString() {

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

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

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

@@ -2,19 +2,14 @@ package de.dhbwstuttgart.bytecode.utilities;
 
 import java.util.ArrayList;
 
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
-import de.dhbwstuttgart.typeinference.result.ResultPair;
 
 public class MethodAndTPH {
 	
 	private String name;
 	private final ArrayList<String> tphs = new ArrayList<>();
-	//private final ArrayList<GenericInsertPair> pairs = new ArrayList<>();
-	private final ArrayList<ResultPair<TypePlaceholder, TypePlaceholder>> pairs = new ArrayList<>();
-	// tphs of local variables and parameters
-	private final ArrayList<String> localTphs = new ArrayList<>();
+	private final ArrayList<GenericInsertPair> pairs = new ArrayList<>();
 
 	public MethodAndTPH(String name) {
 		this.name = name;
@@ -24,19 +19,11 @@ public class MethodAndTPH {
 		return tphs;
 	}
 	
-//	public ArrayList<GenericInsertPair> getPairs(){
-//		return pairs;
-//	}
-	public ArrayList<ResultPair<TypePlaceholder, TypePlaceholder>> getPairs(){
+	public ArrayList<GenericInsertPair> getPairs(){
 		return pairs;
 	}
 	
 	public String getName() {
 		return name;
 	}
-
-	public ArrayList<String> getLocalTphs() {
-		return localTphs;
-	}
-	
 }

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

@@ -1,255 +0,0 @@
-/**
- * 
- */
-package de.dhbwstuttgart.bytecode.utilities;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
-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 de.dhbwstuttgart.bytecode.Exception.NotInCurrentPackageException;
-import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
-import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
-import de.dhbwstuttgart.bytecode.signature.Signature;
-import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
-import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
-import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
-import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.Method;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.syntaxtree.statement.Expression;
-import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
-import de.dhbwstuttgart.syntaxtree.statement.MethodCall;
-import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-import javassist.NotFoundException;
-
-/**
- * @author fayez
- *
- */
-public class MethodCallHelper {
-	private MethodCall methCall;
-	private SourceFile sourceFile;
-	private ResultSet resultSet;
-	private String path;
-
-	/**
-	 * @param methCall
-	 * @param sourceFile
-	 * @param resultSet
-	 * @param path TODO
-	 */
-	public MethodCallHelper(MethodCall methCall, SourceFile sourceFile, ResultSet resultSet, String path) {
-		this.methCall = methCall;
-		this.sourceFile = sourceFile;
-		this.resultSet = resultSet;
-		this.path = path;
-	}
-
-	public String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) {
-		return resultSet.resolveType(type).resolvedType.acceptTV(new TypeToDescriptor());
-	}
-
-	public boolean isInCurrPkg(String className) {
-		for (ClassOrInterface cl : sourceFile.KlassenVektor) {
-			if (className.equals(cl.getClassName().toString()))
-				return true;
-		}
-		return false;
-	}
-
-	public String getSuperClass(String className) throws NotInCurrentPackageException {
-		
-		for (ClassOrInterface cl : sourceFile.getClasses()) {
-			if (className.equals(cl.getClassName().toString())) {
-				return cl.getSuperClass().getName().toString();
-			}
-		}
-		throw new NotInCurrentPackageException("Class " + className + " is not in the current package.");
-	}
-
-	public ClassOrInterface getClassFromCurrPkg(String className) throws NotInCurrentPackageException {
-		for (ClassOrInterface cl : sourceFile.KlassenVektor) {
-			if (className.equals(cl.getClassName().toString()))
-				return cl;
-		}
-		throw new NotInCurrentPackageException("Class of " + className + " is not in the current package.");
-	}
-
-	public String getDesc(String className) throws NotInCurrentPackageException, NotFoundException {
-		String name = methCall.name;
-		ClassOrInterface clazz = getClassFromCurrPkg(className);
-
-		Map<String, String> genAndBoundsClass = getGenericsAndBounds(clazz.getGenerics());
-		modifyGenAndBounds(genAndBoundsClass);
-		for (Method m : clazz.getMethods()) {
-			if (name.equals(m.getName())) {
-				Map<String, String> genAndBoundsMethod = getGenericsAndBoundsMethod(m.getGenerics());
-				modifyGenAndBounds(genAndBoundsMethod);
-				boolean hasGen = hasGen(m, genAndBoundsClass);
-				NormalMethod nm = new NormalMethod(m, (HashMap<String, String>) genAndBoundsClass,
-						(HashMap<String, String>) genAndBoundsMethod, hasGen);
-				return nm.accept(new DescriptorToString(resultSet));
-			}
-		}
-
-		throw new NotFoundException("Method " + name + " is not found");
-	}
-
-	private boolean hasGen(Method m, Map<String, String> genericsAndBounds) {
-		String retType = resultSet.resolveType(m.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
-		/*Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist*/
-		boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.contains("TPH ") || retType.contains("<");
-
-		Map<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
-		Iterator<FormalParameter> itr = m.getParameterList().iterator();
-		while(itr.hasNext()) {
-			FormalParameter fp = itr.next();
-			methodParamsAndTypes.put(fp.getName(), resultSet.resolveType(fp.getType()).resolvedType);
-		}
-		/*Wenn die Rückgabe-Type eine Typ-variable ist, erzeuge direkt die Signature, wenn nicht,
-		 * prüfe, ob einer der Parameter Typ-Variable als Typ hat*/
-		if(!hasGenInParameterList) {
-			for(String paramName : methodParamsAndTypes.keySet()) {
-				String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
-				String sigOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
-				if(genericsAndBounds.containsKey(typeOfParam)||typeOfParam.contains("TPH ")||sigOfParam.contains("<")) {
-					hasGenInParameterList = true;
-					break;
-				}
-			}
-		}
-		return m.getGenerics().iterator().hasNext() || hasGenInParameterList;
-	}
-
-	private Map<String, String> getGenericsAndBoundsMethod(Iterable<? extends GenericTypeVar> generics) {
-		Map<String, String> genAndBounds = new HashMap<>();
-		Iterator<? extends GenericTypeVar> itr = generics.iterator();
-		while (itr.hasNext()) {
-			GenericTypeVar gtv = itr.next();
-			getBoundsOfTypeVar(gtv, genAndBounds);
-		}
-		return genAndBounds;
-	}
-
-	private void modifyGenAndBounds(Map<String, String> genAndBoundsClass) {
-		List<String> visited = new ArrayList<>(genAndBoundsClass.size());
-		Map<String, String> toReplace = new HashMap<>();
-		for (String tv : genAndBoundsClass.keySet()) {
-
-			if (visited.contains(tv))
-				continue;
-
-			List<String> types = new LinkedList<>();
-			String bound = genAndBoundsClass.get(tv);
-			types.add(tv);
-			visited.add(tv);
-			boolean doReplace = false;
-			while (genAndBoundsClass.keySet().contains(bound)) {
-				doReplace = true;
-				types.add(bound);
-				visited.add(bound);
-				bound = genAndBoundsClass.get(bound);
-			}
-
-			if (doReplace) {
-				for (String tt : types) {
-					toReplace.put(tt, bound);
-				}
-			}
-		}
-
-		for (String key : toReplace.keySet()) {
-			genAndBoundsClass.replace(key, toReplace.get(key));
-		}
-
-	}
-
-	private Map<String, String> getGenericsAndBounds(GenericDeclarationList generics) {
-		Map<String, String> genAndBounds = new HashMap<>();
-		Iterator<GenericTypeVar> itr = generics.iterator();
-		while (itr.hasNext()) {
-			GenericTypeVar gtv = itr.next();
-			getBoundsOfTypeVar(gtv, genAndBounds);
-		}
-		return genAndBounds;
-	}
-
-	private void getBoundsOfTypeVar(GenericTypeVar g, Map<String, String> genAndBounds) {
-
-		Iterator<? extends RefTypeOrTPHOrWildcardOrGeneric> bItr = g.getBounds().iterator();
-		while (bItr.hasNext()) {
-			RefTypeOrTPHOrWildcardOrGeneric b = bItr.next();
-			String boundDesc = b.acceptTV(new TypeToDescriptor());
-			genAndBounds.put(g.getName(), boundDesc);
-		}
-	}
-
-	public String generateBCForFunN() {
-		ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
-
-		SignatureWriter methSig = new SignatureWriter();
-
-		int numberOfParams = 0;
-		SignatureVisitor paramVisitor = methSig.visitParameterType();
-		Iterator<Expression> itr1 = methCall.arglist.getArguments().iterator();
-		String methDesc = "(";
-		while(itr1.hasNext()) {
-			numberOfParams++;
-			// getBounds
-			paramVisitor.visitTypeVariable("T" + numberOfParams);
-			methDesc += "L" + Type.getInternalName(Object.class) + ";";
-			itr1.next();
-		}
-		methDesc += ")L" + Type.getInternalName(Object.class) + ";";
-		
-		methSig.visitReturnType().visitTypeVariable("R");
-		// ")"+lam.getReturn.getBounds
-		Signature sig = new Signature(numberOfParams);
-		String name = "Fun" + numberOfParams + "$$";
-		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);
-		return methDesc;
-	}
-
-	private void writeClassFile(byte[] bytecode, String name) {
-		FileOutputStream output;
-		try {
-			System.out.println("generating " + name + ".class file...");
-			output = new FileOutputStream(
-					new File(path + name + ".class"));
-			output.write(bytecode);
-			output.close();
-			System.out.println(name + ".class file generated");
-		} catch (FileNotFoundException e) {
-			e.printStackTrace();
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-
-	}
-
-}

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

@@ -23,7 +23,6 @@ public class MethodFromMethodCall {
 		this.genericsAndBounds = genericsAndBounds;
 	}
 	
-	
 	public ArgumentList getArgList() {
 		return argList;
 	}

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

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

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

@@ -1,42 +0,0 @@
-/**
- * 
- */
-package de.dhbwstuttgart.bytecode.utilities;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-
-import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-
-/**
- * @author fayez
- *
- */
-public class SimplifyResult {
-	private final ArrayList<TPHConstraint> classConstraints;
-	private final ArrayList<String> tphsClass;
-	private final HashMap<String, HashMap<TPHConstraint, HashSet<String>>> methodsConstraints;
-	
-	public SimplifyResult(ArrayList<TPHConstraint> classConstraints, ArrayList<String> tphsClass,
-			HashMap<String, HashMap<TPHConstraint, HashSet<String>>> methodsConstraints) {
-		super();
-		this.classConstraints = classConstraints;
-		this.tphsClass = tphsClass;
-		this.methodsConstraints = methodsConstraints;
-	}
-
-	public ArrayList<TPHConstraint> getClassConstraints() {
-		return classConstraints;
-	}
-
-	public HashMap<String, HashMap<TPHConstraint, HashSet<String>>> getMethodsConstraints() {
-		return methodsConstraints;
-	}
-
-	public ArrayList<String> getTphsClass() {
-		return tphsClass;
-	}
-	
-}

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

@@ -3,8 +3,6 @@ package de.dhbwstuttgart.core;
 
 
 import de.dhbwstuttgart.bytecode.BytecodeGen;
-import de.dhbwstuttgart.bytecode.Exception.BytecodeGeneratorError;
-import de.dhbwstuttgart.bytecode.utilities.SimplifyResult;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
 import de.dhbwstuttgart.parser.JavaTXParser;
 import de.dhbwstuttgart.parser.NullToken;
@@ -36,7 +34,6 @@ import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
 import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
 import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
 
@@ -44,31 +41,20 @@ import java.io.File;
 import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.io.Writer;
 import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.antlr.v4.parse.ANTLRParser.throwsSpec_return;
-import org.apache.commons.io.output.NullOutputStream;
-//import org.apache.commons.io.output.NullOutputStream;
 
 public class JavaTXCompiler {
 
     final CompilationEnvironment environment;
-    Boolean resultmodel = false;
+    Boolean resultmodel = true;
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
     Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"src/test/java/logFiles" geschrieben werden soll?
-    
-    /**
-     * Äußerste Liste der Source-Files.
-     * Danach Liste der Klassen in Source File.
-     * Danach Map Klassenname 
-     */
-    private List<List<HashMap<String, SimplifyResult>>> simplifyResultsSF = new ArrayList<>();
-    
+
     public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
         this(Arrays.asList(sourceFile));
     }
@@ -288,7 +274,7 @@ public class JavaTXCompiler {
 	}
 	*/
     
-    public UnifyResultModel typeInferenceAsync(UnifyResultListener resultListener, Writer logFile) throws ClassNotFoundException {
+    public UnifyResultModel typeInferenceAsync() throws ClassNotFoundException {
     	List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
         //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
         for(SourceFile sf : this.sourceFiles.values()) {
@@ -298,14 +284,12 @@ public class JavaTXCompiler {
 
         final ConstraintSet<Pair> cons = getConstraints();
         Set<Set<UnifyPair>> results = new HashSet<>();
-        UnifyResultModel urm = null;
-        //urm.addUnifyResultListener(resultListener);
+        UnifyResultModel urm = new UnifyResultModel();
         try {
-        	logFile = logFile == null ? new FileWriter(new File("log_"+sourceFiles.keySet().iterator().next().getName())) : logFile;
+			FileWriter logFile = new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName()));
+			
 			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile);
 			System.out.println(finiteClosure);
-			urm = new UnifyResultModel(cons, finiteClosure);
-			urm.addUnifyResultListener(resultListener);
 			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
 			
 			Function<UnifyPair, UnifyPair> distributeInnerVars = 
@@ -417,7 +401,7 @@ public class JavaTXCompiler {
 				}
 				return ret;
 			}).collect(Collectors.toCollection(ArrayList::new));
-			unify.unifyAsync(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm);
+			unify.unifyAsync(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons, urm);
         }
     	catch (IOException e) { 
         	System.err.println("kein LogFile");
@@ -437,8 +421,8 @@ public class JavaTXCompiler {
         final ConstraintSet<Pair> cons = getConstraints();
         Set<Set<UnifyPair>> results = new HashSet<>();
         try {
-			Writer logFile = //new OutputStreamWriter(new NullOutputStream());
-				new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName()));	
+			FileWriter logFile = new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName()));
+			
 			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile);
 			System.out.println(finiteClosure);
 			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
@@ -554,10 +538,10 @@ public class JavaTXCompiler {
 			}).collect(Collectors.toCollection(ArrayList::new));
 			if (resultmodel) {
 				/* UnifyResultModel Anfang */
-				UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
+				UnifyResultModel urm = new UnifyResultModel();
 				UnifyResultListenerImpl li = new UnifyResultListenerImpl();
 				urm.addUnifyResultListener(li);
-				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm);
+				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons, urm);
 				System.out.println("RESULT Final: " + li.getResults());
 				logFile.write("RES_FINAL: " + li.getResults().toString()+"\n");
 				logFile.flush();
@@ -565,8 +549,8 @@ public class JavaTXCompiler {
 			}
 			/* UnifyResultModel End */
 			else {
-				//Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons, finiteClosure));
-				Set<Set<UnifyPair>> result = unify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons, finiteClosure));
+				Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons);
+				//Set<Set<UnifyPair>> result = unify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons);
 				System.out.println("RESULT: " + result);
 				logFile.write("RES: " + result.toString()+"\n");
 				logFile.flush();
@@ -652,7 +636,7 @@ public class JavaTXCompiler {
         return ret;
     }
     // um pfad erweitern
-    public void generateBytecode(String path) throws ClassNotFoundException, IOException, BytecodeGeneratorError {
+    public void generateBytecode(String path) throws ClassNotFoundException, IOException {
     		for(File f : sourceFiles.keySet()) {
     			HashMap<String,byte[]> classFiles = new HashMap<>();
     			SourceFile sf = sourceFiles.get(f);
@@ -660,7 +644,6 @@ public class JavaTXCompiler {
     			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult,sf,path);
 //    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult.get(0));
         		bytecodeGen.visit(sf);
-        		this.simplifyResultsSF.add(bytecodeGen.getSimplifyResultsList());
         		this.writeClassFile(bytecodeGen.getClassFiles(), path);
     		}
     }
@@ -677,8 +660,4 @@ public class JavaTXCompiler {
 			System.out.println(name+".class file generated");
 		}
 	}
-	
-	public List<List<HashMap<String, SimplifyResult>>> getSimplifyResults() {
-		return simplifyResultsSF;
-	}
 }

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

@@ -3,37 +3,31 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
-import de.dhbwstuttgart.parser.antlr.Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 public class TypeGenerator {
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.UnannClassOrInterfaceTypeContext unannClassOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
-        Java8Parser.TypeArgumentsContext arguments=null;
-        /* PL 2019-03-19 auskommentiert ANFANG
+        Java8Parser.TypeArgumentsContext arguments;
         if(unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType() != null){
             arguments = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
         }else{// if(unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType() != null){
             arguments = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
         }
-         PL 2019-03-19 auskommentiert ENDE */
         /**
          * Problem sind hier die verschachtelten Typen mit verschachtelten Typargumenten
          * Beispiel: Typ<String>.InnererTyp<Integer>
@@ -41,28 +35,6 @@ public class TypeGenerator {
         String name = unannClassOrInterfaceTypeContext.getText();
         if(name.contains("<")){
             name = name.split("<")[0]; //Der Typ ist alles vor den ersten Argumenten
-            /* Fuer Debug-Zwecke
-            unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType();
-            unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().getText();
-            //unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
-            //UnannClassType_lfno_unannClassOrInterfaceTypeContext
-            unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(0);
-            unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(0).getText();
-            unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(1);
-            unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(1).getText();
-            unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().getText();
-            //unannClassOrInterfaceTypeContext.unannInterfaceType_lf_unannClassOrInterfaceType();
-            //unannClassOrInterfaceTypeContext.unannInterfaceType_lf_unannClassOrInterfaceType(0).getText();
-            //unannClassOrInterfaceTypeContext.unannInterfaceType_lf_unannClassOrInterfaceType(1).getText();
-            //unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().getText();
-             */
-            int lastElement = new ArrayList<>(unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType()).size()-1;
-            if (lastElement >=0) {//qualifizierter Name z.B.: java.util.Vector
-            	arguments = unannClassOrInterfaceTypeContext.unannClassType_lf_unannClassOrInterfaceType(lastElement).typeArguments();
-            }
-            else { //unqualifizierter Name z.B.: Vector
-            	arguments = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
-            }
         }
         return convertTypeName(name, arguments, unannClassOrInterfaceTypeContext.getStart(), reg, generics);
     }
@@ -160,18 +132,6 @@ public class TypeGenerator {
             throw new NotImplementedException();
         }
     }
-    
-    public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.WildcardContext wildcardContext, JavaClassRegistry reg, GenericsRegistry generics) {
-        if(wildcardContext.wildcardBounds() != null){
-            if(wildcardContext.wildcardBounds().getText().substring(0, 7).equals("extends")){
-                return new ExtendsWildcardType(convert(wildcardContext.wildcardBounds().referenceType(), reg, generics), wildcardContext.getStart());
-            }else{
-            	return new SuperWildcardType(convert(wildcardContext.wildcardBounds().referenceType(), reg, generics), wildcardContext.getStart());
-            }
-        }else{
-            throw new NotImplementedException(); //Wildcard ohne Bound
-        }
-    }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convertTypeName(String name, Token offset, JavaClassRegistry reg, GenericsRegistry generics){
         return convertTypeName(name, null, offset, reg, generics);
@@ -179,17 +139,12 @@ public class TypeGenerator {
 
     public static RefTypeOrTPHOrWildcardOrGeneric convertTypeName(
             String name, Java8Parser.TypeArgumentsContext typeArguments, Token offset, JavaClassRegistry reg, GenericsRegistry generics){
-        if(!reg.contains(name)){ //Dann könnte es ein generischer Type oder ein FunN$$-Type sein
+        if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein
             if(generics.contains(name)){
                 return new GenericRefType(name, offset);
             }else{
-            Pattern p = Pattern.compile("Fun(\\d+)[$][$]");
-            Matcher m = p.matcher(name);
-            if (m.matches()) {//es ist FunN$$-Type 
-                return new RefType(new JavaClassName(name), convert(typeArguments, reg, generics), offset);
-            } else {
                 throw new TypeinferenceException("Der Typ "+ name + " ist nicht vorhanden",offset);
-            }}
+            }
         }
         if(typeArguments == null){
             List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
@@ -207,7 +162,7 @@ public class TypeGenerator {
         List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
         for(Java8Parser.TypeArgumentContext arg : typeArguments.typeArgumentList().typeArgument()){
             if(arg.wildcard() != null){
-            	ret.add(convert(arg.wildcard(), reg, generics));
+                throw new NotImplementedException();
             }else{
                 ret.add(convert(arg.referenceType(), reg, generics));
             }

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

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

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

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
 import java.io.FileWriter;
-import java.io.Writer;
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -31,7 +30,7 @@ public class UnifyTypeFactory {
 	
 	private static ArrayList<PlaceholderType> PLACEHOLDERS = new ArrayList<>(); 
 
-    public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses, Writer logFile) throws ClassNotFoundException {
+    public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses, FileWriter logFile) throws ClassNotFoundException {
         /*
         Die transitive Hülle muss funktionieren.
         Man darf schreiben List<A> extends AL<A>
@@ -68,6 +67,9 @@ public class UnifyTypeFactory {
     public static UnifyType convert(RefTypeOrTPHOrWildcardOrGeneric t, Boolean innerType){
         if(t instanceof GenericRefType){
             return UnifyTypeFactory.convert((GenericRefType)t, innerType);
+        }else
+        if(t instanceof FunN){
+            return UnifyTypeFactory.convert((FunN)t, innerType);
         }else if(t instanceof TypePlaceholder){
             return UnifyTypeFactory.convert((TypePlaceholder)t, innerType);
         }else if(t instanceof ExtendsWildcardType){
@@ -83,13 +85,13 @@ public class UnifyTypeFactory {
 
     public static UnifyType convert(RefType t, Boolean innerType){
         //Check if it is a FunN Type:
-        Pattern p = Pattern.compile("Fun(\\d+)[$][$]");
+        Pattern p = Pattern.compile("Fun(\\d+)");
         Matcher m = p.matcher(t.getName().toString());
         boolean b = m.matches();
         if(b){
             Integer N = Integer.valueOf(m.group(1));
             if((N + 1) == t.getParaList().size()){
-                return convertFunN(t.getParaList(), false);
+                return convert(new FunN(t.getParaList()), false);
             }
         }
         UnifyType ret;
@@ -100,16 +102,16 @@ public class UnifyTypeFactory {
             }
             ret = new ReferenceType(t.getName().toString(),new TypeParams(params));
         }else{
-            ret = new ReferenceType(t.getName().toString(), false);
+            ret = new ReferenceType(t.getName().toString());
         }
         return ret;
     }
 
-    public static UnifyType convertFunN(List<RefTypeOrTPHOrWildcardOrGeneric> paraList, Boolean innerType){
+    public static UnifyType convert(FunN t, Boolean innerType){
         UnifyType ret;
         List<UnifyType> params = new ArrayList<>();
-        if(paraList != null && paraList.size() > 0){
-            for(RefTypeOrTPHOrWildcardOrGeneric pT : paraList){
+        if(t.getParaList() != null && t.getParaList().size() > 0){
+            for(RefTypeOrTPHOrWildcardOrGeneric pT : t.getParaList()){
                 params.add(UnifyTypeFactory.convert(pT, false));
             }
         }
@@ -136,7 +138,7 @@ public class UnifyTypeFactory {
     }
 
     public static UnifyType convert(GenericRefType t, Boolean innerType){
-        return new ReferenceType(t.getParsedName(), true);
+        return new ReferenceType(t.getParsedName());
     }
 
     public static UnifyType convert(WildcardType t, Boolean innerType){
@@ -222,21 +224,18 @@ public class UnifyTypeFactory {
                 return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, (RefType) tr);
             }else if(tr instanceof WildcardType){
                 return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, (WildcardType) tr);
-            }else if(tr instanceof GenericRefType){
-                return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, (GenericRefType) tr);
             }else throw new NotImplementedException();
         }else throw new NotImplementedException();
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs) {
         if(JavaClassName.Void.equals(t.getName()))return new Void(new NullToken());
-        if (t.isGenTypeVar()) return new GenericRefType(t.getName(),new NullToken());
         RefType ret = new RefType(new JavaClassName(t.getName()),convert(t.getTypeParams(), tphs),new NullToken());
         return ret;
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(FunNType t, Map<String,TypePlaceholder> tphs) {
-        RefType ret = new RefType(new JavaClassName(t.getName()), convert(t.getTypeParams(), tphs), new NullToken());
+        RefType ret = new RefType(new JavaClassName(t.getName()+"$$"), convert(t.getTypeParams(), tphs), new NullToken());
         return ret;
     }
 

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

@@ -0,0 +1,41 @@
+package de.dhbwstuttgart.syntaxtree.type;
+
+
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+
+import java.util.List;
+
+/**
+ * @see Spezifikation "Complete Typeinference in Java 8" von Martin Plümicke
+ * "interface FunN<R,T1, T2, ... ,TN> { R apply(T1 arg1, T2 arg2, ... , TN argN); }"
+ * @author A10023 - Andreas Stadelmeier
+ * 
+ * Bemerkung:
+ * FunN ist ein RefType. Der RefType ist nicht mit einem FunNInterface verbunden.
+ * 
+ */
+public class FunN extends RefType {
+	/**
+	 * @author Andreas Stadelmeier,  a10023
+	 * Benötigt für den Typinferenzalgorithmus für Java 8
+	 * Generiert einen RefType auf eine FunN<R,T1,...,TN> - Klasse.
+	 * @param params
+	 * @return
+	 */
+	public FunN(List<RefTypeOrTPHOrWildcardOrGeneric> params) {
+		super(new JavaClassName("Fun"+(params.size()-1)), params, new NullToken());
+	}
+
+	/**
+	 * Spezieller Konstruktor um eine FunN ohne Returntype zu generieren
+	 
+	protected FunN(List<? extends Type> list){
+		super("",0);
+		if(list==null)throw new NullPointerException();
+		setT(list);
+		this.name = new JavaClassName("Fun"+list.size());//getName();
+	}
+	*/
+
+}

src/main/java/de/dhbwstuttgart/typedeployment/TypeInsert.java

@@ -1,6 +1,9 @@
 package de.dhbwstuttgart.typedeployment;
 
+import org.antlr.v4.runtime.Token;
+
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 

src/main/java/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java

@@ -32,7 +32,7 @@ public class TypeInsertFactory {
         ResolvedType resolvedType = resultSet.resolveType(type);
         TypeInsertPoint insertPoint = new TypeInsertPoint(offset,
                     new TypeToInsertString(resolvedType.resolvedType).insert);
-        return new TypeInsert(insertPoint, new HashSet<>());
+        return new TypeInsert(insertPoint, new HashSet<>(Arrays.asList(createGenericInsert(resolvedType.additionalGenerics, cl, m))));
     }
 
     private static TypeInsertPoint createGenericInsert(Set<GenericInsertPair> toInsert, ClassOrInterface cl, Method m){

src/main/java/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java

@@ -8,7 +8,7 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 public class TypeInsertPoint {
-    public Token point;
+    public final Token point;
     private String insertString;
 
     public TypeInsertPoint(Token point, String toInsert){
@@ -28,14 +28,6 @@ public class TypeInsertPoint {
         return insertString;
     }
     
-    public Token getToken() {
-    	return this.point;
-    }
-    
-    public void setToken(Token point) {
-    	this.point = point;
-    }
-    
     /* PL 2018-06-19
      * Zwei TypeInsertPoint's sind gleich, wenn ihre point's gleich sind 
      * eingefuegt damit man TypeReplaceMarker vergleichen kann

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

@@ -21,7 +21,7 @@ import java.util.Optional;
 
 public class FunNClass extends ClassOrInterface {
     public FunNClass(List<GenericRefType> funNParams) {
-        super(0, new JavaClassName("Fun"+(funNParams.size()-1)), new ArrayList<>(), Optional.empty() /* eingefuegt PL 2018-11-24 */,
+        super(0, new JavaClassName("Fun"+(funNParams.size())), new ArrayList<>(), Optional.empty() /* eingefuegt PL 2018-11-24 */,
                 createMethods(funNParams), new ArrayList<>(), createGenerics(funNParams),
                 ASTFactory.createObjectType(), true, new ArrayList<>(), new NullToken());
 

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

@@ -1,10 +1,10 @@
 package de.dhbwstuttgart.typeinference.assumptions;
 
 import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.TypeScope;
+import de.dhbwstuttgart.syntaxtree.type.FunN;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
@@ -63,7 +63,7 @@ public class MethodAssumption extends Assumption{
         }
         RefTypeOrTPHOrWildcardOrGeneric receiverType;
         if(receiver instanceof FunNClass){
-            receiverType = new RefType(new JavaClassName(receiver.getClassName().toString()+"$$"), params, new NullToken()); // new FunN(params);
+            receiverType = new FunN(params);
         }else{
             receiverType = new RefType(receiver.getClassName(), params, new NullToken());
         }

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

@@ -23,9 +23,4 @@ public class GenericInsertPair  {
         if(TA2.equals(additionalTPH))return true;
         return false;
     }
-    
-    @Override
-    public String toString() {
-    	return "GenIns(" + TA1.toString() + " < " + TA2.toString() + ")";
-    }
 }

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

@@ -21,9 +21,4 @@ public class PairTPHequalRefTypeOrWildcardType extends ResultPair{
     public void accept(ResultPairVisitor visitor) {
         visitor.visit(this);
     }
-    
-    @Override
-    public String toString() {
-    	return "(" + left.toString() + " = " + right.toString() + ")";
-    }
 }

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

@@ -20,9 +20,4 @@ public class PairTPHsmallerTPH extends ResultPair{
     public void accept(ResultPairVisitor visitor) {
         visitor.visit(this);
     }
-    
-    @Override
-    public String toString() {
-    	return "(" + left.toString() + " < " + right.toString() + ")";
-    }
 }

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

@@ -8,10 +8,10 @@ import java.util.Set;
 
 public class ResolvedType{
     public final RefTypeOrTPHOrWildcardOrGeneric resolvedType;
-    //public final Set<GenericInsertPair> additionalGenerics;
+    public final Set<GenericInsertPair> additionalGenerics;
 
     public ResolvedType(RefTypeOrTPHOrWildcardOrGeneric resolvedType, Set<GenericInsertPair> additionalGenerics){
         this.resolvedType = resolvedType;
-        //this.additionalGenerics = additionalGenerics;
+        this.additionalGenerics = additionalGenerics;
     }
 }

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

@@ -6,16 +6,11 @@ import de.dhbwstuttgart.syntaxtree.type.*;
 
 import java.util.HashSet;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 public class ResultSet {
     public final Set<ResultPair> results;
-    public Set<ResultPair<TypePlaceholder, TypePlaceholder>> genIns;
     public ResultSet(Set<ResultPair> results){
         this.results = results;
-        this.genIns =  results.stream().filter(a -> a instanceof PairTPHsmallerTPH)
-				              //.map(b -> new GenericInsertPair( (TypePlaceholder)(b.getLeft()), (TypePlaceholder)(b.getRight())))
-				              .collect(Collectors.toCollection(HashSet::new));
     }
 
     public ResolvedType resolveType(RefTypeOrTPHOrWildcardOrGeneric type) {

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

@@ -65,9 +65,7 @@ public class TYPEStmt implements StatementVisitor{
         //lambdaParams.add(0,tphRetType);
         constraintsSet.addUndConstraint(
                 new Pair(lambdaExpression.getType(),
-                		new RefType(new JavaClassName("Fun"+(lambdaParams.size()-1)+"$$"), lambdaParams, new NullToken()),
-                        //new FunN(lambdaParams),
-                        PairOperator.EQUALSDOT));
+                        new FunN(lambdaParams),PairOperator.EQUALSDOT));
         constraintsSet.addUndConstraint(
                 new Pair(lambdaExpression.getReturnType(),
                         tphRetType,PairOperator.EQUALSDOT));

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

@@ -0,0 +1,132 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.Vector;
+
+import com.google.common.collect.Ordering;
+
+public class PartialOrderSet<E, F extends Ordering<E>> implements Set<E> {
+
+	//HashSet<E> hs = new HashSet<>();
+	List<E> ve = new LinkedList<>();//new Vector<>();
+	F ordering;
+	
+	PartialOrderSet(F ordering) {
+		this.ordering= ordering;
+	}
+
+	PartialOrderSet(F ordering, Set<E> s) {
+		this.ordering= ordering;
+		this.addAll(s);
+	}
+	
+	PartialOrderSet(PartialOrderSet<E, F> pos) {
+		this.ordering= pos.ordering;
+		this.ve = new LinkedList<>(pos.ve);
+	}
+	
+	@Override
+	public int size() {
+		return ve.size();
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return ve.isEmpty();
+	}
+
+	@Override
+	public boolean contains(Object o) {
+		return ve.contains(o);
+	}
+
+	@Override
+	public Iterator<E> iterator() {
+		return ve.iterator();
+	}
+
+	@Override
+	public Object[] toArray() {
+		return ve.toArray();
+	}
+
+	@Override
+	public <T> T[] toArray(T[] a) {
+		return ve.toArray(a);
+	}
+
+	public ArrayList<E> toArrayList() {
+		return new ArrayList<>(ve);
+	}
+	
+	public List<E> toList() {
+		return new LinkedList<>(ve);
+	}
+	
+	@Override
+	public boolean add(E e) {
+		if (this.contains(e)) {
+			return false;
+		}
+		//hs.add(e);
+		for(int i = 0; i< ve.size(); i++) { 
+			if (ordering.compare(e, ve.get(i)) == -1) {
+				ve.add(i,e);
+				return true;
+			}
+		}
+		ve.add(e);
+		return true;
+	}
+
+	@Override
+	public boolean remove(Object o) {
+		//hs.remove(o);
+		return ve.remove(o);
+	}
+
+	@Override
+	public boolean containsAll(Collection<?> c) {
+		return ve.containsAll(c);
+	}
+
+	@Override
+	public boolean addAll(Collection<? extends E> c) {
+		Boolean ret = false;
+		Iterator<? extends E> cit = c.iterator(); 
+		while(cit.hasNext()) {
+			Boolean retnew = this.add(cit.next());
+			ret = ret || retnew;
+		}
+		return ret;
+	}
+
+	@Override
+	public boolean retainAll(Collection<?> c) {
+		//hs.retainAll(c);
+		return ve.retainAll(c);
+	}
+
+	@Override
+	public boolean removeAll(Collection<?> c) {
+		//hs.removeAll(c);
+		return ve.removeAll(c);
+	}
+
+	@Override
+	public void clear() {
+		//hs.clear();
+		ve.clear();
+	}
+	
+	@Override
+	public String toString() {
+		return ve.toString();
+	}
+}

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

@@ -4,12 +4,10 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
-import java.util.List;
 import java.util.Optional;
 import java.util.Queue;
 import java.util.Set;
 import java.util.Stack;
-import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import de.dhbwstuttgart.exceptions.DebugException;
@@ -30,7 +28,6 @@ import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 
 import java.io.FileWriter;
 import java.io.IOException;
-import java.io.Writer;
 
 /**
  * Implementation of the type inference rules.
@@ -39,13 +36,13 @@ import java.io.Writer;
  */
 public class RuleSet implements IRuleSet{
 	
-	Writer logFile;
+	FileWriter logFile;
 	
 	public RuleSet() {
 		super();
 	}
 	
-	RuleSet(Writer logFile) {
+	RuleSet(FileWriter logFile) {
 		this.logFile = logFile;
 	}
 	
@@ -622,12 +619,8 @@ public class RuleSet implements IRuleSet{
 		return succ ? permutation : new int[0];
 	}
 
-	public Optional<Set<UnifyPair>> subst(Set<UnifyPair> pairs) {
-		return subst(pairs, new ArrayList<>());
-	}
-	
 	@Override
-	public Optional<Set<UnifyPair>> subst(Set<UnifyPair> pairs, List<Set<Set<UnifyPair>>> oderConstraints) {
+	public Optional<Set<UnifyPair>> subst(Set<UnifyPair> pairs) {
 		HashMap<UnifyType, Integer> typeMap = new HashMap<>();
 		
 		Stack<UnifyType> occuringTypes = new Stack<>();
@@ -667,35 +660,13 @@ public class RuleSet implements IRuleSet{
 			if(lhsType != null 
 					//&& !((rhsType = pair.getRhsType()) instanceof PlaceholderType) //PL geloescht am 2017-09-29 Begründung: auch Typvariablen muessen ersetzt werden.
 					&& typeMap.get(lhsType) > 1  // The type occurs in more pairs in the set than just the recent pair.
-					&& !rhsType.getTypeParams().occurs(lhsType) 
-					&& !((rhsType instanceof WildcardType) && ((WildcardType)rhsType).getWildcardedType().equals(lhsType))) //PL eigefuegt 2018-02-18
-			{
+					&& !rhsType.getTypeParams().occurs(lhsType)) {
 				Unifier uni = new Unifier(lhsType,  rhsType);
 				result = result.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(ArrayList::new));
 				result1 = result1.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(LinkedList::new));
-				
-				Function<? super Set<UnifyPair>,? extends HashSet<UnifyPair>> applyUni = b -> b.stream().map(
-						x -> uni.apply(pair,x)).collect(Collectors.toCollection(HashSet::new));
-				List<Set<Set<UnifyPair>>> oderConstraintsRet = new ArrayList<>();
-				for(Set<Set<UnifyPair>> oc : oderConstraints) {
-					//Set<Set<UnifyPair>> ocRet = new HashSet<>();
-					//for(Set<UnifyPair> cs : oc) {
-						Set<Set<UnifyPair>> csRet = oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new));
-						oderConstraintsRet.add(csRet);
-					//}
-				}
-				oderConstraints.replaceAll(oc -> oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new)));
-				/*
-						oderConstraints = oderConstraints.stream().map(
-						a -> a.stream().map(applyUni
-								//b -> b.stream().map(
-								//		x -> uni.apply(pair,x)).collect(Collectors.toCollection(HashSet::new) )
-								).collect(Collectors.toCollection(HashSet::new))
-						).collect(Collectors.toList(ArrayList::new));
-				}
-				*/
 				applied = true;
 			}
+			
 			result.add(pair);
 		}
 		
@@ -974,8 +945,6 @@ public class RuleSet implements IRuleSet{
 		
 		UnifyType extendedType = ((ExtendsType)lhsType).getExtendedType();
 		
-		if (extendedType.equals(rhsType)) return Optional.empty(); //PL 2019-02-18 eingefügt ? extends a <.? a
-		
 		boolean isGen = extendedType instanceof PlaceholderType && !((PlaceholderType) extendedType).isGenerated();
 		
 		Set<UnifyPair> result = new HashSet<>();
@@ -1002,8 +971,6 @@ public class RuleSet implements IRuleSet{
 		
 		UnifyType superedType = ((SuperType)lhsType).getSuperedType();
 		
-		if (superedType.equals(rhsType)) return Optional.empty(); //PL 2019-02-18 eingefügt ? super a <.? a
-		
 		boolean isGen = superedType instanceof PlaceholderType && !((PlaceholderType) superedType).isGenerated();
 		
 		Set<UnifyPair> result = new HashSet<>();

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

@@ -1,87 +1,47 @@
 package de.dhbwstuttgart.typeinference.unify;
 
 import java.io.FileWriter;
-import java.io.IOException;
-import java.io.Writer;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ForkJoinPool;
+import java.util.stream.Collectors;
 
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.OrderingUnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 public class TypeUnify {
-	
-	/**
-	 * unify parallel ohne result modell
-	 * @param undConstrains
-	 * @param oderConstraints
-	 * @param fc
-	 * @param logFile
-	 * @param log
-	 * @param cons
-	 * @return
-	 */
-	public Set<Set<UnifyPair>> unify(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret);
+	public Set<Set<UnifyPair>> unify(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, FileWriter logFile, Boolean log, ConstraintSet<Pair> cons) {
+		List<PartialOrderSet<Set<UnifyPair>,OrderingUnifyPair>> oderConstraintsPartial = 
+				oderConstraints.stream().map(x -> new PartialOrderSet<Set<UnifyPair>,OrderingUnifyPair>(new OrderingUnifyPair(fc),x)).collect(Collectors.toList());
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraintsPartial, fc, true, logFile, log, 0, new UnifyResultModel(), cons);
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		Set<Set<UnifyPair>> res =  unifyTask.join();
-		try {
-			logFile.write("\nnoShortendElements: " + unifyTask.noShortendElements + "\n");
-			logFile.flush();
-		}
-		catch (IOException e) {
-			System.err.println("no log-File");
-		}
 		return res;
 	}
 	
-	/**
-	 * unify asynchron mit Rückgabe UnifyResultModel ohne dass alle results gesammelt sind
-	 * @param undConstrains
-	 * @param oderConstraints
-	 * @param fc
-	 * @param logFile
-	 * @param log
-	 * @param cons
-	 * @param ret
-	 * @return
-	 */
-	public UnifyResultModel unifyAsync(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret);
+	public UnifyResultModel unifyAsync(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, FileWriter logFile, Boolean log, ConstraintSet<Pair> cons, UnifyResultModel ret) {
+		List<PartialOrderSet<Set<UnifyPair>,OrderingUnifyPair>> oderConstraintsPartial = 
+				oderConstraints.stream().map(x -> new PartialOrderSet<Set<UnifyPair>,OrderingUnifyPair>(new OrderingUnifyPair(fc),x)).collect(Collectors.toList());
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraintsPartial, fc, true, logFile, log, 0, ret, cons);
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		return ret;
 	}
 	
-	/**
-	 * unify parallel mit Rückgabe UnifyResultModel nachdem alle results gesammelt sind
-	 * @param undConstrains
-	 * @param oderConstraints
-	 * @param fc
-	 * @param logFile
-	 * @param log
-	 * @param cons
-	 * @param ret
-	 * @return
-	 */
-	public UnifyResultModel unifyParallel(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret);
+	public UnifyResultModel unifyParallel(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, FileWriter logFile, Boolean log, ConstraintSet<Pair> cons, UnifyResultModel ret) {
+		List<PartialOrderSet<Set<UnifyPair>,OrderingUnifyPair>> oderConstraintsPartial = 
+				oderConstraints.stream().map(x -> new PartialOrderSet<Set<UnifyPair>,OrderingUnifyPair>(new OrderingUnifyPair(fc),x)).collect(Collectors.toList());
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraintsPartial, fc, true, logFile, log, 0, ret, cons);
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		Set<Set<UnifyPair>> res =  unifyTask.join();
-		try {
-			logFile.write("\nnoShortendElements: " + unifyTask.noShortendElements +"\n");
-			logFile.flush();
-		}
-		catch (IOException e) {
-			System.err.println("no log-File");
-		}
 		return ret;
 	}
 	
@@ -93,26 +53,11 @@ public class TypeUnify {
 	}
 	*/
 	
-	/**
-	 * unify sequentiell mit oderconstraints
-	 * @param undConstrains
-	 * @param oderConstraints
-	 * @param fc
-	 * @param logFile
-	 * @param log
-	 * @param cons
-	 * @return
-	 */
-	public Set<Set<UnifyPair>> unifyOderConstraints(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, false, logFile, log, 0, ret);
+	public Set<Set<UnifyPair>> unifyOderConstraints(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, FileWriter logFile, Boolean log, ConstraintSet<Pair> cons) {
+		List<PartialOrderSet<Set<UnifyPair>,OrderingUnifyPair>> oderConstraintsPartial = 
+				oderConstraints.stream().map(x -> new PartialOrderSet<Set<UnifyPair>,OrderingUnifyPair>(new OrderingUnifyPair(fc),x)).collect(Collectors.toList());
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraintsPartial, fc, false, logFile, log, 0, new UnifyResultModel(), cons);
 		Set<Set<UnifyPair>> res = unifyTask.compute();
-		try {
-			logFile.write("\nnoShortendElements: " + unifyTask.noShortendElements +"\n");
-			logFile.flush();
-		}
-		catch (IOException e) {
-			System.err.println("no log-File");
-		}
 		return res;
 	}
 

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

@@ -1,8 +1,6 @@
 package de.dhbwstuttgart.typeinference.unify;
 
 import java.io.FileWriter;
-import java.io.IOException;
-import java.io.Writer;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -11,14 +9,15 @@ import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.OrderingUnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 public class TypeUnify2Task extends TypeUnifyTask {
        
        Set<Set<UnifyPair>> setToFlatten;
 
-       public TypeUnify2Task(Set<Set<UnifyPair>> setToFlatten, Set<UnifyPair> eq, List<Set<Set<UnifyPair>>> oderConstraints, Set<UnifyPair> nextSetElement, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm) {
-               super(eq, oderConstraints, fc, parallel, logFile, log, rekTiefe, urm);
+       public TypeUnify2Task(Set<Set<UnifyPair>> setToFlatten, Set<UnifyPair> eq, List<PartialOrderSet<Set<UnifyPair>,OrderingUnifyPair>> oderConstraints, Set<UnifyPair> nextSetElement, IFiniteClosure fc, boolean parallel, FileWriter logFile, Boolean log, int rekTiefe, UnifyResultModel urm, ConstraintSet<Pair> cons) {
+               super(eq, oderConstraints, fc, parallel, logFile, log, rekTiefe, urm, cons);
                this.setToFlatten = setToFlatten;
                this.nextSetElement = nextSetElement;
        }
@@ -33,23 +32,12 @@ public class TypeUnify2Task extends TypeUnifyTask {
                        System.out.println("two");
                }
                one = true;
-               Set<Set<UnifyPair>> res = unify2(setToFlatten, eq, oderConstraintsField, fc, parallel, rekTiefeField, true);
+               Set<Set<UnifyPair>> res = unify2(setToFlatten, eq, oderConstraintsField, fc, parallel, rekTiefeField);
                /*if (isUndefinedPairSetSet(res)) { 
                        return new HashSet<>(); }
                else
                */ 
                noOfThread--;
-               return res;
-       }
-       
-       public void closeLogFile() {
-
-           try {
-				logFile.close();
-			}
-			catch (IOException ioE) {
-				System.err.println("no log-File" + thNo);
-			}
-           
+                       return res;
        }
 }

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

@@ -1,31 +1,13 @@
 package de.dhbwstuttgart.typeinference.unify;
 
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Optional;
 import java.util.Set;
-import java.util.stream.Collectors;
 
-import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
-import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
-import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 public class UnifyResultModel {
 	
-	ConstraintSet<de.dhbwstuttgart.typeinference.constraints.Pair> cons;
-	
-	IFiniteClosure fc;
-	
-	public UnifyResultModel(ConstraintSet<de.dhbwstuttgart.typeinference.constraints.Pair> cons,
-					 IFiniteClosure fc) {
-		this.cons = cons;
-		this.fc = fc;
-	}
-	
 	private List<UnifyResultListener> listeners = new ArrayList<>();
 	
 	public void addUnifyResultListener(UnifyResultListener listenerToAdd) {
@@ -36,20 +18,7 @@ public class UnifyResultModel {
 		listeners.remove(listenerToRemove);
 	}
 	
-	public void notify(Set<Set<UnifyPair>> eqPrimePrimeSet) {
-		Set<Set<UnifyPair>> eqPrimePrimeSetRet = eqPrimePrimeSet.stream().map(x -> {
-			Optional<Set<UnifyPair>> res = new RuleSet().subst(x.stream().map(y -> { 
-				if (y.getPairOp() == PairOperator.SMALLERDOTWC) y.setPairOp(PairOperator.EQUALSDOT);
-				return y; //alle Paare a <.? b erden durch a =. b ersetzt
-			}).collect(Collectors.toCollection(HashSet::new)));
-			if (res.isPresent()) {//wenn subst ein Erg liefert wurde was veraendert
-				return new TypeUnifyTask().applyTypeUnificationRules(res.get(), fc);
-			}
-			else return x; //wenn nichts veraendert wurde wird x zurueckgegeben
-		}).collect(Collectors.toCollection(HashSet::new));
-		List<ResultSet> newResult = eqPrimePrimeSetRet.stream().map(unifyPairs ->
-           new ResultSet(UnifyTypeFactory.convert(unifyPairs, de.dhbwstuttgart.typeinference.constraints.Pair.generateTPHMap(cons))))
-           .collect(Collectors.toList());
+	public void notify(List<ResultSet> newResult) {
 		UnifyResultEvent evt = new UnifyResultEvent(newResult);
 		
 		for (UnifyResultListener listener : listeners) {

src/main/java/de/dhbwstuttgart/typeinference/unify/interfaces/IRuleSet.java

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.typeinference.unify.interfaces;
 
-import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 
@@ -86,13 +85,6 @@ public interface IRuleSet {
 	public Optional<UnifyPair> adaptExt(UnifyPair pair, IFiniteClosure fc);
 	public Optional<UnifyPair> adaptSup(UnifyPair pair, IFiniteClosure fc);
 	
-	/**
-	 * Applies the subst-Rule to a set of pairs (usually Eq').
-	 * @param pairs The set of pairs where the subst rule should apply.
-	 * @return An optional of the modified set, if there were any substitutions. An empty optional if there were no substitutions.
-	 */
-	public Optional<Set<UnifyPair>> subst(Set<UnifyPair> pairs, List<Set<Set<UnifyPair>>> oderConstraints);
-	
 	/**
 	 * Applies the subst-Rule to a set of pairs (usually Eq').
 	 * @param pairs The set of pairs where the subst rule should apply.

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

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.typeinference.unify.model;
 
 import java.io.FileWriter;
 import java.io.IOException;
-import java.io.Writer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -13,7 +12,6 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
-import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import com.google.common.collect.Ordering;
@@ -34,7 +32,7 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.IUnify;
 public class FiniteClosure //extends Ordering<UnifyType> //entfernt PL 2018-12-11
 implements IFiniteClosure  {
 
-	Writer logFile;
+	FileWriter logFile;
 	static Boolean log = false;
 	public void setLogTrue() {
 		log = true;
@@ -68,7 +66,7 @@ implements IFiniteClosure  {
 	/**
 	 * Creates a new instance using the inheritance tree defined in the pairs.
 	 */
-	public FiniteClosure(Set<UnifyPair> pairs, Writer logFile) {
+	public FiniteClosure(Set<UnifyPair> pairs, FileWriter logFile) {
 		this.logFile = logFile;
 		this.pairs = new HashSet<>(pairs);
 		inheritanceGraph = new HashMap<UnifyType, Node<UnifyType>>();
@@ -658,16 +656,11 @@ implements IFiniteClosure  {
 		if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
 			System.out.println("");
 		/*
-		pairop = PairOperator.SMALLERDOTWC;
 		List<UnifyType> al = new ArrayList<>();
 		PlaceholderType xx =new PlaceholderType("xx");
 		al.add(xx);
 		left = new ExtendsType(new ReferenceType("Vector", new TypeParams(al)));
-		
-		List<UnifyType> alr = new ArrayList<>();
-		UnifyType exx = new ExtendsType(xx);
-		alr.add(exx);
-		right = new ExtendsType(new ReferenceType("Vector", new TypeParams(alr)));
+		right = new ReferenceType("Vector", new TypeParams(new ArrayList<>(al)));
 		*/
 		/*
 		List<UnifyType> al = new ArrayList<>();
@@ -718,13 +711,8 @@ implements IFiniteClosure  {
 		}
 		catch (IOException e) {
 			System.err.println("no LogFile");}}
-		//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok.
-		Predicate<UnifyPair> delFun = x -> !((x.getLhsType() instanceof PlaceholderType || 
-											 x.getRhsType() instanceof PlaceholderType)
-								 			 && !((x.getLhsType() instanceof WildcardType) &&   //? extends/super a <.? a 
-													 ((WildcardType)x.getLhsType()).getWildcardedType().equals(x.getRhsType()))
-											 );
-		long smallerLen = smallerRes.stream().filter(delFun).count();
+		//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok. 
+		long smallerLen = smallerRes.stream().filter(x -> !(x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType)).count();
 		if (smallerLen == 0) return -1;
 		else {
 			up = new UnifyPair(right, left, pairop);
@@ -740,7 +728,7 @@ implements IFiniteClosure  {
 			catch (IOException e) {
 				System.err.println("no LogFile");}}
 			//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok. 
-			long greaterLen = greaterRes.stream().filter(delFun).count();
+			long greaterLen = greaterRes.stream().filter(x -> !(x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType)).count();
 			if (greaterLen == 0) return 1;
 			else return 0;
 		}	

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

@@ -22,7 +22,7 @@ public class FunNType extends UnifyType {
 	 * Creates a FunN-Type with the specified TypeParameters.
 	 */
 	protected FunNType(TypeParams p) {
-		super("Fun"+(p.size()-1)+"$$", p);
+		super("Fun"+(p.size()-1), p);
 	}
 
 	/**

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

@@ -1,11 +1,9 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
-import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.BinaryOperator;
@@ -32,25 +30,14 @@ public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
 	 * in dem compare(Theta, Theta') aufgerufen wird.
 	 */
 	public int compareEq (UnifyPair left, UnifyPair right) {
-		try {
 		//if (left.getRhsType() instanceof WildcardType || right.getRhsType() instanceof WildcardType) {//PL 2019-01-12 ausgetauscht
 		if (((PlaceholderType)left.getLhsType()).isInnerType() && ((PlaceholderType)right.getLhsType()).isInnerType()) {
 			return fc.compare(left.getRhsType(), right.getRhsType(), PairOperator.SMALLERDOTWC);
 		}
 			else	 {
 				return fc.compare(left.getRhsType(), right.getRhsType(), PairOperator.SMALLERDOT);
-		}}
-		catch (ClassCastException e) {
-			try {
-			((FiniteClosure)fc).logFile.write("ClassCastException: " + left.toString() +"\n\n");
-			((FiniteClosure)fc).logFile.flush();
-			}
-			catch (IOException ie) {
-			}
-			return -99;
 		}
 	}
-	
 	/*
 	public int compareEq (UnifyPair left, UnifyPair right) {
 		if (left == null || right == null)
@@ -128,43 +115,6 @@ public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
 	 * @see com.google.common.collect.Ordering#compare(java.lang.Object, java.lang.Object)
 	 */
 	public int compare (Set<UnifyPair> left, Set<UnifyPair> right) {
-		/*
-		//pairop = PairOperator.SMALLERDOTWC;
-		List<UnifyType> al = new ArrayList<>();
-		PlaceholderType xx = PlaceholderType.freshPlaceholder();
-		al.add(xx);
-		UnifyType t1 = new ExtendsType(new ReferenceType("Vector", new TypeParams(al)));
-		
-		//PlaceholderType yy =new PlaceholderType("yy");
-		List<UnifyType> alr = new ArrayList<>();
-		UnifyType exx = new ExtendsType(xx);
-		alr.add(exx);
-		UnifyType t2 = new ExtendsType(new ReferenceType("Vector", new TypeParams(alr)));
-		
-		PlaceholderType a = PlaceholderType.freshPlaceholder();
-		a.setInnerType(true);
-		UnifyPair p1 = new UnifyPair(a, t1, PairOperator.SMALLERDOTWC); 
-		PlaceholderType b = PlaceholderType.freshPlaceholder();
-		b.setInnerType(true);
-		UnifyPair p2 = new UnifyPair(b, t2, PairOperator.SMALLERDOTWC);
-		
-		List<UnifyType> al3 = new ArrayList<>();
-		al3.add(a);
-		
-		List<UnifyType> al4 = new ArrayList<>();
-		al4.add(b);
-		
-		UnifyPair p3 = new UnifyPair(new PlaceholderType("c"), new ReferenceType("Vector", new TypeParams(al3)), PairOperator.EQUALSDOT);
-		UnifyPair p4 = new UnifyPair(new PlaceholderType("c"), new ReferenceType("Vector", new TypeParams(al4)), PairOperator.EQUALSDOT);
-		
-		right = new HashSet<>();
-		right.add(p1);
-		right.add(p3);
-		left = new HashSet<>();
-		left.add(p2);
-		left.add(p4);
-		*/
-		
 		if ((left.size() == 1) && right.size() == 1) { 
 			if (left.iterator().next().getLhsType().getName().equals("AFS")) {
 				System.out.println("");
@@ -248,9 +198,9 @@ public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
 			//Set<PlaceholderType> varsleft = lefteq.stream().map(x -> (PlaceholderType)x.getLhsType()).collect(Collectors.toCollection(HashSet::new));
 			//Set<PlaceholderType> varsright = righteq.stream().map(x -> (PlaceholderType)x.getLhsType()).collect(Collectors.toCollection(HashSet::new));
 			//filtern des Paares a = Theta, das durch a <. Thata' generiert wurde (nur im Fall 1 relevant)  andere Substitutioen werden rausgefiltert
-			lefteq.removeIf(x -> (x.getBasePair()!=null) && !(x.getLhsType().getName().equals(x.getBasePair().getLhsType().getName())
+			lefteq.removeIf(x -> !(x.getLhsType().getName().equals(x.getBasePair().getLhsType().getName())
 					              ||x.getLhsType().getName().equals(x.getBasePair().getRhsType().getName())));//removeIf(x -> !varsright.contains(x.getLhsType()));
-			righteq.removeIf(x -> (x.getBasePair()!=null) && !(x.getLhsType().getName().equals(x.getBasePair().getLhsType().getName())
+			righteq.removeIf(x -> !(x.getLhsType().getName().equals(x.getBasePair().getLhsType().getName())
 		              	           ||x.getLhsType().getName().equals(x.getBasePair().getRhsType().getName())));//.removeIf(x -> !varsleft.contains(x.getLhsType()));
 			UnifyPair lseq = lefteq.iterator().next();
 			UnifyPair rseq = righteq.iterator().next();

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

@@ -11,45 +11,28 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
  * @author Florian Steurer
  *
  */
-public class ReferenceType extends UnifyType {
+public final class ReferenceType extends UnifyType {
 	
 	/**
 	 * The buffered hashCode
 	 */
 	private final int hashCode;
 	
-	/**
-	 * gibt an, ob der ReferenceType eine generische Typvariable ist
-	 */
-	private final boolean genericTypeVar;
-	
 
 	public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht) {
 		return visitor.visit(this, ht);
 	}
 	
-	public ReferenceType(String name, Boolean genericTypeVar) {
-		super(name, new TypeParams());
-		hashCode = 31 + 17 * typeName.hashCode() + 17 * typeParams.hashCode();
-		this.genericTypeVar = genericTypeVar;
-	}
-	
 	public ReferenceType(String name, UnifyType... params) {
 		super(name, new TypeParams(params));
 		hashCode = 31 + 17 * typeName.hashCode() + 17 * typeParams.hashCode();
-		genericTypeVar = false;
 	}
 	
 	public ReferenceType(String name, TypeParams params) {
 		super(name, params);
 		hashCode = 31 + 17 * typeName.hashCode() + 17 * typeParams.hashCode();
-		genericTypeVar = false;
 	}
 
-	public boolean isGenTypeVar () { 
-		return genericTypeVar;
-	}
-	
 	@Override
 	Set<UnifyType> smArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
 		return fc.smArg(this, fBounded);

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

@@ -177,20 +177,6 @@ public class UnifyPair {
 		}
 	}
 	
-	/**
-	 * wenn in einem  Paar bestehend aus 2 Typvariablen eine nicht wildcardtable ist,
-	 * so beide auf nicht wildcardtable setzen
-	 */
-	public void disableCondWildcards() {
-		if (lhs instanceof PlaceholderType && rhs instanceof PlaceholderType
-			&& (!((PlaceholderType)lhs).isWildcardable() || !((PlaceholderType)rhs).isWildcardable()))
-		{
-			((PlaceholderType)lhs).disableWildcardtable();
-			((PlaceholderType)rhs).disableWildcardtable();
-		}
-			
-	}
-	
 	public Boolean wrongWildcard() {
 		return lhs.wrongWildcard() || rhs.wrongWildcard();
 	}
@@ -233,12 +219,10 @@ public class UnifyPair {
 	public String toString() {
 		String ret = "";
 		if (lhs instanceof PlaceholderType) {
-			ret = new Integer(((PlaceholderType)lhs).getVariance()).toString() + " " + ((PlaceholderType)lhs).isInnerType() 
-					+ " " + ((PlaceholderType)lhs).isWildcardable();
+			ret = new Integer(((PlaceholderType)lhs).getVariance()).toString() + " " + ((PlaceholderType)lhs).isInnerType();
 		}
 		if (rhs instanceof PlaceholderType) {
-			ret = ret + ", " + new Integer(((PlaceholderType)rhs).getVariance()).toString() + " " + ((PlaceholderType)rhs).isInnerType()
-					+ " " + ((PlaceholderType)rhs).isWildcardable();
+			ret = ret + ", " + new Integer(((PlaceholderType)rhs).getVariance()).toString() + " " + ((PlaceholderType)rhs).isInnerType();
 		}
 		return "(" + lhs + " " + pairOp + " " + rhs + ", " + ret + ")"; //+ ", [" + getfBounded().toString()+ "])";
 	}

src/test/java/bytecode/ClassGenLamTest.java

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

src/test/java/bytecode/FieldTph.java

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

src/test/java/bytecode/FieldTphConsMethTest.java

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

src/test/java/bytecode/FieldTphMMethTest.java

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

src/test/java/bytecode/InfTest.java

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

src/test/java/bytecode/KompTphTest.java

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

src/test/java/bytecode/MatrixOpTest.java

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

src/test/java/bytecode/applyLambdaTest.java

@@ -1,4 +1,3 @@
-
 package bytecode;
 
 import static org.junit.Assert.assertEquals;

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

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

src/test/java/logFiles/.gitignore

@@ -0,0 +1,5 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore
+

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

@@ -1,8 +0,0 @@
-import java.lang.Integer;
-
-public class ClassGenLam {
-	lam = x-> x;
-//	public ClassGenLam() {
-//		lam = x->x; 
-//	}
-}

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

@@ -1,25 +1,22 @@
 import java.lang.Integer;
-import java.lang.Long;
-import java.lang.Short;
 
 public class Faculty {
-    public fact;  
-    Faculty() {
-        fact = (x) -> {
-            if (x == 1) {
-                return 1;
-            }
-            else {
-              return x * (fact.apply(x-1));
-            }
-        };
-    }
-    
-    
-    public getFact(x) {
-        return fact.apply(x);
-    }
-}
+	public fact;
+	Faculty() {
+		fact = (x) -> {
+			if (x == 1) {
+				return 1;
+			}
+			else {
+			  return x * (fact.apply(x-1));
+			}
+		};
+	}
+	
+	
+	public getFact(x) {
+		return fact.apply(x);
+	}
 //  m (x) {
 //	  
 ////   var fact = (x) -> {
@@ -48,4 +45,4 @@ public class Faculty {
 //		  return x * m(x-1);
 //	  }
 //  }
-
+}

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

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

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

@@ -3,5 +3,4 @@ public class Id {
 	id(b){
 		return b;
 	}
-}
-
+}

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

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

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

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

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

@@ -4,7 +4,7 @@ import java.lang.Float;
 //import java.lang.Byte;
 //import java.lang.Boolean;
 
-public class Matrix    extends Vector<Vector<Integer>> {
+public class Matrix   extends Vector<Vector<Integer>> {
    
 	Matrix () {
     }
@@ -16,10 +16,10 @@ public class Matrix    extends Vector<Vector<Integer>> {
 //	    	Boolean a = this.add(vv.elementAt(i));
 		  this.add(vv.elementAt(i));
 		  i=i+1;
-	  } 
+	  }
     }
 
-    mul(java.util.Vector<? extends Vector<? extends java.lang.Integer>> m) {
+    mul(m) {
         var ret = new Matrix();
         var i = 0;
         while(i < size()) {

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

@@ -3,7 +3,7 @@ import java.lang.Integer;
 //import java.lang.Byte;
 import java.lang.Boolean;
 
-public class MatrixOP    extends Vector<Vector<Integer>> {
+public class MatrixOP extends Vector<Vector<Integer>> {
    
 	MatrixOP () {
     }
@@ -18,10 +18,10 @@ public class MatrixOP    extends Vector<Vector<Integer>> {
 	  }
     }
 
-	public Fun2$$<java.util.Vector<? extends java.util.Vector<? extends java.lang.Integer>>, java.util.Vector<? extends java.util.Vector<? extends java.lang.Integer>>, MatrixOP> mul = (m1, m2) -> {
+	mul = (m1, m2) -> {
         var ret = new MatrixOP();
         var i = 0;
-        while(i < m1.size()) {
+        while(i < size()) {
             var v1 = m1.elementAt(i);
             var v2 = new Vector<Integer>();
             var j = 0;

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

@@ -10,6 +10,8 @@ public class OL     {
 	
 }
 
+         
+
 public class OLMain   {
 
 	main(x) { 

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

@@ -14,10 +14,10 @@ sort(in){
 	return merge(sort(firstHalf), sort(secondHalf));
 }
 */
-
+/*
 	
-	void sort(a){
+	void sort(ArrayList<String> a){
 		a = merge(a,a);
 	}
-	
+*/	
 }

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

@@ -1,12 +0,0 @@
-public class TypedID/*<L extends K,K> */ {
-	
-	lam = x-> x;
-	
-    id(b){  
-        return b;
-    }
-    
-    m(){
-    	return lam;
-    }
-}

src/test/resources/javFiles/Faculty.jav

@@ -1,14 +1,13 @@
 import java.lang.Integer;
 
 class Faculty {
-	//fact;
-	
-  	Integer mul(Integer x, Integer y) {
+
+  Integer mul(Integer x, Integer y) {
   	return x;
    }
-  
+ 
   m () {
-    var fact = (Integer x) -> {
+   var fact = (Integer x) -> {
         return mul(x, fact.apply(x));
    };
    return fact;

src/test/resources/javFiles/mathStruc.jav

@@ -1,8 +1,13 @@
-class MathStruc <A> {
 
-    A model;
-	
-	innerOp = o -> ms -> new MathStruc<A>(o.apply(this.model, ms.model));
+class mathStruc<A> {
 
-	MathStruc(A m) { model=m; }
- }
+mathStruc(A a) { }
+
+A model(){ A a; return a; }
+
+methode(){
+var innerOp = o -> ms ->
+ new mathStruc<A>(o.apply(this.model(),ms.model()));
+ return innerOp;
+ }
+}