modified: src/test/java/typeinference/JavaTXCompilerTest.java

modified:   src/test/resources/javFiles/IfTest.jav
	modified:   src/test/resources/javFiles/ListenerOverload.jav
	modified:   src/test/resources/javFiles/fc.jav

.gitignore

@@ -23,6 +23,3 @@ bin
 
 #
 manually/
-
-logFiles/**
-!logFiles/.gitkeep

abgabeprotokoll.md

@@ -1,19 +0,0 @@
-# JavaTXCompiler Klasse
-* Konstruktor hat einen weiteren Parameter
-* contextPath
-	* Arrays aus URLs (file-urls)
-* Parameter ist Optional
-* wird er gesetzt, so werden Classfiles aus den übergebenen Pfaden geladen
-	* die übergebenen Pfade müssen dabei die Source-Roots sein
-	* Beispiel:
-	`import de.test.Klasse;`
-	* `Klasse.class` liegt in `output/de/test/Klasse.class`
-	* dann muss contextpath auf `output` gesetzt werden
-* wird der Parameter nicht übergeben, so wird der Sourceroot auf das Verzeichnis gesetzt, in dem der Compiler ausgeführt wird
-* dies ist das Verhalten vom javac Compiler
-
-* generateBytecode - Methode hat neuen Parameter: path
-* wird hier null übergeben, so wird die class-File in den gleichen Ordner wie die übergebene .jav File geschrieben
-* wird hier ein Pfad übergeben, so gilt dieser als output root.
-	* Klassen werden in outputRoot/package/name/KlassenName.class geschrieben
-

doc/Generics/generics.tex

@@ -1,25 +0,0 @@
-\documentclass{article}
-
-\begin{document}
-
-\section{Generics sind notwendig}
-Generics können nicht ignoriert werden.
-Folgender Fall ist Typisierbar:
-
-\begin{program}
-<T> T m1(T x){
-	return m2(x);
-}
-
-m2(x){
-	m1(1);
-	m2("Test");
-	return m1(x);
-}
-\end{program}
-
-Beim weglassen des Generics T wäre es aber nicht mehr möglich.
-Dann erhält jeder Constraint, welcher in Verbindung mit der Methode m1 steht
-den selben TPH.
-
-\end{document}

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>
@@ -20,7 +20,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 		<dependency>
 			<groupId>org.antlr</groupId>
 			<artifactId>antlr4</artifactId>
-			<version>4.7</version>
+			<version>4.8-1</version>
 		</dependency>
 		<dependency>
 			<groupId>commons-io</groupId>
@@ -63,6 +63,19 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 					<skipTests>true</skipTests>
 				</configuration>
 			</plugin>
+			<!-- plugin>
+		        <groupId>org.apache.maven.plugins</groupId>
+		        <artifactId>maven-compiler-plugin</artifactId>
+		        <version>3.8.1</version>
+		        <configuration>
+		          <verbose>true</verbose>
+		          <fork>true</fork>
+		          <executable>/home/michael/programs/jdk/jdk8u232-b09/bin/javac</executable>
+		          <compilerVersion>1.8</compilerVersion>
+		          <source>1.8</source>
+		          <target>1.8</target>
+		        </configuration>
+		    </plugin -->	
 			<plugin>
 				<groupId>org.antlr</groupId>
 				<artifactId>antlr4-maven-plugin</artifactId>
@@ -110,11 +123,6 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 					</execution>
 				</executions>
 				<configuration>
-					<archive>
-						<manifest>
-							<mainClass>de.dhbwstuttgart.core.ConsoleInterface</mainClass>
-						</manifest>
-					</archive>
 					<descriptorRefs>
 						<descriptorRef>jar-with-dependencies</descriptorRef>
 					</descriptorRefs>
@@ -166,10 +174,11 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 		</repository>
 	</repositories>
 	<properties>
+	    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 		<maven.compiler.source>1.8</maven.compiler.source>
 		<maven.compiler.target>1.8</maven.compiler.target>
 		<tycho.version>0.23.0</tycho.version>
-		<mainClass>de.dhbwstuttgart.core.ConsoleInterface</mainClass>
 	</properties>
 	<distributionManagement>
 		<repository>

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.bytecode;
 
-import java.io.File;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -8,8 +7,6 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Optional;
 
-import de.dhbwstuttgart.environment.DirectoryClassLoader;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.FieldVisitor;
 import org.objectweb.asm.MethodVisitor;
@@ -84,13 +81,13 @@ public class BytecodeGen implements ASTVisitor {
 	String type;
 
 	public static RefTypeOrTPHOrWildcardOrGeneric THISTYPE = null;
-	private JavaClassName className;
+	private String className;
 	private String pkgName;
 	private boolean isInterface;
 	private Collection<ResultSet> listOfResultSets;
 	private ResultSet resultSet;
 	private SourceFile sf;
-	private File path;
+	private String path;
 
 	private Optional<Constructor> fieldInitializations;
 
@@ -110,7 +107,7 @@ public class BytecodeGen implements ASTVisitor {
 
 	HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
 	byte[] bytecode;
-	HashMap<JavaClassName, byte[]> classFiles;
+	HashMap<String, byte[]> classFiles;
 
 	private final ArrayList<String> methodNameAndParamsT = new ArrayList<>();
 	private final ArrayList<String> fieldNameAndParamsT = new ArrayList<>();
@@ -121,26 +118,24 @@ public class BytecodeGen implements ASTVisitor {
 	private GenericsGeneratorResultForClass generatedGenerics;
 
 	private Resolver resolver;
-	private final DirectoryClassLoader classLoader;
 
-	public BytecodeGen(HashMap<JavaClassName, byte[]> classFiles, Collection<ResultSet> listOfResultSets, List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles, SourceFile sf,
-					   File path, DirectoryClassLoader classLoader) {
+	public BytecodeGen(HashMap<String, byte[]> classFiles, Collection<ResultSet> listOfResultSets, List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles, SourceFile sf,
+			String path) {
 		this.classFiles = classFiles;
 		this.listOfResultSets = listOfResultSets;
 		this.simplifyResultsForAllSourceFiles = simplifyResultsForAllSourceFiles;
 		this.sf = sf;
 		this.path = path;
 		this.pkgName = sf.getPkgName();
-		this.classLoader = classLoader;
 	}
 
 	@Override
 	public void visit(SourceFile sourceFile) {
 		for (ClassOrInterface cl : sourceFile.getClasses()) {
 			System.out.println("in Class: " + cl.getClassName().toString());
-			BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets, simplifyResultsForAllSourceFiles, sf, path, classLoader);
+			BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets, simplifyResultsForAllSourceFiles, sf, path);
 			cl.accept(classGen);
-			classGen.writeClass(cl.getClassName());
+			classGen.writeClass(cl.getClassName().toString());
 		}
 	}
 
@@ -150,22 +145,22 @@ public class BytecodeGen implements ASTVisitor {
 	 * 
 	 * @param name name of the class with which the bytecode is to be associated
 	 */
-	private void writeClass(JavaClassName name) {
+	private void writeClass(String name) {
 		bytecode = cw.toByteArray();
 		classFiles.put(name, bytecode);
 
 	}
 
-	public HashMap<JavaClassName, byte[]> getClassFiles() {
+	public HashMap<String, byte[]> getClassFiles() {
 		return classFiles;
 	}
 
 	@Override
 	public void visit(ClassOrInterface classOrInterface) {
 
-		className = classOrInterface.getClassName();
+		className = classOrInterface.getClassName().toString();
 
-		cw.visitSource(className.getClassName() + ".jav", null);
+		cw.visitSource(className + ".jav", null);
 
 		isInterface = (classOrInterface.getModifiers() & 512) == 512;
 
@@ -177,7 +172,7 @@ public class BytecodeGen implements ASTVisitor {
 //		resultSet = listOfResultSets.get(0);
 		boolean isVisited = false;
 		List<ResultSet> listOfResultSetsList = new ArrayList<>(listOfResultSets);
-		generatedGenerics = simplifyResultsForAllSourceFiles.stream().map(sr->sr.getSimplifyResultsByName(className)).findFirst().get();
+		generatedGenerics = simplifyResultsForAllSourceFiles.stream().map(sr->sr.getSimplifyResultsByName(pkgName, className)).findFirst().get();
 		for (int i = 0; i < listOfResultSetsList.size(); i++) {
 		//for (ResultSet rs : listOfResultSets) {
 			superClass = classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor());
@@ -204,7 +199,7 @@ public class BytecodeGen implements ASTVisitor {
 					System.out.println("Signature: => " + sig);
 				}
 
-				cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString().replace(".", "/"), sig,
+				cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString(), sig,
 						classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
 
 				isVisited = true;
@@ -274,7 +269,7 @@ public class BytecodeGen implements ASTVisitor {
 		constructorPos += 1;
 
 		BytecodeGenMethod gen = new BytecodeGenMethod(className, superClass, resultSet, field, mv, paramsAndLocals, cw,
-				genericsAndBoundsMethod, genericsAndBounds, isInterface, classFiles, sf, path, block, constructorPos, classLoader);
+				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);
@@ -355,7 +350,7 @@ public class BytecodeGen implements ASTVisitor {
 
 		mv.visitCode();
 		BytecodeGenMethod gen = new BytecodeGenMethod(className, superClass, resultSet, method, mv, paramsAndLocals, cw,
-				genericsAndBoundsMethod, genericsAndBounds, isInterface, classFiles, sf, path, classLoader);
+				genericsAndBoundsMethod, genericsAndBounds, isInterface, classFiles, sf, path);
 
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.bytecode;
 
-import java.io.File;
 import java.lang.invoke.CallSite;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
@@ -15,9 +14,7 @@ import java.util.LinkedList;
 import java.util.List;
 
 import de.dhbwstuttgart.bytecode.utilities.*;
-import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr.Operator;
 import de.dhbwstuttgart.syntaxtree.statement.UnaryExpr.Operation;
@@ -48,7 +45,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	private Method m;
 	private MethodVisitor mv;
 	private HashMap<String, Integer> paramsAndLocals = new HashMap<>();
-	private JavaClassName className;
+	private String className;
 	private int lamCounter;
 	private ClassWriter cw;
 	private ResultSet resultSet;
@@ -57,7 +54,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	private HashMap<String, String> genericsAndBounds;
 	public boolean isBinaryExp = false;
 	private String superClass;
-	private File path;
+	private String path;
 	private SourceFile sf;
 	private IStatement statement = null;
 	private boolean isReturnStmt = false;
@@ -74,18 +71,16 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 	private boolean isRightSideALambda = false;
 	private KindOfLambda kindOfLambda;
-	private HashMap<JavaClassName, byte[]> classFiles;
+	private HashMap<String, byte[]> classFiles;
 	
 	private int constructorPos = 0;
 
 	private ArrayList<RefTypeOrTPHOrWildcardOrGeneric> varsFunInterface = new ArrayList<>();;
-	private final DirectoryClassLoader classLoader;
-
 	// generate bytecode for constructor
-	public BytecodeGenMethod(JavaClassName className, String superClass, ResultSet resultSet, Method m, MethodVisitor mv,
-							 HashMap<String, Integer> paramsAndLocals, ClassWriter cw, HashMap<String, String> genericsAndBoundsMethod,
-							 HashMap<String, String> genericsAndBounds, boolean isInterface, HashMap<JavaClassName, byte[]> classFiles,
-							 SourceFile sf, File path, Block block, int constructorPos, DirectoryClassLoader classLoader) {
+	public BytecodeGenMethod(String className, String superClass,ResultSet resultSet, Method m, MethodVisitor mv,
+			HashMap<String, Integer> paramsAndLocals, ClassWriter cw, HashMap<String, String> genericsAndBoundsMethod,
+			HashMap<String, String> genericsAndBounds, boolean isInterface, HashMap<String, byte[]> classFiles, 
+			SourceFile sf,String path, Block block, int constructorPos) {
 
 		this.className = className;
 		this.superClass = superClass;
@@ -103,15 +98,16 @@ public class BytecodeGenMethod implements StatementVisitor {
 		this.path = path;
 		this.lamCounter = -1;
 		this.constructorPos = constructorPos;
-		this.classLoader = classLoader;
 		if(block != null)
 			this.blockFieldInit = block;
 		this.m.block.accept(this);
+		
+		
 	}
 	
-	public BytecodeGenMethod(JavaClassName className, String superClass,ResultSet resultSet, Method m, MethodVisitor mv,
+	public BytecodeGenMethod(String className, String superClass,ResultSet resultSet, Method m, MethodVisitor mv,
 			HashMap<String, Integer> paramsAndLocals, ClassWriter cw, HashMap<String, String> genericsAndBoundsMethod,
-			HashMap<String, String> genericsAndBounds, boolean isInterface, HashMap<JavaClassName, byte[]> classFiles, SourceFile sf,File path, DirectoryClassLoader classLoader) {
+			HashMap<String, String> genericsAndBounds, boolean isInterface, HashMap<String, byte[]> classFiles, SourceFile sf,String path) {
 
 		this.className = className;
 		this.superClass = superClass;
@@ -128,14 +124,14 @@ public class BytecodeGenMethod implements StatementVisitor {
 		this.sf = sf;
 		this.path = path;
 		this.lamCounter = -1;
-		this.classLoader = classLoader;
 		if (!isInterface)
 			this.m.block.accept(this);
+
 	}
 
-	public BytecodeGenMethod(JavaClassName className, ClassWriter cw, LambdaExpression lambdaExpression, ArrayList<String> usedVars, ResultSet resultSet, MethodVisitor mv,
-			int indexOfFirstParamLam, boolean isInterface, HashMap<JavaClassName, byte[]> classFiles, File path, int lamCounter, SourceFile sf,HashMap<String, String> genericsAndBoundsMethod,
-			HashMap<String, String> genericsAndBounds, DirectoryClassLoader classLoader) {
+	public BytecodeGenMethod(String className, ClassWriter cw, 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) {
 		this.className = className;
 		this.cw = cw;
 		this.resultSet = resultSet;
@@ -148,7 +144,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 		this.sf = sf;
 		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
 		this.genericsAndBounds = genericsAndBounds;
-		this.classLoader = classLoader;
 		
 		Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
 		int i = indexOfFirstParamLam;
@@ -177,7 +172,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 	@Override
 	public void visit(Block block) {
-		HashMap<String, Integer> paramsAndLocalsOld = new HashMap<>(paramsAndLocals);
 		for (Statement stmt : block.getStatements()) {
 			stmt.accept(this);
 			if(stmt instanceof MethodCall) {
@@ -186,7 +180,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 					mv.visitInsn(Opcodes.POP);
 			}
 		}
-		paramsAndLocals = paramsAndLocalsOld;
 	}
 
 	@Override
@@ -224,7 +217,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	// ??
 	@Override
 	public void visit(LocalVarDecl localVarDecl) {
-		paramsAndLocals.put(localVarDecl.getName(), paramsAndLocals.size()+1);
+
 	}
 
 	@Override
@@ -629,7 +622,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		}
 		String newDesc = addUsedVarsToDesugaredMethodDescriptor(lamDesc);
 		// first check if capturing lambda then invokestatic or invokespecial
-		Handle arg2 = new Handle(staticOrSpecial, this.className.getClassName(), desugaredMethodName, newDesc, false);
+		Handle arg2 = new Handle(staticOrSpecial, this.className, desugaredMethodName, newDesc, false);
 		// Descriptor of functional interface methode
 		SamMethod samMethod = new SamMethod(kindOfLambda.getArgumentList(), lambdaExpression.getType());
 		// Desc: (this/nothing)TargetType
@@ -643,7 +636,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 			
 			new BytecodeGenMethod(className, cw,lambdaExpression, usedVars,this.resultSet, mvLambdaBody, indexOfFirstParamLam, isInterface,
 					classFiles,this.path, lamCounter, sf, genericsAndBoundsMethod,
-					genericsAndBounds, classLoader);
+					genericsAndBounds);
 	
 			mvLambdaBody.visitMaxs(0, 0);
 			mvLambdaBody.visitEnd();
@@ -762,10 +755,10 @@ public class BytecodeGenMethod implements StatementVisitor {
 		String mDesc = "";
 		
 		MethodCallHelper helper = new MethodCallHelper(methodCall, sf, resultSet, path);
-
-		DirectoryClassLoader cLoader = this.classLoader;
+		
+		ClassLoader cLoader = ClassLoader.getSystemClassLoader();
 		// This will be used if the class is not standard class (not in API)
-		DirectoryClassLoader cLoader2;
+		ClassLoader cLoader2;
 
 		String methCallType = resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 		String[] typesOfParams = getTypes(methodCall.arglist.getArguments());
@@ -774,13 +767,13 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 			java.lang.reflect.Method[] methods = cLoader.loadClass(clazz).getMethods();
 			System.out.println("Methods of " + receiverName + " ");
-			methodRefl = getMethod(methodCall.name, methodCall.arglist.getArguments().size(),methCallType, typesOfParams, methods);
+			methodRefl = getMethod(methodCall.name, methodCall.arglist.getArguments().size(), methods);
 
 			} catch (Exception e) {
 					String superClass = "";
 					while(true) {
 						try {
-							superClass = helper.getSuperClass(receiverName.replace("/", "."));
+							superClass = helper.getSuperClass(receiverName);
 							
 							try {
 								String superClazz = superClass.replace("/", ".");
@@ -788,7 +781,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 								java.lang.reflect.Method[] methods = cLoader.loadClass(superClazz).getMethods();
 								System.out.println("Methods of " + superClass + " ");
 
-								methodRefl = getMethod(methodCall.name, methodCall.arglist.getArguments().size(), methCallType, typesOfParams, methods);
+								methodRefl = getMethod(methodCall.name, methodCall.arglist.getArguments().size(), methods);
 
 								break;
 							} catch (Exception e3) {
@@ -804,7 +797,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 			}
 			
 			if(methodRefl == null) {
-				boolean toCreate = !receiverName.equals(className.getClassName()) && helper.isInCurrPkg(clazz);
+				boolean toCreate = !receiverName.equals(className) && helper.isInCurrPkg(clazz);
 				if(toCreate) {
 					try {
 						mDesc = helper.getDesc(clazz);
@@ -818,7 +811,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 //						mDesc = helper.generateBCForFunN(methCallType,typesOfParams);
 					}else {
 						try {
-							cLoader2 = new DirectoryClassLoader(path, classLoader);
+							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++) {
@@ -839,7 +832,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		System.out.println("Methodcall type : " + resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor()));
 		List<Boolean> argListMethCall = new LinkedList<>();
 		String receiverRefl="";
-		if(methodRefl == null && receiverName.equals(className.getClassName())) {
+		if(methodRefl == null && receiverName.equals(className)) {
 			MethodFromMethodCall method = new MethodFromMethodCall(methodCall.arglist, methodCall.getType(),
 					receiverName, genericsAndBoundsMethod, genericsAndBounds);
 			mDesc = method.accept(new DescriptorToString(resultSet));
@@ -917,7 +910,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		}
 		return clazz;
 	}
-	
+
 	private String[] getTypes(List<Expression> arguments) {
 		String[] types = new String[arguments.size()];
 		for(int i = 0; i<arguments.size(); ++i) {
@@ -943,17 +936,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 		return null;
 	}
 	
-	
-	boolean unbox(String demanded, String given) {
-		if (demanded.equals("java/lang/Boolean") && given.equals("boolean")) return true;
-		if (demanded.equals("java/lang/Integer") && given.equals("int")) return true;
-		if (demanded.equals("java/lang/Short") && given.equals("short")) return true;
-		if (demanded.equals("java/lang/Byte") && given.equals("byte")) return true;
-		if (demanded.equals("java/lang/Double") && given.equals("double")) return true;
-		if (demanded.equals("java/lang/Float") && given.equals("float")) return true;
-		return false;
-	}
-	
 	/**
 	 * @param name name of a method
 	 * @param i number of parameters
@@ -971,15 +953,11 @@ public class BytecodeGenMethod implements StatementVisitor {
 		for(java.lang.reflect.Method m : methods) {
 			if(name.equals(m.getName()) && i == m.getParameterCount() && 
 					(methCallType.equals(m.getReturnType().getName().replace(".", "/")) || 
-							m.getReturnType().getName().replace(".", "/").equals(Type.getInternalName(Object.class)) ||
-							unbox(methCallType, m.getReturnType().getName().replace(".", "/"))
-							)  ) {
+							m.getReturnType().getName().replace(".", "/").equals(Type.getInternalName(Object.class)))) {
 				boolean typesEqual = true;
 				Class<?>[] pTypes = m.getParameterTypes();
 				for(int j = 0; j<typesOfParams.length; ++j) {
-					if(!typesOfParams[j].replaceAll("/", ".").equals(pTypes[j].getName())
-							&& !unbox(typesOfParams[j], pTypes[j].getName())
-							&& !pTypes[j].getName().replace(".", "/").equals(Type.getInternalName(Object.class))) {
+					if(!typesOfParams[j].equals(pTypes[j].getName().replaceAll(".", "/")) && !pTypes[j].getName().replace(".", "/").equals(Type.getInternalName(Object.class))) {
 						typesEqual = false;
 						break;
 					}

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

@@ -20,8 +20,7 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
 		System.out.println("\nWILDCARD ="+superWildcardType.getInnerType().toString().replace(".", "/"));
-		//return superWildcardType.getInnerType().toString().replace(".", "/");
-		return superWildcardType.getInnerType().acceptTV(new TypeToDescriptor());
+		return superWildcardType.getInnerType().toString().replace(".", "/");
 		//throw new NotImplementedException();
 	}
 
@@ -33,8 +32,7 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
 		System.out.println("\nWILDCARD extends ="+extendsWildcardType.getInnerType().toString().replace(".", "/"));
-		//return extendsWildcardType.getInnerType().toString().replace(".", "/");
-		return extendsWildcardType.getInnerType().acceptTV(new TypeToDescriptor());
+		return extendsWildcardType.getInnerType().toString().replace(".", "/");
 		//throw new NotImplementedException();
 	}
 

src/main/java/de/dhbwstuttgart/bytecode/genericsGenerator/GeneratedGenericsFinder.java

@@ -16,7 +16,6 @@ import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 import de.dhbwstuttgart.bytecode.utilities.MethodUtility;
 import de.dhbwstuttgart.bytecode.utilities.Resolver;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Constructor;
@@ -76,7 +75,7 @@ public class GeneratedGenericsFinder implements ASTVisitor {
 	private final List<String> methodNameAndParamsT = new ArrayList<>();
 	
 	private String pkgName;
-	private JavaClassName className;
+	private String className;
 	private Resolver resolver;
 
 	/**
@@ -118,7 +117,7 @@ public class GeneratedGenericsFinder implements ASTVisitor {
 	 */
 	@Override
 	public void visit(ClassOrInterface classOrInterface) {
-		className = classOrInterface.getClassName();
+		className = classOrInterface.getClassName().toString();
 		List<ResultSet> listOfResultSetsList = new ArrayList<>(listOfResultSets);
 		
 		boolean isVisited = false;

src/main/java/de/dhbwstuttgart/bytecode/genericsGenerator/GenericsGenerator.java

@@ -12,7 +12,6 @@ import java.util.Set;
 import java.util.stream.Collectors;
 
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.*;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import org.objectweb.asm.Type;
 
 import de.dhbwstuttgart.bytecode.TPHExtractor;
@@ -31,7 +30,7 @@ public class GenericsGenerator {
        class constraints: tphClass < tphMeth1, tphMeth1 < tphMeth2, tphMeth2 < Object
      */
 
-    public static GenericsGeneratorResultForClass generateConstraints(final JavaClassName className, final TPHExtractor tphExtractor,
+    public static GenericsGeneratorResultForClass generateConstraints(final String className, final TPHExtractor tphExtractor,
                                                                       final List<String> tphsClass, final ConstraintsSimplierResult simplifiedConstraints) {
 
         List<GenericsGeneratorResult> classConstraints = generateConstraintsForClass(tphExtractor,

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

@@ -3,8 +3,6 @@
  */
 package de.dhbwstuttgart.bytecode.genericsGeneratorTypes;
 
-import de.dhbwstuttgart.parser.scope.JavaClassName;
-
 import java.util.ArrayList;
 import java.util.List;
 import java.util.NoSuchElementException;
@@ -39,15 +37,14 @@ public class GenericGenratorResultForSourceFile {
 		genericGeneratorResultForAllClasses.add(sResClass);
 	}
 
-	public GenericsGeneratorResultForClass getSimplifyResultsByName(JavaClassName name) {
+	public GenericsGeneratorResultForClass getSimplifyResultsByName(String pkgName, String name) {
 
-		if (this.pkgName.equals(name.getPackageName())) {
+		if (this.pkgName.equals(pkgName)) {
 			return genericGeneratorResultForAllClasses.stream()
 					.filter(sr -> sr.getClassName().equals(name))
 					.findAny()
-					.orElseThrow(() -> new NoSuchElementException(
-							"Simplify results for the class " + pkgName + "." + name + " are not found"));
+					.orElse(new GenericsGeneratorResultForClass(name));
 		}
-		throw new NoSuchElementException("Simplify results for the class " + pkgName + "." + name + " are not found");
+		return new GenericsGeneratorResultForClass(name);
 	}
 }

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

@@ -3,21 +3,22 @@
  */
 package de.dhbwstuttgart.bytecode.genericsGeneratorTypes;
 
-import de.dhbwstuttgart.parser.scope.JavaClassName;
-
 import java.util.Collections;
 import java.util.List;
+import java.util.Optional;
+
+import com.google.common.collect.Lists;
 
 /**
  * @author fayez
  *
  */
 public class GenericsGeneratorResultForClass {
-	private final JavaClassName className;
+	private final String className;
 	private final List<GenericsGeneratorResult> classConstraints;
 	private final GenericGeneratorResultsForAllMethods methodsAndTheirConstraints;
 
-	public GenericsGeneratorResultForClass(JavaClassName className) {
+	public GenericsGeneratorResultForClass(String className) {
 		this(className, Collections.emptyList(), new GenericGeneratorResultsForAllMethods());
 	}
 	/**
@@ -25,8 +26,8 @@ public class GenericsGeneratorResultForClass {
 	 * @param classConstraints
 	 * @param methodsAndTheirConstraints
 	 */
-	public GenericsGeneratorResultForClass(JavaClassName className, List<GenericsGeneratorResult> classConstraints,
-										   GenericGeneratorResultsForAllMethods methodsAndTheirConstraints) {
+	public GenericsGeneratorResultForClass(String className, List<GenericsGeneratorResult> classConstraints,
+			GenericGeneratorResultsForAllMethods methodsAndTheirConstraints) {
 		this.className = className;
 		this.classConstraints = classConstraints;
 		this.methodsAndTheirConstraints = methodsAndTheirConstraints;
@@ -35,7 +36,7 @@ public class GenericsGeneratorResultForClass {
 	/**
 	 * @return the className
 	 */
-	public JavaClassName getClassName() {
+	public String getClassName() {
 		return className;
 	}
 
@@ -58,12 +59,16 @@ public class GenericsGeneratorResultForClass {
 				.anyMatch(i -> i.equals(id));
 	}
 
-	
-	
-	
 	public List<GenericsGeneratorResult> getMethodConstraintsByID(String id) {
-		return methodsAndTheirConstraints.getMethodsAndConstraints().stream().filter(mc -> mc.getMethodID().equals(id))
-				.findFirst().get().getConstraints();
+		Optional<MethodAndConstraints> methodConstraints = methodsAndTheirConstraints.getMethodsAndConstraints()
+				.stream()
+				.filter(mc -> mc.getMethodID().equals(id))
+				.findFirst();
+		
+		if (methodConstraints.isPresent())  {
+			return methodConstraints.get().getConstraints();
+		} else {
+			return Collections.emptyList();
+		}
 	}
-
 }

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

@@ -20,7 +20,7 @@ import java.util.Iterator;
 
 public class ByteCodeForFunNGenerator {
 
-    public static void generateBCForFunN(LambdaExpression lambdaExpression, String methDesc, File path) {
+    public static void generateBCForFunN(LambdaExpression lambdaExpression, String methDesc, String path) {
         ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
 
         SignatureWriter methSig = new SignatureWriter();
@@ -46,7 +46,7 @@ public class ByteCodeForFunNGenerator {
         writeClassFile(classWriter.toByteArray(), name, path);
     }
 
-    public static void generateBCForFunN(ArgumentList argumentList, String methDesc, File path) {
+    public static void generateBCForFunN(ArgumentList argumentList, String methDesc, String path) {
         ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
 
         SignatureWriter methSig = new SignatureWriter();
@@ -75,12 +75,12 @@ public class ByteCodeForFunNGenerator {
     }
 
 
-    public static void writeClassFile(byte[] bytecode, String name, File path) {
+    public static void writeClassFile(byte[] bytecode, String name, String path) {
         FileOutputStream output;
         try {
             System.out.println("generating " + name + ".class file...");
             output = new FileOutputStream(
-                    new File(path , name + CONSTANTS.EXTENSIONCLASS));
+                    new File(path + name + CONSTANTS.EXTENSIONCLASS));
             output.write(bytecode);
             output.close();
             System.out.println(name + ".class file generated");

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

@@ -16,7 +16,6 @@ import javassist.NotFoundException;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 
-import java.io.File;
 import java.util.*;
 
 /**
@@ -27,7 +26,7 @@ public class MethodCallHelper {
 	private MethodCall methCall;
 	private SourceFile sourceFile;
 	private ResultSet resultSet;
-	private File path;
+	private String path;
 
 	/**
 	 * @param methCall
@@ -35,7 +34,7 @@ public class MethodCallHelper {
 	 * @param resultSet
 	 * @param path TODO
 	 */
-	public MethodCallHelper(MethodCall methCall, SourceFile sourceFile, ResultSet resultSet, File path) {
+	public MethodCallHelper(MethodCall methCall, SourceFile sourceFile, ResultSet resultSet, String path) {
 		this.methCall = methCall;
 		this.sourceFile = sourceFile;
 		this.resultSet = resultSet;

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

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.core;
 
 import java.io.File;
 import java.io.IOException;
-import java.net.URL;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -10,29 +9,8 @@ public class ConsoleInterface {
 	private static final String directory = System.getProperty("user.dir");
 
 	public static void main(String[] args) throws IOException, ClassNotFoundException {
-		List<File> input = new ArrayList<>();
-		List<File> classpath = new ArrayList<>();
-        String outputPath = null;
-		Iterator<String> it = Arrays.asList(args).iterator();
-		while(it.hasNext()){
-            String arg = it.next();
-            if(arg.equals("-d")){
-                outputPath = it.next();
-            }else if(arg.startsWith("-d")) {
-                outputPath = arg.substring(2);
-            }else if(arg.equals("-cp") || arg.equals("-classpath")){
-                String[] cps = it.next().split(":");
-                for(String cp : cps){
-                    classpath.add(new File(cp));
-                }
-            }else{
-                input.add(new File(arg));
-            }
-        }
-		JavaTXCompiler compiler = new JavaTXCompiler(input, classpath);
+		List<File> input = Arrays.asList(args).stream().map((s -> new File(s))).collect(Collectors.toList());
+		JavaTXCompiler compiler = new JavaTXCompiler(input);
 		compiler.typeInference();
-		compiler.generateBytecode(outputPath);
 	}
-
-
 }

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

@@ -1,38 +1,21 @@
 //PL 2018-12-19: typeInferenceOld nach typeInference uebertragen
 package de.dhbwstuttgart.core;
 
-import com.google.common.collect.Lists;
 import de.dhbwstuttgart.bytecode.BytecodeGen;
 import de.dhbwstuttgart.bytecode.Exception.BytecodeGeneratorError;
 import de.dhbwstuttgart.bytecode.genericsGenerator.GeneratedGenericsFinder;
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
-import de.dhbwstuttgart.environment.DirectoryClassLoader;
-import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.JavaTXParser;
-import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.antlr.Java8Parser.CompilationUnitContext;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.Method;
-import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.syntaxtree.TypeScope;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
-import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
-import de.dhbwstuttgart.syntaxtree.statement.Block;
-import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
-import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
 import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
@@ -58,125 +41,55 @@ import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
-import java.io.OutputStreamWriter;
-import java.net.URL;
-import java.net.URLClassLoader;
 import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-
-import org.antlr.v4.runtime.Token;
-import org.apache.commons.io.output.NullOutputStream;
-
+//import org.apache.commons.io.output.NullOutputStream;
 
 public class JavaTXCompiler {
 
-	public static JavaTXCompiler INSTANCE;
+	//public static JavaTXCompiler INSTANCE;
     final CompilationEnvironment environment;
-	Boolean resultmodel = true;
+    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?
     public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
-    private final DirectoryClassLoader classLoader;
-
-	public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
-		this(Arrays.asList(sourceFile), null);
-		INSTANCE = this;
-	}
+    
+    public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
+        this(Arrays.asList(sourceFile));
+        //INSTANCE = this;
+    }
 
     public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
     	this(sourceFile);
     	this.log = log;
-    	INSTANCE = this;
+    	//INSTANCE = this;
     }
-
-	public JavaTXCompiler(List<File> sourceFiles) throws IOException, ClassNotFoundException {
-		this(sourceFiles, null);
-		INSTANCE = this;
-	}
-    public JavaTXCompiler(List<File> sources, List<File> contextPath) throws IOException, ClassNotFoundException {
-        if(contextPath == null || contextPath.isEmpty()){
-        	//When no contextPaths are given, the working directory is the sources root
-			contextPath = Lists.newArrayList(new File(System.getProperty("user.dir")));
-		}
-        classLoader = new DirectoryClassLoader(contextPath, ClassLoader.getSystemClassLoader());
-		environment = new CompilationEnvironment(sources);
+    
+    public JavaTXCompiler(List<File> sources) throws IOException, ClassNotFoundException {
+        environment = new CompilationEnvironment(sources);
         for (File s : sources) {
             sourceFiles.put(s, parse(s));
         }
-        INSTANCE = this;
+        //INSTANCE = this;
     }
 
-    public ConstraintSet<Pair> getConstraints() throws ClassNotFoundException, IOException {
+    public ConstraintSet<Pair> getConstraints() throws ClassNotFoundException {
         List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
+        for (SourceFile sf : sourceFiles.values()) {
+            allClasses.addAll(sf.getClasses());
+        }
         List<ClassOrInterface> importedClasses = new ArrayList<>();
-        ClassOrInterface objectClass = ASTFactory.createClass(
-                classLoader.loadClass(new JavaClassName("java.lang.Object").toString()));
         //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
-        for (File forSourceFile : sourceFiles.keySet()){
+        for (File forSourceFile : sourceFiles.keySet())
             for (JavaClassName name : sourceFiles.get(forSourceFile).getImports()) {
                 //TODO: Hier werden imports von eigenen (.jav) Klassen nicht beachtet
                 ClassOrInterface importedClass = ASTFactory.createClass(
-                        classLoader.loadClass(name.toString()));
+                        ClassLoader.getSystemClassLoader().loadClass(name.toString()));
                 importedClasses.add(importedClass);
             }
-			for(Class c : CompilationEnvironment.loadDefaultPackageClasses(forSourceFile, classLoader)){
-				ClassOrInterface importedClass = ASTFactory.createClass(c);
-				importedClasses.add(importedClass);
-			}
-        }
-        for (File f : this.sourceFiles.keySet()) {
-			SourceFile sf = sourceFiles.get(f);
-			sf = new SourceFile(sf.getPkgName(),
-					       sf.KlassenVektor.stream()
-										   .map(cl -> new ClassOrInterface(cl))
-							               .collect(Collectors.toCollection(ArrayList::new)),
-						   sf.imports);
-			//sf enthaelt neues Source-File, neue Klassen-Objekte und neue 
-			//ArrayListen-Objekte fuer Fields, Construktoren und Methoden
-			//Alle anderen Objekte werden nur kopiert.
-			sf.KlassenVektor.forEach(cl -> {
-				ClassOrInterface superclass = null;
-				if (cl.getSuperClass().getName().equals(new JavaClassName("java.lang.Object"))) {
-					superclass = objectClass;
-				}	
-				else {
-					Optional<ClassOrInterface> optSuperclass = 
-							importedClasses.stream().filter(x -> x.getClassName().equals(
-									cl.getSuperClass().getName())).findFirst();
-					if (optSuperclass.isPresent()) {
-						superclass = optSuperclass.get();
-					}
-					else {	
-						//throw new ClassNotFoundException("");
-					}
-				}
-				Iterator<RefTypeOrTPHOrWildcardOrGeneric> paraIt= cl.getSuperClass().getParaList().iterator();
-				Iterator<GenericTypeVar> tvarVarIt = superclass.getGenerics().iterator();
-				
-				HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs = new HashMap<>();
-				while (paraIt.hasNext()) { 
-					gtvs.put(tvarVarIt.next().getName(), paraIt.next());
-				}
-				Iterator<Method> methodIt = superclass.getMethods().iterator();
-				while(methodIt.hasNext()) {
-					Method m = methodIt.next();
-					ParameterList newParaList = new ParameterList(
-					m.getParameterList()
-					 .getFormalparalist()
-					 .stream()
-					 .map(fp -> new FormalParameter(fp.getName(), fp.getType().acceptTV(new TypeExchanger(gtvs)), fp.getOffset()))
-					 .collect(Collectors.toCollection(ArrayList::new)), m.getParameterList().getOffset());
-					cl.getMethods().add(new Method(m.modifier, m.name, m.getReturnType().acceptTV(new TypeExchanger(gtvs)), newParaList, m.block,
-							  //new GenericDeclarationList(newGenericsList, ((GenericDeclarationList)m.getGenerics()).getOffset()), 
-							(GenericDeclarationList)m.getGenerics(),
-							m.getOffset()));
-				}
-				
-			});
-            allClasses.addAll(sf.getClasses());
-		}
         allClasses.addAll(importedClasses);
+
         return new TYPE(sourceFiles.values(), allClasses).getConstraints();
     }
 
@@ -209,7 +122,7 @@ public class JavaTXCompiler {
 		for (JavaClassName name : forSourceFile.getImports()) {
 			// TODO: Hier werden imports von eigenen (.jav) Klassen nicht beachtet
 			ClassOrInterface importedClass = ASTFactory
-					.createClass(classLoader.loadClass(name.toString()));
+					.createClass(ClassLoader.getSystemClassLoader().loadClass(name.toString()));
 			importedClasses.add(importedClass);
 			allClasses.addAll(importedClasses);
 		}
@@ -362,14 +275,12 @@ public class JavaTXCompiler {
 	 */
 
 	public UnifyResultModel typeInferenceAsync(UnifyResultListener resultListener, Writer logFile)
-			throws ClassNotFoundException, IOException {
+			throws ClassNotFoundException {
 		List<ClassOrInterface> allClasses = new ArrayList<>();// environment.getAllAvailableClasses();
 		// Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
-		for (File f : this.sourceFiles.keySet()) {
-			SourceFile sf = sourceFiles.get(f);
+		for (SourceFile sf : this.sourceFiles.values()) {
 			allClasses.addAll(getAvailableClasses(sf));
 			allClasses.addAll(sf.getClasses());
-			allClasses.addAll(CompilationEnvironment.loadDefaultPackageClasses(f,classLoader).stream().map(ASTFactory::createClass).collect(Collectors.toList()));
 		}
 
 		final ConstraintSet<Pair> cons = getConstraints();
@@ -380,7 +291,7 @@ public class JavaTXCompiler {
 			logFile = logFile == null
 					? new FileWriter(new File("log_" + sourceFiles.keySet().iterator().next().getName()))
 					: logFile;
-			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile, classLoader);
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile);
 			System.out.println(finiteClosure);
 			urm = new UnifyResultModel(cons, finiteClosure);
 			urm.addUnifyResultListener(resultListener);
@@ -532,28 +443,26 @@ public class JavaTXCompiler {
 		return urm;
 	}
 
-	public List<ResultSet> typeInference() throws ClassNotFoundException, IOException {
+	public List<ResultSet> typeInference() throws ClassNotFoundException {
 		List<ClassOrInterface> allClasses = new ArrayList<>();// environment.getAllAvailableClasses();
 		// Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
-		for (File f : this.sourceFiles.keySet()) {
-			SourceFile sf = sourceFiles.get(f);
+		for (SourceFile sf : this.sourceFiles.values()) {
 			allClasses.addAll(getAvailableClasses(sf));
 			allClasses.addAll(sf.getClasses());
-			allClasses.addAll(CompilationEnvironment.loadDefaultPackageClasses(f,classLoader).stream().map(ASTFactory::createClass).collect(Collectors.toList()));
 		}
 
 		final ConstraintSet<Pair> cons = getConstraints();
 		Set<Set<UnifyPair>> results = new HashSet<>();
 		try {
-			Writer logFile = //new OutputStreamWriter(new NullOutputStream());
+			Writer logFile = // new OutputStreamWriter(new NullOutputStream());
 					// new FileWriter(new
 					// File(System.getProperty("user.dir")+"/src/test/resources/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName()));
 					new FileWriter(new File(System.getProperty("user.dir") + "/logFiles/" + "log_"
 							+ sourceFiles.keySet().iterator().next().getName()));
-			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile, classLoader);
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile);
 			System.out.println(finiteClosure);
 			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
-			System.out.println("xxx1");
+
 			Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
 				UnifyType lhs, rhs;
 				if (((lhs = x.getLhsType()) instanceof PlaceholderType)
@@ -565,9 +474,7 @@ public class JavaTXCompiler {
 				return x;
 
 			};
-			
 			logFile.write("Unify:" + unifyCons.toString());
-			System.out.println("Unify:" + unifyCons.toString());
 			unifyCons = unifyCons.map(distributeInnerVars);
 			logFile.write("\nUnify_distributeInnerVars: " + unifyCons.toString());
 			TypeUnify unify = new TypeUnify();
@@ -575,7 +482,6 @@ public class JavaTXCompiler {
 			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
 			for (SourceFile sf : this.sourceFiles.values()) {
 				logFile.write(ASTTypePrinter.print(sf));
-				System.out.println(ASTTypePrinter.print(sf));
 			}
 			logFile.flush();
 
@@ -664,23 +570,6 @@ public class JavaTXCompiler {
 				return x;// HIER DIE JEWEILS RECHT BZW. LINKE SEITE AUF GLEICHE VARIANZ SETZEN WIE DIE
 							// JEWEILS ANDERE SEITE
 			});
-			
-			//PL 2020-02-05 alle Oder-Constraints Receiver und Parameter werden auf variance 1 gesetzt
-			//Es wird davon ausgegangen, dass in OderConstraints in Bedingungen für Parameter die Typen der Argumente links stehen
-			//und die Typen der Rückgabewerte immer rechts stehen
-			
-			/*
-			unifyCons.getOderConstraints().forEach(z -> z.forEach(y -> y.forEach(x -> {
-				if ((x.getLhsType() instanceof PlaceholderType) && x.getPairOp().compareTo(PairOperator.SMALLERDOT) == 0) {
-					((PlaceholderType) x.getLhsType()).setVariance((byte)1);
-				}
-				else if ((x.getRhsType() instanceof PlaceholderType) && x.getPairOp().compareTo(PairOperator.EQUALSDOT) == 0) {
-					((PlaceholderType) x.getRhsType()).setVariance((byte)-1);
-				}
-				})));
-			*/
-			
-			System.out.println("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
 			Set<PlaceholderType> varianceTPHold;
 			Set<PlaceholderType> varianceTPH = new HashSet<>();
 			varianceTPH = varianceInheritanceConstraintSet(unifyCons);
@@ -819,17 +708,21 @@ public class JavaTXCompiler {
 
 	private SourceFile parse(File sourceFile) throws IOException, java.lang.ClassNotFoundException {
 		CompilationUnitContext tree = JavaTXParser.parse(sourceFile);
-		SyntaxTreeGenerator generator = new SyntaxTreeGenerator(environment.getRegistry(sourceFile, classLoader),
+		SyntaxTreeGenerator generator = new SyntaxTreeGenerator(environment.getRegistry(sourceFile),
 				new GenericsRegistry(null));
-		SourceFile ret = generator.convert(tree, environment.packageCrawler, classLoader);
+		SourceFile ret = generator.convert(tree, environment.packageCrawler);
 		return ret;
 	}
 
-	public void generateBytecodForFile(File path, HashMap<JavaClassName, byte[]> classFiles, SourceFile sf,
-			List<ResultSet> typeinferenceResult) throws IOException {
+	public synchronized void generateBytecodForFile(String path, /* HashMap<String, byte[]> classFiles,*/ SourceFile sf,
+			List<ResultSet> typeinferenceResult, List<GenericGenratorResultForSourceFile> genericResultsRet) throws IOException {
+			//genericResultsRet is empty; fuer die Rückgabe
 		try {
+			HashMap<String, byte[]> classFiles = new HashMap<>();
+
 			List<GenericGenratorResultForSourceFile> genericResults = getGeneratedGenericResultsForAllSourceFiles(typeinferenceResult);
-			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult, genericResults, sf,path, classLoader);
+			genericResultsRet.addAll(genericResults);//fuer Rueckgabe
+			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult, genericResults, sf,path);
 			bytecodeGen.visit(sf);
 			this.writeClassFile(bytecodeGen.getClassFiles(), path);
 		} catch (ClassNotFoundException e) {
@@ -840,7 +733,7 @@ public class JavaTXCompiler {
 
 
 	public List<GenericGenratorResultForSourceFile> getGeneratedGenericResultsForAllSourceFiles()
-			throws ClassNotFoundException, IOException {
+			throws ClassNotFoundException {
 		List<GenericGenratorResultForSourceFile> result = new ArrayList<>();
 		for (File f : sourceFiles.keySet()) {
 			SourceFile sf = sourceFiles.get(f);
@@ -864,24 +757,8 @@ public class JavaTXCompiler {
 		return result;
 	}
 
-	public void generateBytecode() throws ClassNotFoundException, IOException, BytecodeGeneratorError {
-		generateBytecode((File) null);
-	}
-
-	/**
-	 * @param path - can be null, then class file output is in the same directory as the parsed source files
-	 */
+	// um pfad erweitern
 	public void generateBytecode(String path) throws ClassNotFoundException, IOException, BytecodeGeneratorError {
-		if(path != null)
-			generateBytecode(new File(path));
-		else
-			generateBytecode();
-	}
-
-	/**
-	 * @param path - can be null, then class file output is in the same directory as the parsed source files
-	 */
-	public void generateBytecode(File path) throws ClassNotFoundException, IOException, BytecodeGeneratorError {
 		List<ResultSet> typeinferenceResult = this.typeInference();
 		List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = getGeneratedGenericResultsForAllSourceFiles(
 				typeinferenceResult);
@@ -889,91 +766,35 @@ public class JavaTXCompiler {
 	}
 
 	/**
-	 * @param outputPath - can be null, then class file output is in the same directory as the parsed source files
+	 * @param path
 	 * @param typeinferenceResult
 	 * @param simplifyResultsForAllSourceFiles
 	 * @throws IOException
 	 */
-	public void generateBytecode(File outputPath, List<ResultSet> typeinferenceResult,
+	public void generateBytecode(String path, List<ResultSet> typeinferenceResult,
 			List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles) throws IOException {
 		for (File f : sourceFiles.keySet()) {
-			HashMap<JavaClassName, byte[]> classFiles = new HashMap<>();
+			HashMap<String, byte[]> classFiles = new HashMap<>();
 			SourceFile sf = sourceFiles.get(f);
-			File path;
-			if(outputPath == null){
-				path = f.getParentFile(); //Set path to path of the parsed .jav file
-			}else{
-				path = new File(outputPath ,sf.getPkgName().replace(".","/")); //add package path to root path
-			}
 			BytecodeGen bytecodeGen = new BytecodeGen(classFiles, typeinferenceResult, simplifyResultsForAllSourceFiles,
-					sf, path, classLoader);
+					sf, path);
 			bytecodeGen.visit(sf);
 			writeClassFile(bytecodeGen.getClassFiles(), path);
 		}
 	}
 
-	private void writeClassFile(HashMap<JavaClassName, byte[]> classFiles, File path) throws IOException {
+	private void writeClassFile(HashMap<String, byte[]> classFiles, String path) throws IOException {
 		FileOutputStream output;
-		for (JavaClassName name : classFiles.keySet()) {
+		for (String name : classFiles.keySet()) {
 			byte[] bytecode = classFiles.get(name);
 			System.out.println("generating " + name + ".class file ...");
 			// output = new FileOutputStream(new File(System.getProperty("user.dir") +
 			// "/testBytecode/generatedBC/" +name+".class"));
-			File outputFile = new File(path, name.getClassName() + ".class");
-			outputFile.getAbsoluteFile().getParentFile().mkdirs();
-			output = new FileOutputStream(outputFile);
+			output = new FileOutputStream(new File(path + name + ".class"));
 			output.write(bytecode);
 			output.close();
 			System.out.println(name + ".class file generated");
 		}
 	}
-	
-	/* PL 2020-03-17 mit TypeExchanger in FCGenerator.java zusammenfuehren */
-	/**
-     * Tauscht die GTVs in einem Typ gegen die entsprechenden Typen in der übergebenen Map aus.
-     */
-    private static class TypeExchanger implements TypeVisitor<RefTypeOrTPHOrWildcardOrGeneric>{
-
-        private final HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs;
-
-        TypeExchanger(HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs){
-            this.gtvs = gtvs;
-        }
-
-        @Override
-        public RefTypeOrTPHOrWildcardOrGeneric visit(RefType refType) {
-            List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
-            for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
-                params.add(param.acceptTV(this));
-            }
-            RefTypeOrTPHOrWildcardOrGeneric ret = new RefType(refType.getName(), params, new NullToken());
-            return ret;
-        }
-
-        @Override
-        public RefTypeOrTPHOrWildcardOrGeneric visit(SuperWildcardType superWildcardType) {
-        	SuperWildcardType ret = new SuperWildcardType(superWildcardType.getInnerType().acceptTV(this), superWildcardType.getOffset());
-            return ret;
-        }
-
-        @Override
-        public RefTypeOrTPHOrWildcardOrGeneric visit(TypePlaceholder typePlaceholder) {
-            throw new DebugException("Dieser Fall darf nicht auftreten");
-        }
-
-        @Override
-        public RefTypeOrTPHOrWildcardOrGeneric visit(ExtendsWildcardType extendsWildcardType) {
-        	ExtendsWildcardType ret = new ExtendsWildcardType(extendsWildcardType.getInnerType().acceptTV(this), extendsWildcardType.getOffset());
-            return ret;
-        }
-
-        @Override
-        public RefTypeOrTPHOrWildcardOrGeneric visit(GenericRefType genericRefType) {
-            if(! gtvs.containsKey(genericRefType.getParsedName()))
-                throw new DebugException("Dieser Fall darf nicht auftreten");
-            return gtvs.get(genericRefType.getParsedName());
-        }
-
-    }
 
 }

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

@@ -4,12 +4,18 @@ import java.io.File;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.net.URLClassLoader;
 import java.util.*;
 
-import com.google.common.collect.Lists;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import org.antlr.v4.runtime.tree.TerminalNode;
+import org.reflections.Reflections;
+import org.reflections.scanners.ResourcesScanner;
+import org.reflections.scanners.SubTypesScanner;
+import org.reflections.util.ClasspathHelper;
+import org.reflections.util.ConfigurationBuilder;
+import org.reflections.util.FilterBuilder;
 
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.JavaTXParser;
@@ -43,7 +49,8 @@ public class CompilationEnvironment {
 		 *
 		 */
 		//String bootClassPath = System.getProperty("sun.boot.class.path");
-		//		DirectoryClassLoader cl = DirectoryClassLoader.getPlatformClassLoader();
+		//		ClassLoader cl = ClassLoader.getPlatformClassLoader();
+				ClassLoader cl = ClassLoader.getSystemClassLoader();
 				String bootClassPath = System.getProperty("java.class.path");
 		librarys = new ArrayList<>();
 		for(String path : bootClassPath.split(File.pathSeparator)) {
@@ -60,44 +67,13 @@ public class CompilationEnvironment {
         this.packageCrawler = new PackageCrawler(librarys);
 	}
 
-	public JavaClassRegistry getRegistry(File forSourceFile, DirectoryClassLoader classLoader) throws ClassNotFoundException, IOException {
+	public JavaClassRegistry getRegistry(File forSourceFile) throws ClassNotFoundException, IOException {
 		Map<String, Integer> allNames;
 		CompilationUnitContext tree = JavaTXParser.parse(forSourceFile);
-		allNames = GatherNames.getNames(tree, packageCrawler, classLoader);
-		for(Class c : loadDefaultPackageClasses(forSourceFile, classLoader)){
-			allNames.put(c.getName(), c.getTypeParameters().length);
-		}
+		allNames = GatherNames.getNames(tree, packageCrawler);
 		return new JavaClassRegistry(allNames);
 	}
 
-	public static List<Class> loadDefaultPackageClasses(File forSourceFile, DirectoryClassLoader classLoader) throws IOException, ClassNotFoundException {
-		List<Class> ret = new ArrayList<>();
-		String packageName = getPackageName(JavaTXParser.parse(forSourceFile));
-		//Set classLoader to include default package for this specific source file
-		File dir = new File(forSourceFile.getAbsoluteFile().getParent());
-		String dirPath = dir.toString() + "/";
-		if(packageName.length()>0)dirPath = dirPath.substring(0,dirPath.length() - packageName.length());
-		String path = dirPath;
-		ArrayList<File> defaultPath = Lists.newArrayList(new File(path));
-		classLoader = new DirectoryClassLoader(defaultPath, classLoader);
-		//Gather all names in the default package for this source file (classes that are imported by default)
-		File [] files = dir.listFiles((dir1, name) -> name.endsWith(".class"));
-		if(files != null)for (File classFile : files) {
-			String className = classFile.getName().substring(0,classFile.getName().length()-6);
-			ret.add(classLoader.loadClass(packageName + className));
-        }
-		return ret;
-	}
-
-	private static String getPackageName(CompilationUnitContext forTree){
-		String packageName = "";
-		if(forTree.packageDeclaration() != null && forTree.packageDeclaration().Identifier() != null)
-		    for(TerminalNode subPackage : forTree.packageDeclaration().Identifier()){
-			    packageName += subPackage.toString() + ".";
-		}
-		return packageName;
-	}
-
 	public List<ClassOrInterface> getAllAvailableClasses() {
 		List<ClassOrInterface> ret = new ArrayList<>();
 		for(Class c : new PackageCrawler(librarys).getAllAvailableClasses()){

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

@@ -1,45 +0,0 @@
-package de.dhbwstuttgart.environment;
-
-import java.io.File;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class DirectoryClassLoader {
-    private final URLClassLoader classLoader;
-
-    public DirectoryClassLoader(File directory, java.lang.ClassLoader parent) {
-        classLoader = new URLClassLoader(generateURLArray(dirToURL(directory)), parent);
-    }
-
-    public DirectoryClassLoader(List<File> directory, java.lang.ClassLoader parent) {
-        classLoader = new URLClassLoader(directory.stream().map(DirectoryClassLoader::dirToURL).collect(Collectors.toList()).toArray(new URL[0]), parent);
-    }
-
-    public DirectoryClassLoader(File directory, DirectoryClassLoader parent) {
-        classLoader = new URLClassLoader(generateURLArray(dirToURL(directory)), parent.classLoader);
-    }
-
-    public DirectoryClassLoader(List<File> directory, DirectoryClassLoader parent) {
-        classLoader = new URLClassLoader(directory.stream().map(DirectoryClassLoader::dirToURL).collect(Collectors.toList()).toArray(new URL[0]), parent.classLoader);
-    }
-
-    private static URL[] generateURLArray(URL url) {
-        return new URL[]{url};
-    }
-
-    private static URL dirToURL(File url){
-        if(!url.isDirectory())throw new RuntimeException(url.toString() + " is not a directory");
-        try {
-            return url.toURI().toURL();
-        } catch (MalformedURLException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    public Class loadClass(String className) throws ClassNotFoundException {
-        return classLoader.loadClass(className);
-    }
-}

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

@@ -26,11 +26,11 @@ public class PackageCrawler {
 	
     public Set<Class<?>> getClassesInPackage(String packageName){
     	/*
-        List<DirectoryClassLoader> classLoadersList = new LinkedList<DirectoryClassLoader>();
+        List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
         classLoadersList.add(Thread.currentThread().getContextClassLoader());
         classLoadersList.add(ClasspathHelper.staticClassLoader());
         classLoadersList.add(Thread.currentThread().getContextClassLoader().getParent());
-        classLoadersList.add(DirectoryClassLoader.getSystemClassLoader());
+        classLoadersList.add(ClassLoader.getSystemClassLoader());
         String bootClassPath = System.getProperty("sun.boot.class.path");
         ArrayList<URL> urlList = new ArrayList<>();
         for(String path : bootClassPath.split(";")) {
@@ -41,7 +41,7 @@ public class PackageCrawler {
 			}
         }
         URL[] urls = urlList.toArray(new URL[0]);
-        classLoadersList.add(new URLClassLoader(urls, DirectoryClassLoader.getSystemClassLoader()));
+        classLoadersList.add(new URLClassLoader(urls, ClassLoader.getSystemClassLoader()));
         */
         Reflections reflections = new Reflections(new ConfigurationBuilder()
                 .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner())

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
-import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
@@ -23,16 +22,16 @@ public class FCGenerator {
      *
      * @param availableClasses - Alle geparsten Klassen
      */
-    public static Set<UnifyPair> toUnifyFC(Collection<ClassOrInterface> availableClasses, DirectoryClassLoader classLoader) throws ClassNotFoundException {
-        return toFC(availableClasses, classLoader).stream().map(t -> UnifyTypeFactory.convert(t)).collect(Collectors.toSet());
+    public static Set<UnifyPair> toUnifyFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
+        return toFC(availableClasses).stream().map(t -> UnifyTypeFactory.convert(t)).collect(Collectors.toSet());
     }
 
-    public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses, DirectoryClassLoader classLoader) throws ClassNotFoundException {
+    public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
         HashSet<Pair> pairs = new HashSet<>();
         //PL 2018-09-18: gtvs vor die for-Schleife gezogen, damit immer die gleichen Typeplaceholder eingesetzt werden.
         HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs = new HashMap<>();
         for(ClassOrInterface cly : availableClasses){
-            pairs.addAll(getSuperTypes(cly, availableClasses, gtvs, classLoader));
+            pairs.addAll(getSuperTypes(cly, availableClasses, gtvs));
         }
         return pairs;
     }
@@ -49,8 +48,8 @@ public class FCGenerator {
      * @param forType
      * @return
      */
-    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses, DirectoryClassLoader classLoader) throws ClassNotFoundException {
-        return getSuperTypes(forType, availableClasses, new HashMap<>(), classLoader);
+    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses) throws ClassNotFoundException {
+        return getSuperTypes(forType, availableClasses, new HashMap<>());
     }
 
     /**
@@ -62,7 +61,7 @@ public class FCGenerator {
      * @throws ClassNotFoundException
      */
     private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses,
-                                            HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs, DirectoryClassLoader classLoader) throws ClassNotFoundException {
+                                            HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs) throws ClassNotFoundException {
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
         //Die GTVs, die in forType hinzukommen:
         HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> newGTVs = new HashMap<>();
@@ -87,7 +86,7 @@ public class FCGenerator {
             ClassOrInterface superClass;
             if(!hasSuperclass.isPresent()) //Wenn es die Klasse in den available Klasses nicht gibt wird sie im Classpath gesucht. Ansonsten Exception
             {
-                superClass = ASTFactory.createClass(classLoader.loadClass(superType.getName().toString()));
+                superClass = ASTFactory.createClass(ClassLoader.getSystemClassLoader().loadClass(superType.getName().toString()));
             }else{
                 superClass = hasSuperclass.get();
             }
@@ -121,7 +120,7 @@ public class FCGenerator {
             if(superClass.getClassName().equals(ASTFactory.createObjectClass().getClassName())){
                 superTypes = Arrays.asList(new Pair(ASTFactory.createObjectType(), ASTFactory.createObjectType(), PairOperator.SMALLER));
             }else{
-                superTypes = getSuperTypes(superClass, availableClasses, newGTVs, classLoader);
+                superTypes = getSuperTypes(superClass, availableClasses, newGTVs);
             }
 
             retList.add(ret);

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

@@ -17,7 +17,6 @@ import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.tree.TerminalNode;
 
 import java.util.*;
-import java.util.stream.Collectors;
 
 public class StatementGenerator {
 
@@ -210,12 +209,7 @@ public class StatementGenerator {
         }else throw new NotImplementedException();
 
         ArgumentList argumentList = convert(methodInvocationContext.argumentList());
-        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = argumentList.getArguments().stream()
-        		.map(x -> TypePlaceholder.fresh(methodInvocationContext.getStart()))
-        		.collect(Collectors.toCollection(ArrayList::new));
-        MethodCall ret = new MethodCall(TypePlaceholder.fresh(methodInvocationContext.getStart()), 
-        		getReceiver(receiver), name, argumentList, TypePlaceholder.fresh(methodInvocationContext.getStart()), 
-        		argTypes, methodInvocationContext.getStart());
+        MethodCall ret = new MethodCall(TypePlaceholder.fresh(methodInvocationContext.getStart()), getReceiver(receiver), name, argumentList, methodInvocationContext.getStart());
         return ret;
     }
 
@@ -285,24 +279,9 @@ public class StatementGenerator {
     }
 
 
-    private Statement convert(Java8Parser.ClassInstanceCreationExpressionContext newExpression) {
-        Java8Parser.TypeArgumentsContext genericArgs = null;
-        if(newExpression.expressionName()!= null)throw new NotImplementedException();
-        if(newExpression.typeArgumentsOrDiamond()!= null){
-            if(newExpression.typeArgumentsOrDiamond().typeArguments()!=null){
-                genericArgs = newExpression.typeArgumentsOrDiamond().typeArguments();
-            }
-        }
-        if(newExpression.typeArguments()!= null)throw new NotImplementedException();
-
-        TerminalNode identifier = newExpression.Identifier(0);
-        RefType newClass = (RefType) TypeGenerator.convertTypeName(identifier.getText(),genericArgs,identifier.getSymbol(),reg,generics);
-
-        ArgumentList args = convert(newExpression.argumentList());
-        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = args.getArguments().stream()
-        		.map(x -> TypePlaceholder.fresh(newExpression.getStart()))
-        		.collect(Collectors.toCollection(ArrayList::new));
-        return new NewClass(newClass, args, null, argTypes, newExpression.getStart());
+    private Statement convert(Java8Parser.ClassInstanceCreationExpressionContext stmt) {
+        //TODO
+        throw new NotImplementedException();
     }
 
     private Statement convert(Java8Parser.PreIncrementExpressionContext stmt) {
@@ -788,14 +767,10 @@ public class StatementGenerator {
         }else {
             Java8Parser.MethodInvocation_lf_primaryContext ctxt = e.methodInvocation_lf_primary();
             String methodName = ctxt.Identifier().toString();
-            ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = ctxt.argumentList().expression().stream()
-            		.map(x -> TypePlaceholder.fresh(e.getStart()))
-            		.collect(Collectors.toCollection(ArrayList::new));
-            return new MethodCall(TypePlaceholder.fresh(e.getStart()), getReceiver(expr), methodName, 
-            		convert(ctxt.argumentList()), TypePlaceholder.fresh(e.getStart()), argTypes, e.getStart());
+            return new MethodCall(TypePlaceholder.fresh(e.getStart()), getReceiver(expr), methodName, convert(ctxt.argumentList()), e.getStart());
         }
     }
-    
+
     private Expression convert(Java8Parser.ArrayCreationExpressionContext expression) {
         throw new NotImplementedException();
     }
@@ -846,10 +821,7 @@ public class StatementGenerator {
         RefType newClass = (RefType) TypeGenerator.convertTypeName(identifier.getText(),genericArgs,identifier.getSymbol(),reg,generics);
 
         ArgumentList args = convert(newExpression.argumentList());
-        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = args.getArguments().stream()
-        		.map(x -> TypePlaceholder.fresh(newExpression.getStart()))
-        		.collect(Collectors.toCollection(ArrayList::new));
-        return new NewClass(newClass, args, null, argTypes, newExpression.getStart());
+        return new NewClass(newClass, args, newExpression.getStart());
     }
 
     private Expression convert(Java8Parser.LiteralContext literal) {
@@ -907,12 +879,7 @@ public class StatementGenerator {
         }
 
         ArgumentList argumentList = convert(methodInvocationContext.argumentList());
-        ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = argumentList.getArguments().stream()
-        		.map(x -> TypePlaceholder.fresh(methodInvocationContext.getStart()))
-        		.collect(Collectors.toCollection(ArrayList::new));
-        MethodCall ret = new MethodCall(TypePlaceholder.fresh(methodInvocationContext.getStart()), 
-        		getReceiver(receiver), name, argumentList, TypePlaceholder.fresh(methodInvocationContext.getStart()),
-        		argTypes, methodInvocationContext.getStart());
+        MethodCall ret = new MethodCall(TypePlaceholder.fresh(methodInvocationContext.getStart()), getReceiver(receiver), name, argumentList, methodInvocationContext.getStart());
         return ret;
     }
 

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
-import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.environment.PackageCrawler;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import java.lang.ClassNotFoundException;
@@ -20,7 +19,6 @@ import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
 import java.lang.reflect.Modifier;
-import java.net.URL;
 import java.sql.Ref;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -76,10 +74,10 @@ public class SyntaxTreeGenerator{
     return ret;
   }
   
-  public SourceFile convert(Java8Parser.CompilationUnitContext ctx, PackageCrawler packageCrawler, DirectoryClassLoader classLoader) throws ClassNotFoundException{
+  public SourceFile convert(Java8Parser.CompilationUnitContext ctx, PackageCrawler packageCrawler) throws ClassNotFoundException{
     if(ctx.packageDeclaration()!=null)this.pkgName = convert(ctx.packageDeclaration());
     List<ClassOrInterface> classes = new ArrayList<>();
-    Map<String, Integer> imports = GatherNames.getImports(ctx, packageCrawler, classLoader);
+    Map<String, Integer> imports = GatherNames.getImports(ctx, packageCrawler);
     this.imports = imports.keySet().stream().map(name -> reg.getName(name)).collect(Collectors.toSet());
     for(Java8Parser.TypeDeclarationContext typeDecl : ctx.typeDeclaration()){
       ClassOrInterface newClass;
@@ -361,7 +359,7 @@ public class SyntaxTreeGenerator{
             && fieldDeclarationContext.unannTypeOrAuto().unannType() != null){
       fieldType = TypeGenerator.convert(fieldDeclarationContext.unannTypeOrAuto().unannType(), reg, generics);
     }else{
-      fieldType = TypePlaceholder.fresh(fieldDeclarationContext.getStart());
+      fieldType = TypePlaceholder.fresh(fieldDeclarationContext.variableDeclaratorList().getStart()); //PL 2019-12-06: variableDeclaratorList() eingefuegt, um als Token nicht die Modifier zu bekommen
     }
     for(Java8Parser.VariableDeclaratorContext varCtx : fieldDeclarationContext.variableDeclaratorList().variableDeclarator()){
       String fieldName = convert(varCtx.variableDeclaratorId());

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

@@ -1,14 +1,13 @@
 package de.dhbwstuttgart.parser.scope;
 
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
-import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.parser.antlr.Java8BaseListener;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
 import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.antlr.v4.runtime.tree.TerminalNode;
 
 import de.dhbwstuttgart.environment.PackageCrawler;
@@ -16,7 +15,7 @@ import de.dhbwstuttgart.parser.antlr.Java8Parser;
 
 public class GatherNames {
 
-	  public static Map<String, Integer> getNames(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages, DirectoryClassLoader classLoader) throws ClassNotFoundException{
+	  public static Map<String, Integer> getNames(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages) throws ClassNotFoundException{
 		  Map<String, Integer> ret = new HashMap<>();
 	    String pkgName = getPackageName(ctx);
 	    String nameString = "";
@@ -65,12 +64,14 @@ public class GatherNames {
 	        }
 	      }
 	    }
-		  ret.putAll(getImports(ctx, packages, classLoader));
-		  return ret;
+	    ret.putAll(getImports(ctx, packages));
+	    return ret;
 	  }
+	  
 
-	public static Map<String, Integer> getImports(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages, DirectoryClassLoader classLoader) throws ClassNotFoundException {
+	  public static Map<String, Integer> getImports(Java8Parser.CompilationUnitContext ctx, PackageCrawler packages) throws ClassNotFoundException {
 		  Map<String, Integer> ret = new HashMap<>();
+	    ClassLoader classLoader = ClassLoader.getSystemClassLoader();
 		  //ret.putAll(packages.getClassNames("java.lang"));
 		  for(Java8Parser.ImportDeclarationContext importDeclCtx : ctx.importDeclaration()){
 	      if(importDeclCtx.singleTypeImportDeclaration() != null){

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

@@ -84,15 +84,7 @@ public class JavaClassName {
 
 	@Override
 	public String toString() {
-		return (packageName!=null ? packageName.toString() + "." : "") + name;
-	}
-
-	public String getPackageName() {
-		return (packageName!=null ? packageName.toString() : "");
-	}
-
-	public String getClassName(){
-		return name;
+		return (packageName!=null ? packageName.toString() : "") + name;
 	}
 }
 
@@ -138,9 +130,6 @@ class PackageName{
 		String ret = "";
 		if(names == null)return "";
 		for(String n : names)ret+=n+".";
-		if (ret != null && ret.length() > 0 && ret.charAt(ret.length() - 1) == '.') {
-			ret = ret.substring(0, ret.length() - 1);
-		}
 		return ret;
 	}
 }

src/main/java/de/dhbwstuttgart/sat/asp/writer/ASPFactory.java

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.sat.asp.writer;
 
-import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
 import de.dhbwstuttgart.sat.asp.ASPStringConverter;
@@ -17,9 +16,9 @@ import java.util.*;
 
 public class ASPFactory implements TypeVisitor<String>{
 
-    public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses, DirectoryClassLoader classLoader) throws ClassNotFoundException{
+    public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses) throws ClassNotFoundException{
         ASPFactory factory = new ASPFactory();
-        factory.convertFC(fcClasses, classLoader);
+        factory.convertFC(fcClasses);
         List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
         for(Constraint<Pair> constraint : constraints1){
             for(Pair p : constraint){
@@ -33,8 +32,8 @@ public class ASPFactory implements TypeVisitor<String>{
     ASPWriter writer = new ASPWriter();
     boolean isFCType = false;
 
-    private void convertFC(Collection<ClassOrInterface> classes, DirectoryClassLoader classLoader) throws ClassNotFoundException {
-        Set<Pair> fc = FCGenerator.toFC(classes, classLoader);
+    private void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
+        Set<Pair> fc = FCGenerator.toFC(classes);
         isFCType = true;
         for(Pair fcp : fc){
             convertPair(fcp);

src/main/java/de/dhbwstuttgart/sat/asp/writer/ASPGencayFactory.java

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.sat.asp.writer;
 
-import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
 import de.dhbwstuttgart.sat.asp.ASPStringConverter;
@@ -56,9 +55,9 @@ public class ASPGencayFactory implements TypeVisitor<String> {
         return ret;
     }
 
-    public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses, DirectoryClassLoader classLoader) throws ClassNotFoundException{
+    public static String generateASP(ConstraintSet<Pair> constraints, Collection<ClassOrInterface> fcClasses) throws ClassNotFoundException{
         ASPGencayFactory factory = new ASPGencayFactory();
-        factory.convertFC(fcClasses, classLoader);
+        factory.convertFC(fcClasses);
         List<Constraint<Pair>> constraints1 = constraints.cartesianProduct().iterator().next();
         for(Constraint<Pair> constraint : constraints1){
             for(Pair p : constraint){
@@ -70,8 +69,8 @@ public class ASPGencayFactory implements TypeVisitor<String> {
         return factory.writer.getASPFile();
     }
 
-    private void convertFC(Collection<ClassOrInterface> classes, DirectoryClassLoader classLoader) throws ClassNotFoundException {
-        Set<Pair> fc = FCGenerator.toFC(classes, classLoader);
+    private void convertFC(Collection<ClassOrInterface> classes) throws ClassNotFoundException {
+        Set<Pair> fc = FCGenerator.toFC(classes);
         isFCType = true;
         for(Pair fcp : fc){
             generateTheta((RefType) fcp.TA1);

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

@@ -34,7 +34,6 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
   private List<RefType> implementedInterfaces;
   private List<Constructor> constructors;
 
-  
   public ClassOrInterface(int modifiers, JavaClassName name, List<Field> fielddecl, Optional<Constructor> fieldInitializations, List<Method> methods, List<Constructor> constructors, GenericDeclarationList genericClassParameters,
                           RefType superClass, Boolean isInterface, List<RefType> implementedInterfaces, Token offset){
     super(offset);
@@ -51,23 +50,6 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
     this.constructors = constructors;
   }
   
-  /* erzeugt fuer Fields, Konstruktoren und Methoden neue ArrayList-Objekte 
-   * alle anderen Datenobjekte werden nur kopiert.
-   */
-  public ClassOrInterface(ClassOrInterface cl){
-	  super(cl.getOffset());
-	  this.modifiers = cl.modifiers;
-	  this.name = cl.name;
-	  this.fields = new ArrayList<>(cl.fields);
-	  this.fieldInitializations= cl.fieldInitializations;
-	  this.genericClassParameters = cl.genericClassParameters;
-	  this.superClass = cl.superClass;
-	  this.isInterface = cl.isInterface;
-	  this.implementedInterfaces = cl.implementedInterfaces;
-	  this.methods = new ArrayList<>(cl.methods);
-	  this.constructors = new ArrayList<>(cl.constructors);
-  }
-  
   // Gets class name
   public JavaClassName getClassName(){
     return this.name;

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

@@ -27,7 +27,7 @@ public class Constructor extends Method {
 	 */
 	protected static Block prepareBlock(Block constructorBlock /*, List<Statement> fieldInitializations new ArrayList<>() geloescht PL 2018-11-24 */){
 		List<Statement> statements = constructorBlock.getStatements();
-		statements.add(0, new SuperCall(null, null, constructorBlock.getOffset()));
+		statements.add(0, new SuperCall(constructorBlock.getOffset()));
 		/* statements.addAll(fieldInitializations); geloescht PL 2018-11-24 */
 		return new Block(statements, constructorBlock.getOffset());
 	}

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

@@ -6,7 +6,7 @@ import org.antlr.v4.runtime.Token;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 
 /**
- * Eine Feldinitialisation steht für eine Felddeklaration mit gleichzeitiger Wertzuweisung
+ * Eine Feldinitialisation steht für eine Felddeklaration mit gleichzeitiger Wertzuweisung
  * Beispiel: 'public Feld FeldVar = FeldWert;'
  * @author janulrich
  *
@@ -17,7 +17,7 @@ public class FieldDeclaration extends Field{
 	
     /**
      * Dieser Konstruktor der FieldDeclaration erstellt den Syntaxknoten vollständig.
-     * Kein nachträgliches hinzfügen von Informationen oder aufrufen von parserPostProcessing ist notwendig.
+     * Kein nachträgliches hinzfügen von Informationen oder aufrufen von parserPostProcessing ist notwendig.
      */
     public FieldDeclaration(String name, RefTypeOrTPHOrWildcardOrGeneric typ, int modifier, Expression value, Token offset){
     	super(name, typ, modifier, offset);//Dieser Deklarator wird nicht vom Parser aufgerufen. Dadurch gibt es auch keinen Offset

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

@@ -63,7 +63,7 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 
 	@Override
 	public Token getOffset() {
-		return null;
+		return super.getOffset();
 	}
 
 	public String getName() {

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

@@ -26,13 +26,6 @@ public class SourceFile extends SyntaxTreeNode{
     this.imports = imports;
   }
   
-  public SourceFile(SourceFile sf) {
-	  super(new NullToken());
-	  this.KlassenVektor = new ArrayList<>(sf.KlassenVektor);
-	  this.imports = new HashSet<>(sf.imports);
-  }
-  
-  
   public String getPkgName(){
     return this.pkgName;
   }

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

@@ -70,7 +70,7 @@ public class ASTFactory {
 	}
 
 	private static Field createField(java.lang.reflect.Field field, JavaClassName jreClass) {
-		return new Field(field.getName(), createType(field.getGenericType()), field.getModifiers(), new NullToken());
+		return new Field(field.getName(), createType(field.getType()), field.getModifiers(), new NullToken());
 	}
 
 	//private static RefType createType(Class classType) {
@@ -189,11 +189,11 @@ public class ASTFactory {
 
 	public static de.dhbwstuttgart.syntaxtree.GenericTypeVar createGeneric(TypeVariable jreTypeVar, String jreTVName, Class context, String parentMethod){
 		JavaClassName parentClass = new JavaClassName(context.getName());
-		List<RefTypeOrTPHOrWildcardOrGeneric> genericBounds = new ArrayList<>();
+		List<RefType> genericBounds = new ArrayList<>();
 		java.lang.reflect.Type[] bounds = jreTypeVar.getBounds();
 		if(bounds.length > 0){
 			for(java.lang.reflect.Type bound : bounds){
-				genericBounds.add(createType(bound));
+				genericBounds.add((RefType) createType(bound));
 			}
 		}
 		return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(jreTVName, genericBounds, new NullToken(), new NullToken());

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

@@ -7,7 +7,6 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
-import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
@@ -32,7 +31,7 @@ public class UnifyTypeFactory {
 	
 	private static ArrayList<PlaceholderType> PLACEHOLDERS = new ArrayList<>(); 
 
-    public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses, Writer logFile, DirectoryClassLoader classLoader) throws ClassNotFoundException {
+    public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses, Writer logFile) throws ClassNotFoundException {
         /*
         Die transitive Hülle muss funktionieren.
         Man darf schreiben List<A> extends AL<A>
@@ -43,7 +42,7 @@ public class UnifyTypeFactory {
         Generell dürfen sie immer die gleichen Namen haben.
         TODO: die transitive Hülle bilden
          */
-        return new FiniteClosure(FCGenerator.toUnifyFC(fromClasses, classLoader), logFile);
+        return new FiniteClosure(FCGenerator.toUnifyFC(fromClasses), logFile);
     }
 
     public static UnifyPair generateSmallerPair(UnifyType tl, UnifyType tr){
@@ -123,7 +122,6 @@ public class UnifyTypeFactory {
     		System.out.println("XXX"+innerType);
     	}
     	PlaceholderType ntph = new PlaceholderType(tph.getName());
-    	ntph.setVariance(tph.getVariance());
     	int in = PLACEHOLDERS.indexOf(ntph);
 		if (in == -1) {
 			PLACEHOLDERS.add(ntph);

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

@@ -21,24 +21,13 @@ public class MethodCall extends Statement
 {
     public final String name;
     public final Receiver receiver;
-    
     public final ArgumentList arglist;
-    
-    /*
-     * noetig fuer Bytecodegenerierung
-     */
-    public RefTypeOrTPHOrWildcardOrGeneric receiverType;
-    public final ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes;
-    
 
-    public MethodCall(RefTypeOrTPHOrWildcardOrGeneric retType, Receiver receiver, String methodName, ArgumentList argumentList, 
-    		          RefTypeOrTPHOrWildcardOrGeneric receiverType, ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes, Token offset){
+    public MethodCall(RefTypeOrTPHOrWildcardOrGeneric retType, Receiver receiver, String methodName, ArgumentList argumentList, Token offset){
 		super(retType,offset);
 		this.arglist = argumentList;
         this.name = methodName;
         this.receiver = receiver;
-        this.receiverType = receiverType;
-        this.argTypes = argTypes;
 	}
 
     @Override

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

@@ -29,10 +29,8 @@ public class NewClass extends MethodCall
      * @param args Argumente mit denen der New-Call aufgerufen wurde
      * @param start
      */
-    public NewClass(RefType newClass, ArgumentList args, RefTypeOrTPHOrWildcardOrGeneric receiverType, 
-    		ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes, Token start) {
-        super(newClass, new ExpressionReceiver(new EmptyStmt(start)), newClass.getName().toString(), 
-        		args, receiverType, argTypes, start);
+    public NewClass(RefType newClass, ArgumentList args, Token start) {
+        super(newClass, new ExpressionReceiver(new EmptyStmt(start)), newClass.getName().toString(), args, start);
     }
 
     @Override

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

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import org.antlr.v4.runtime.Token;
 
@@ -13,14 +12,12 @@ import java.util.ArrayList;
 
 public class SuperCall extends MethodCall
 {
-    public SuperCall(RefTypeOrTPHOrWildcardOrGeneric receiverType, 
-    		ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes, Token offset){
-        this(new ArgumentList(new ArrayList<Expression>(), offset), receiverType, argTypes, offset);
+    public SuperCall(Token offset){
+        this(new ArgumentList(new ArrayList<Expression>(), offset),offset);
     }
 
-    public SuperCall(ArgumentList argumentList, RefTypeOrTPHOrWildcardOrGeneric receiverType, 
-    		ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes, Token offset){
-        super(new Void(offset), new ExpressionReceiver(new This(offset)), "<init>", argumentList, receiverType, argTypes, offset);
+    public SuperCall(ArgumentList argumentList, Token offset){
+        super(new Void(offset), new ExpressionReceiver(new This(offset)), "<init>", argumentList, offset);
     }
 
 

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

@@ -8,7 +8,7 @@ public class ThisCall extends MethodCall
 {
     public ThisCall(Receiver receiver, ArgumentList arglist, int offset)
     {
-		super(null, null, null, null, null, null, null);
+		super(null, null, null, null, null);
 
 	}
     

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

@@ -18,12 +18,7 @@ import org.antlr.v4.runtime.Token;
 public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
 {
 	private final String name;
-	
-	/**
-	 * wird bisher nicht genutzt
-	 * setVariance muss ggf. auskommentiert werden.
-	 */
-	int variance = 0;
+
 
 
     /**
@@ -41,7 +36,7 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
     /**
      * @author Andreas Stadelmeier, a10023
      * Ruft die TypePlaceholder.fresh()-Methode auf.
-     * Fügt zusätzlich einen Replacementlistener hinzu.
+     * Fügt zusätzlich einen Replacementlistener hinzu.
      * @return
      */
     public static TypePlaceholder fresh(Token position){
@@ -74,16 +69,6 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
         return name;
     }
 
-    /* wird bisher nicht genutzt
-    public void setVariance(int variance) {
-    	this.variance= variance;
-    }
-    */
-    
-    public int getVariance() {
-    	return this.variance;
-    }
-    
     @Override
     public void accept(ASTVisitor visitor) {
         visitor.visit(this);

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

@@ -0,0 +1,7 @@
+package de.dhbwstuttgart.typedeployment;
+
+public enum KindOfTypeInsertPoint {
+	NORMAL_INSERT,
+	GENERIC_CLASS_INSERT,
+	GENERERIC_METHOD_INSERT
+}

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

@@ -1,8 +1,13 @@
 package de.dhbwstuttgart.typedeployment;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Set;
+import java.util.TreeSet;
+
+import org.antlr.v4.parse.BlockSetTransformer.setAlt_return;
 
 import de.dhbwstuttgart.syntaxtree.statement.This;
 import de.dhbwstuttgart.typeinference.result.ResultPair;
@@ -23,10 +28,15 @@ public class TypeInsert {
 
     public String insert(String intoSource){
         List<TypeInsertPoint> offsets = new ArrayList<>();
-        String ret = point.insert(intoSource, offsets);
-        offsets.add(point);
-        for(TypeInsertPoint insertPoint : inserts){
-            ret = insertPoint.insert(ret, offsets);
+        String ret = intoSource;
+        
+        List<TypeInsertPoint> insertsSorted = new ArrayList<>();
+        insertsSorted.add(point);
+        insertsSorted.addAll(inserts);
+        Collections.sort(insertsSorted, new TypeInsertPoint.TypeInsertPointPositionComparator().reversed());
+        
+        for(TypeInsertPoint insertPoint : insertsSorted) {
+            ret = insertPoint.insert(ret, new ArrayList<>());
             offsets.add(insertPoint);
         }
         return ret;
@@ -56,7 +66,14 @@ public class TypeInsert {
     }
     
     public Set<TypeInsertPoint> getAdditionalPoints() {
-    	return this.inserts;
+    	TypeInsertPoint.TypeInsertPointPositionComparator comparator = new TypeInsertPoint.TypeInsertPointPositionComparator();
+		TreeSet<TypeInsertPoint> result = new TreeSet<>(comparator.reversed());
+    	result.addAll(inserts);
+    	return result;
+    }
+    
+    public Set<TypeInsertPoint> getAdditionalPointsUnsorted() {
+    	return inserts;
     }
     
     public String toString() {

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

@@ -1,20 +1,35 @@
 package de.dhbwstuttgart.typedeployment;
 
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import org.antlr.v4.runtime.Token;
+import org.objectweb.asm.Type;
+
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericsGeneratorResult;
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericsGeneratorResultForClass;
 import de.dhbwstuttgart.bytecode.utilities.MethodUtility;
 import de.dhbwstuttgart.bytecode.utilities.Resolver;
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.syntaxtree.*;
-import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.typeinference.result.*;
-
-import org.antlr.v4.runtime.Token;
-import org.objectweb.asm.Type;
-
-import java.util.*;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.PairTPHEqualTPH;
+import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
+import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
+import de.dhbwstuttgart.typeinference.result.ResolvedType;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
 
 /**
  * TODO:
@@ -33,49 +48,58 @@ public class TypeInsertFactory {
 
 	private static List<ResultSet> newResults;
 
-    public static Set<TypeInsert> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults, List<ResultSet> newResults){
+    public static Set<TypeInsert> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults, List<ResultSet> newResults, List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles){
     	TypeInsertFactory.newResults = newResults;
-    	return new TypeInsertPlacer().getTypeInserts(forSourcefile, withResults);
+    	return new TypeInsertPlacer().getTypeInserts(forSourcefile, withResults, simplifyResultsForAllSourceFiles);
     }
 
     public static TypeInsert createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m,
-                                                ResultSet resultSet) {
+                                                ResultSet resultSet, List<GenericsGeneratorResult> constraints, List<GenericsGeneratorResult> classConstraints) {
         
-		try {
+    	/* PL 2020-04-11 auskommentiert
+    	 * try {
+    	 */
 			ResolvedType resolvedType = resultSet.resolveType(type);
 			TypeInsertPoint insertPoint = new TypeInsertPoint(offset,
-					new TypeToInsertString(resolvedType.resolvedType).insert); 
+					new TypeToInsertString(resolvedType.resolvedType, constraints, classConstraints).insert, KindOfTypeInsertPoint.NORMAL_INSERT); 
+			/* PL 2020-04-11 auskommentiert
 			List<GenericGenratorResultForSourceFile> simplifyResults = JavaTXCompiler.INSTANCE.getGeneratedGenericResultsForAllSourceFiles(newResults);
 			for (GenericGenratorResultForSourceFile simplifyResultsEntries : simplifyResults) {
-				GenericsGeneratorResultForClass genericResultsForClass = simplifyResultsEntries.getSimplifyResultsByName(cl.getClassName());
+				GenericsGeneratorResultForClass genericResultsForClass = simplifyResultsEntries.getSimplifyResultsByName("", cl.getClassName().toString());
 				return new TypeInsert(insertPoint, createGenericInsert(genericResultsForClass, cl, m, resultSet, offset), resolvedType.getResultPair());
 			}
 			
 			return new TypeInsert(insertPoint, new HashSet<>(), resolvedType.getResultPair());
+			*/
+			//GenericsGeneratorResultForClass genericResultsForClass = genericResult.getSimplifyResultsByName("", cl.getClassName().toString());
+			return new TypeInsert(insertPoint, createGenericInsert(constraints, classConstraints, cl, m, resultSet, offset), resolvedType.getResultPair());
+		
+		/* PL 2020-04-11 auskommentiert
 		} catch (ClassNotFoundException e) {
 			e.printStackTrace();
 		    return null;
 		}
+		*/
     }
 
-    private static synchronized Set<TypeInsertPoint> createGenericInsert(GenericsGeneratorResultForClass genericResult, ClassOrInterface cl, Method m, ResultSet resultSet, Token mOffset){
-        Set<TypeInsertPoint> result = createGenericClassInserts(genericResult, cl);
-        
-        for (Method method : cl.getMethods()) {        	
-        	Resolver resolver = new Resolver(resultSet);
-        	List<GenericsGeneratorResult> methodConstraints = genericResult.getMethodConstraintsByID(MethodUtility.createID(resolver, method));
-        	result.addAll(createMethodConstraints(method, methodConstraints, mOffset));
-        }
+    private static synchronized Set<TypeInsertPoint> createGenericInsert(List<GenericsGeneratorResult> methodConstraints, List<GenericsGeneratorResult> classConstraints,ClassOrInterface cl, Method m, ResultSet resultSet, Token mOffset){
+        Set<TypeInsertPoint> result = createGenericClassInserts(classConstraints, cl);
+         	 
+    	Resolver resolver = new Resolver(resultSet);
+    	
+    	if (m != null) {
+        	//List<GenericsGeneratorResult> methodConstraints = genericResult.getMethodConstraintsByID(MethodUtility.createID(resolver, m));
+        	result.addAll(createMethodConstraints(methodConstraints, m.getOffset() != null ? m.getOffset() : mOffset));
+    	}
         
         return result;
     }
     
-    private static Set<TypeInsertPoint> createMethodConstraints(Method method, List<GenericsGeneratorResult> constraints, Token mOffset) {
+    private static Set<TypeInsertPoint> createMethodConstraints(List<GenericsGeneratorResult> constraints, Token mOffset) {
     	Set<TypeInsertPoint> result = new HashSet<>();
     	Token offset = mOffset;
 
 		if (constraints.size() == 0) {
-			result.add(new TypeInsertPoint(offset, ""));
 			return result;
 		} 
 		
@@ -85,25 +109,25 @@ public class TypeInsertFactory {
         	if (genericInsertConstraint.getConstraint().getRight().equals(Type.getInternalName(Object.class))) {
         		insert += genericInsertConstraint.getConstraint().getLeft();
         	} else {        		
-        		insert += genericInsertConstraint.getConstraint().getLeft() + " extends " + genericInsertConstraint.getConstraint().getRight() + ", ";
+        		insert += genericInsertConstraint.getConstraint().getLeft() + " extends " + genericInsertConstraint.getConstraint().getRight();
         	}
+        	insert += ", ";
         }
         
         insert = insert.substring(0, insert.length() -2);
         insert += ">";
 
-        result.add(new TypeInsertPoint(offset, insert));
+        result.add(new TypeInsertPoint(offset, insert, KindOfTypeInsertPoint.GENERERIC_METHOD_INSERT));
     	return result;
     }
 
-	private static Set<TypeInsertPoint> createGenericClassInserts(GenericsGeneratorResultForClass genericResult, ClassOrInterface cl) {
+	private static Set<TypeInsertPoint> createGenericClassInserts(List<GenericsGeneratorResult> classConstraints, ClassOrInterface cl) {
 		Set<TypeInsertPoint> result = new HashSet<>();
 		Token offset = cl.getGenerics().getOffset();
     	
-        List<GenericsGeneratorResult> classConstraints = genericResult.getClassConstraints();
+        //List<GenericsGeneratorResult> classConstraints = genericResult.getClassConstraints();
         
-		if (classConstraints.size() == 0) {
-			result.add(new TypeInsertPoint(offset, ""));
+		if (classConstraints == null || classConstraints.size() == 0) {
 			return result;
 		} 
 		
@@ -113,14 +137,15 @@ public class TypeInsertFactory {
         	if (genericInsertConstraint.getConstraint().getRight().equals(Type.getInternalName(Object.class))) {
         		insert += genericInsertConstraint.getConstraint().getLeft();
         	} else {        		
-        		insert += genericInsertConstraint.getConstraint().getLeft() + " extends " + genericInsertConstraint.getConstraint().getRight() + ", ";
+        		insert += genericInsertConstraint.getConstraint().getLeft() + " extends " + genericInsertConstraint.getConstraint().getRight();
         	}
+        	insert +=  ", ";
         }
 
         insert = insert.substring(0, insert.length() -2);
         insert += ">";
 
-        result.add(new TypeInsertPoint(offset, insert));
+        result.add(new TypeInsertPoint(offset, insert, KindOfTypeInsertPoint.GENERIC_CLASS_INSERT));
         
         return result;
 	}
@@ -128,9 +153,14 @@ public class TypeInsertFactory {
 
 class TypeToInsertString implements ResultSetVisitor{
     String insert = "";
+    private List<GenericsGeneratorResult> constraints;
+    private List<GenericsGeneratorResult> classConstraints;
+    
 
-    TypeToInsertString(RefTypeOrTPHOrWildcardOrGeneric type){
-        type.accept(this);
+    TypeToInsertString(RefTypeOrTPHOrWildcardOrGeneric type, List<GenericsGeneratorResult> constraints, List<GenericsGeneratorResult> classConstraints){
+        this.constraints = constraints;
+        this.classConstraints = classConstraints;
+    	type.accept(this);
     }
 
     @Override
@@ -156,7 +186,7 @@ class TypeToInsertString implements ResultSetVisitor{
             Iterator<RefTypeOrTPHOrWildcardOrGeneric> iterator = resolved.getParaList().iterator();
             while(iterator.hasNext()){
                 RefTypeOrTPHOrWildcardOrGeneric typeParam = iterator.next();
-                insert += new TypeToInsertString(typeParam).insert;
+                insert += new TypeToInsertString(typeParam, constraints, classConstraints).insert;
                 if(iterator.hasNext())insert += ", ";
             }
             insert += ">";
@@ -170,16 +200,37 @@ class TypeToInsertString implements ResultSetVisitor{
 
     @Override
     public void visit(SuperWildcardType superWildcardType) {
-        insert += "? super " + new TypeToInsertString(superWildcardType.getInnerType()).insert;
+        insert += "? super " + new TypeToInsertString(superWildcardType.getInnerType(), constraints, classConstraints).insert;
     }
 
     @Override
     public void visit(TypePlaceholder typePlaceholder) {
-        insert += typePlaceholder.getName();
+    	String realName = typePlaceholder.getName();
+        //String realName = sig2.substring(1, sig2.length() - 1);
+		//String toVisit = realName+SPECIAL_CHAR;
+		//if(!genericsAndBounds.containsKey(toVisit)) {//PL 202-04-1 vielleicht braucht man das, vgl. Signature.java
+			Optional<GenericsGeneratorResult> equalTPH = getEqualTPHFromClassConstraints(classConstraints, realName);
+			if(equalTPH.isPresent()){
+				insert += equalTPH.get().getConstraint().getLeft();// + SPECIAL_CHAR;
+			} else {
+				insert += getEqualTPH(constraints, realName);// + SPECIAL_CHAR;
+			}
     }
 
     @Override
     public void visit(ExtendsWildcardType extendsWildcardType) {
-        insert += "? extends " + new TypeToInsertString(extendsWildcardType.getInnerType()).insert;
+        insert += "? extends " + new TypeToInsertString(extendsWildcardType.getInnerType(), constraints, classConstraints).insert;
     }
+    
+    private Optional<GenericsGeneratorResult> getEqualTPHFromClassConstraints(List<GenericsGeneratorResult> listOfConstraints, String tph) {
+		return listOfConstraints.stream()
+				.filter(c -> c.getConstraint().getLeft().equals(tph) || c.getEqualsTPHs().contains(tph))
+				.findFirst();
+	}
+    
+    private String getEqualTPH(List<GenericsGeneratorResult> constraints2, String tph) {
+		return constraints2.stream()
+				.filter(c -> c.getConstraint().getLeft().equals(tph) || c.getEqualsTPHs().contains(tph))
+				.findFirst().get().getConstraint().getLeft();
+	}
 }

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

@@ -1,10 +1,16 @@
 package de.dhbwstuttgart.typedeployment;
 
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericsGeneratorResult;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericsGeneratorResultForClass;
+import de.dhbwstuttgart.bytecode.utilities.MethodUtility;
+import de.dhbwstuttgart.bytecode.utilities.Resolver;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
+import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -12,47 +18,68 @@ import java.util.Set;
 public class TypeInsertPlacer extends AbstractASTWalker{
     Set<TypeInsert> inserts = new HashSet<>();
     private ResultSet withResults;
+    String pkgName;
+    private List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles;
 
-    public Set<TypeInsert> getTypeInserts(SourceFile forSourceFile, ResultSet withResults){
+    public Set<TypeInsert> getTypeInserts(SourceFile forSourceFile, ResultSet withResults, List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles){
         this.withResults = withResults;
+        this.simplifyResultsForAllSourceFiles = simplifyResultsForAllSourceFiles;
+        pkgName = forSourceFile.getPkgName();
         forSourceFile.accept(this);
         return inserts;
     }
 
     @Override
     public void visit(ClassOrInterface classOrInterface) {
-        TypeInsertPlacerClass cl = new TypeInsertPlacerClass(classOrInterface, withResults);
+    	GenericsGeneratorResultForClass generatedGenerics = simplifyResultsForAllSourceFiles
+    			.stream()
+    			.map(sr->sr.getSimplifyResultsByName(pkgName, classOrInterface.getClassName().toString()))
+    			.findFirst()
+    			.get();
+        TypeInsertPlacerClass cl = new TypeInsertPlacerClass(classOrInterface, withResults, generatedGenerics);
         this.inserts.addAll(cl.inserts);
     }
 }
 
 class TypeInsertPlacerClass extends AbstractASTWalker{
     protected final ResultSet results;
+    private GenericsGeneratorResultForClass generatedGenerics;
     protected final ClassOrInterface cl;
     public final Set<TypeInsert> inserts = new HashSet<>();
     private Method method;
+    
+    private Resolver resolver;
+    
+    List<GenericsGeneratorResult> constraints;
+	List<GenericsGeneratorResult> classConstraints;
 
-    TypeInsertPlacerClass(ClassOrInterface forClass, ResultSet withResults){
+    TypeInsertPlacerClass(ClassOrInterface forClass, ResultSet withResults, GenericsGeneratorResultForClass generatedGenerics){
         this.cl = forClass;
         this.method = null;
         this.results = withResults;
+        this.generatedGenerics = generatedGenerics;
+        resolver = new Resolver(withResults); //PL 2020-04-12 Ob das stimmt weiss ich nicht
         forClass.accept(this);
     }
 
     @Override
     public void visit(Method method) {
         this.method = method;
+        String id = MethodUtility.createID(resolver, method);
+        constraints = generatedGenerics.getMethodConstraintsByID(id);
+		classConstraints = generatedGenerics.getClassConstraints();
         if(method.getReturnType() instanceof TypePlaceholder)
             inserts.add(TypeInsertFactory.createInsertPoints(
-                    method.getReturnType(), method.getReturnType().getOffset(), cl, method, results));
+                    method.getReturnType(), method.getReturnType().getOffset(), cl, method, results, constraints, classConstraints));
         super.visit(method);
     }
 
     @Override
     public void visit(Field field) {
         if(field.getType() instanceof TypePlaceholder){
+        	classConstraints = generatedGenerics.getClassConstraints();
                 inserts.add(TypeInsertFactory.createInsertPoints(
-                        field.getType(), field.getType().getOffset(), cl, method, results));
+                        field.getType(), field.getType().getOffset(), cl, method, results, new ArrayList<>(), classConstraints));
         }
         super.visit(field);
     }
@@ -61,7 +88,7 @@ class TypeInsertPlacerClass extends AbstractASTWalker{
     public void visit(FormalParameter param) {
             if(param.getType() instanceof TypePlaceholder)
                 inserts.add(TypeInsertFactory.createInsertPoints(
-                        param.getType(), param.getType().getOffset(), cl, method, results));
+                        param.getType(), param.getType().getOffset(), cl, method, results, constraints, classConstraints));
         super.visit(param);
     }
 

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

@@ -1,30 +1,29 @@
 package de.dhbwstuttgart.typedeployment;
 
-import org.antlr.v4.runtime.Token;
-
-import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
-
-import java.time.OffsetDateTime;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Set;
-import java.util.stream.Collectors;
+
+import org.antlr.v4.runtime.Token;
 
 public class TypeInsertPoint {
     public Token point;
     private String insertString;
     private int extraOffset = 0;
+    private KindOfTypeInsertPoint kind;
 
-    public TypeInsertPoint(Token point, String toInsert){
+    public TypeInsertPoint(Token point, String toInsert, KindOfTypeInsertPoint kind){
         this.point = point;
+        this.kind = kind;
         this.insertString = (toInsert.endsWith(" ")) ? toInsert : toInsert + " " ;
     }
+    
+    public boolean isGenericClassInsertPoint() {
+    	return kind == KindOfTypeInsertPoint.GENERIC_CLASS_INSERT;
+    }
 
     public String insert(String intoSource, List<TypeInsertPoint> additionalOffset){
-        int offset = additionalOffset.stream().filter((token ->
-                //token.point.getLine() != point.getLine() && token.point.getCharPositionInLine() <= point.getCharPositionInLine()))
-                token.point.getStartIndex() <= point.getStartIndex()))
-                .mapToInt((typeInsertPoint -> typeInsertPoint.insertString.length())).sum();
-        return new StringBuilder(intoSource).insert(point.getStartIndex()+offset+extraOffset, insertString).toString();
+        return new StringBuilder(intoSource).insert(point.getStartIndex()+extraOffset, insertString).toString();
     }
 
     public String getInsertString() {
@@ -45,13 +44,21 @@ public class TypeInsertPoint {
      * @see java.lang.Object#equals(java.lang.Object)
      */
     public boolean equals(Object obj) {
+    	return this == obj;
+    	/*
     	if(!(obj instanceof TypeInsertPoint)) {
 			return false;
     	}
     	else {
-    		return ((TypeInsertPoint)obj).point.equals(this.point) &&
-    				((TypeInsertPoint)obj).insertString.equals(this.insertString);
-    	}			
+    		return 
+	    		((TypeInsertPoint)obj).getPositionInCode() == this.getPositionInCode() &&
+	    		((TypeInsertPoint)obj).insertString.equals(this.insertString);
+    	}		
+    	*/	
+    }
+    
+    public int hashCode() {
+    	return getPositionInCode() * 11 * insertString.hashCode();
     }
     
     public Set<TypeInsertPoint> getAdditionalPoints() {
@@ -59,6 +66,28 @@ public class TypeInsertPoint {
     }
     
     public String toString() {
-    	return point.toString() + " " + insertString.toString();
+    	return point.getLine() + ":" + point.getCharPositionInLine() + ":" + insertString;
+    }
+    
+    public static final class TypeInsertPointPositionComparator implements Comparator<TypeInsertPoint> {
+
+    	@Override
+    	public int compare(TypeInsertPoint o1, TypeInsertPoint o2) { 
+    		if (o1.point == null && o2.point == null) {
+    			return 0;
+    		} else if (o2.point == null) {
+    			return 1;
+    		} else if (o1.point == null) {
+    			return -1;
+    		}
+    		
+    		if (o1.getPositionInCode() > o2.getPositionInCode()) {
+    			return 1;
+    		} else if (o1.getPositionInCode() < o2.getPositionInCode()) {
+    			return -1;
+    		}
+    		return 0;
+    	}
+
     }
 }

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

@@ -6,7 +6,6 @@ import de.dhbwstuttgart.typeinference.unify.GuavaSetOperations;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 import java.util.*;
-import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -30,10 +29,7 @@ public class ConstraintSet<A> {
 
     @Override
     public String toString(){
-    	BinaryOperator<String> b = (x,y) -> x+y;
-        return "\nUND:" + this.undConstraints.toString() + "\n" + 
-    		   "ODER:" + this.oderConstraints.stream().reduce("", (x,y) -> x.toString()+ "\n"  +y, b);
-        		//cartesianProduct().toString();
+        return cartesianProduct().toString();
     }
 
     public Set<List<Constraint<A>>> cartesianProduct(){

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

@@ -46,7 +46,7 @@ public class TYPE {
     /*
     TODO: Hier eine Information erstellen nur mit den importierte Klassen einer einzigen SourceFile
         private TypeInferenceInformation getTypeInferenceInformation(sourceFile) {
-            DirectoryClassLoader classLoader = DirectoryClassLoader.getSystemClassLoader();
+            ClassLoader classLoader = ClassLoader.getSystemClassLoader();
             Set<ClassOrInterface> classes = new HashSet<>();
 
             for(SourceFile sourceFile : sfs){

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

@@ -17,7 +17,6 @@ import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.constraints.*;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
-import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 
 import java.util.*;
 import java.util.stream.Collectors;
@@ -160,12 +159,10 @@ public class TYPEStmt implements StatementVisitor{
     }
 
     @Override
-    //Es wird in OderConstraints davon ausgegangen dass die Bedingungen für die Typen der Argumente links stehen
-  	//und die Typen der Rückgabewerte immer rechts stehen (vgl. JavaTXCompiler)
     public void visit(MethodCall methodCall) {
         methodCall.receiver.accept(this);
         //Overloading:
-        Set<Constraint<Pair>> methodConstraints = new HashSet<>();
+        Set<Constraint> methodConstraints = new HashSet<>();
         for(MethodAssumption m : this.getMethods(methodCall.name, methodCall.arglist, info)){
             GenericsResolver resolver = getResolverInstance();
             methodConstraints.add(generateConstraint(methodCall, m, info, resolver));
@@ -225,8 +222,6 @@ public class TYPEStmt implements StatementVisitor{
     }
 
     @Override
-    //Es wird in OderConstraints davon ausgegangen dass die Bedingungen für die Typen der Argumente links stehen
-	//und die Typen der Rückgabewerte immer rechts stehen (vgl. JavaTXCompiler)
     public void visit(BinaryExpr binary) {
     		binary.lexpr.accept(this);
     		binary.rexpr.accept(this);
@@ -253,7 +248,7 @@ public class TYPEStmt implements StatementVisitor{
             	numeric = new Constraint<>();
             	numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT));
             	numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT));
-            	numeric.add(new Pair(binary.getType(), integer, PairOperator.EQUALSDOT));
+            	numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             //PL eingefuegt 2018-07-17
@@ -261,7 +256,7 @@ public class TYPEStmt implements StatementVisitor{
             	numeric = new Constraint<>();
             	numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT));
             	numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT));
-            	numeric.add(new Pair(binary.getType(), integer, PairOperator.EQUALSDOT));
+            	numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
             	numericAdditionOrStringConcatenation.add(numeric);
             }
             //PL eingefuegt 2018-07-17
@@ -269,7 +264,7 @@ public class TYPEStmt implements StatementVisitor{
             	numeric = new Constraint<>();
             	numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT));
             	numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT));
-            	numeric.add(new Pair(integer, binary.getType(), PairOperator.EQUALSDOT));
+            	numeric.add(new Pair(integer, binary.getType(), PairOperator.SMALLERDOT));
             	numericAdditionOrStringConcatenation.add(numeric);
             }
             //PL eingefuegt 2018-07-17
@@ -277,7 +272,7 @@ public class TYPEStmt implements StatementVisitor{
             	numeric = new Constraint<>();
             	numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT));
             	numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT));
-            	numeric.add(new Pair(longg, binary.getType(), PairOperator.EQUALSDOT));
+            	numeric.add(new Pair(longg, binary.getType(), PairOperator.SMALLERDOT));
             	numericAdditionOrStringConcatenation.add(numeric);
             }
             //PL eingefuegt 2018-07-17
@@ -285,7 +280,7 @@ public class TYPEStmt implements StatementVisitor{
             	numeric = new Constraint<>();
             	numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT));
             	numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT));
-            	numeric.add(new Pair(floatt, binary.getType(), PairOperator.EQUALSDOT));
+            	numeric.add(new Pair(floatt, binary.getType(), PairOperator.SMALLERDOT));
             	numericAdditionOrStringConcatenation.add(numeric);
             }
             //PL eingefuegt 2018-07-17
@@ -293,7 +288,7 @@ public class TYPEStmt implements StatementVisitor{
             	numeric = new Constraint<>();
             	numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT));
             	numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT));
-            	numeric.add(new Pair(doublee, binary.getType(), PairOperator.EQUALSDOT));
+            	numeric.add(new Pair(doublee, binary.getType(), PairOperator.SMALLERDOT));
             	numericAdditionOrStringConcatenation.add(numeric);
             }
             /* PL auskommentiert Anfang 2018-07-17
@@ -367,7 +362,7 @@ public class TYPEStmt implements StatementVisitor{
             constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERNEQDOT));
             constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERNEQDOT));
             //Rückgabetyp ist Boolean
-            constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.EQUALSDOT));
+            constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.SMALLERDOT));
 
             //auskommentiert PL 2018-05-24
             //constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
@@ -379,7 +374,7 @@ public class TYPEStmt implements StatementVisitor{
             The equality operators may be used to compare two operands that are convertible (§5.1.8) to numeric type, or two operands of type boolean or Boolean, or two operands that are each of either reference type or the null type. All other cases result in a compile-time error.
              */
             //Der Equals Operator geht mit fast allen Typen, daher werden hier keine Constraints gesetzt
-            constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.EQUALSDOT));
+            constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.SMALLERDOT));
         }else{
                 throw new NotImplementedException();
         }
@@ -560,7 +555,7 @@ public class TYPEStmt implements StatementVisitor{
 
     protected Constraint<Pair> generateConstraint(MethodCall forMethod, MethodAssumption assumption,
                                                   TypeInferenceBlockInformation info, GenericsResolver resolver){
-        Constraint<Pair> methodConstraint = new Constraint<>();
+        Constraint methodConstraint = new Constraint();
         ClassOrInterface receiverCl = assumption.getReceiver();
         /*
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
@@ -574,13 +569,7 @@ public class TYPEStmt implements StatementVisitor{
         
         RefTypeOrTPHOrWildcardOrGeneric retType = assumption.getReceiverType(resolver);
         methodConstraint.add(new Pair(forMethod.receiver.getType(), retType,
-                    PairOperator.EQUALSDOT));//PL 2020-03-17 SMALLERDOT in EQUALSDOT umgewandelt, weil alle geerbten Methoden in den jeweilen Klassen enthalten sind. 
-        
-        //Fuer Bytecodegenerierung PL 2020-03-09 wird derzeit nicht benutzt ANFANG
-        //methodConstraint.add(new Pair(forMethod.receiverType, retType,
-        //        PairOperator.EQUALSDOT));
-        //Fuer Bytecodegenerierung PL 2020-03-09 wird derzeit nicht benutzt ENDE
-        
+                    PairOperator.SMALLERDOT));
         methodConstraint.add(new Pair(assumption.getReturnType(resolver), forMethod.getType(),
                 PairOperator.EQUALSDOT));
         methodConstraint.addAll(generateParameterConstraints(forMethod, assumption, info, resolver));
@@ -595,10 +584,6 @@ public class TYPEStmt implements StatementVisitor{
             RefTypeOrTPHOrWildcardOrGeneric argType = foMethod.arglist.getArguments().get(i).getType();
             RefTypeOrTPHOrWildcardOrGeneric assType = assumption.getArgTypes(resolver).get(i);
             ret.add(new Pair(argType, assType, PairOperator.SMALLERDOT));
-            
-          //Fuer Bytecodegenerierung PL 2020-03-09 wird derzeit nicht benutzt ANFANG
-          //  ret.add(new Pair(foMethod.argTypes.get(i), assType, PairOperator.EQUALSDOT));
-          //Fuer Bytecodegenerierung PL 2020-03-09 wird derzeit nicht benutzt ENDE
         }
         return ret;
     }
@@ -681,11 +666,8 @@ public class TYPEStmt implements StatementVisitor{
     protected Constraint<Pair> generateConstructorConstraint(NewClass forConstructor, MethodAssumption assumption,
                                                              TypeInferenceBlockInformation info, GenericsResolver resolver){
         Constraint methodConstraint = new Constraint();
-        //WELCHEN SINN MACHT DIESER CONSTRAINT???
-        //Ist er nicht immer classname <. classname und damit redundant?
         methodConstraint.add(new Pair(assumption.getReturnType(resolver), forConstructor.getType(),
                 PairOperator.SMALLERDOT));
-        //WELCHEN SINN MACHT DIESER CONSTRAINT??? 
         methodConstraint.addAll(generateParameterConstraints(forConstructor, assumption, info, resolver));
         return methodConstraint;
     }

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

@@ -22,7 +22,6 @@ import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
 public class Match implements IMatch {
 
 	@Override
-	//vorne muss das Pattern stehen
 	//A<X> =. A<Integer> ==> True
 	//A<Integer> =. A<X> ==> False
 	public Optional<Unifier> match(ArrayList<UnifyPair> termsList) {

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

@@ -28,7 +28,6 @@ import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
-import de.dhbwstuttgart.typeinference.unify.interfaces.IMatch;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IRuleSet;
 import de.dhbwstuttgart.typeinference.unify.interfaces.ISetOperations;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IUnify;
@@ -187,6 +186,12 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				usedTasks.cancel();
 				writeLog(nOfUnify.toString() + "cancel");
 				System.out.println("cancel");
+				try {
+					logFile.write("Abbruch");
+				}
+				catch (IOException e) { 
+					System.err.println("log-File nicht vorhanden");
+				}	
 			}
 			*/
 			rules = new RuleSet(logFile);
@@ -304,12 +309,18 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		/*
 		 * Step 1: Repeated application of reduce, adapt, erase, swap 
 		 */
+		synchronized (usedTasks) {
+			if (this.myIsCancelled()) {
+				return new HashSet<>();
+			}
+		}
 		
 		rekTiefe++;
 		nOfUnify++;
         writeLog(nOfUnify.toString() + " Unifikation: " + eq.toString());
         writeLog(nOfUnify.toString() + " Oderconstraints: " + oderConstraints.toString());
-			
+		//eq = eq.stream().map(x -> {x.setVariance((byte)-1); return x;}).collect(Collectors.toCollection(HashSet::new));
+		
 		/*
 		 * Variancen auf alle Gleichungen vererben
 		 */
@@ -463,7 +474,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		//		.collect(Collectors.toCollection(HashSet::new));
 		//Muss auskommentiert werden, wenn computeCartesianRecursive ENDE
 		
-
+		synchronized (usedTasks) {
+			if (this.myIsCancelled()) {
+				return new HashSet<>();
+			}
+		}
 		
 		Set<Set<UnifyPair>> eqPrimePrimeSet = new HashSet<>();
 		
@@ -607,8 +622,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			for (UnifyPair ele : nextSetasList.get(0)) {//check ob a <. ty base oder ob Ueberladung
 				sameBase = sameBase && ele.getBasePair() != null && ele.getBasePair().equals(fstBasePair);
 			}
-			if (sameBase) {                                                                                                                 //angefuegt PL 2020-02-30
-				Optional<Integer> xi = nextSetasList.stream().map(x -> x.stream().filter(y -> (y.getLhsType() instanceof PlaceholderType && !(y.getRhsType() instanceof PlaceholderType)))
+			if (sameBase) {
+				Optional<Integer> xi = nextSetasList.stream().map(x -> x.stream().filter(y -> y.getLhsType() instanceof PlaceholderType)
 						.filter(z -> ((PlaceholderType)z.getLhsType()).getVariance() != 0)
 						.map(c -> ((PlaceholderType)c.getLhsType()).getVariance())
 						.reduce((a,b)-> {if (a==b) return a; else return 0; })) //2 kommt insbesondere bei Oder-Constraints vor
@@ -731,7 +746,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			}
 			else if (variance == -1) {
 				a = oup.min(nextSetasList.iterator());
-				writeLog("Min: a in " + variance + " "+ a);
 				nextSetasList.remove(a);
 				nextSetasListRest = new ArrayList<>(nextSetasList);
 				Iterator<Set<UnifyPair>> nextSetasListItRest = new ArrayList<Set<UnifyPair>>(nextSetasListRest).iterator();
@@ -908,6 +922,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					writeLog("wait "+ forkOrig.thNo);
 					noOfThread--;
 					res = forkOrig.join();
+					synchronized (usedTasks) {
+						if (this.myIsCancelled()) {
+							return new HashSet<>();
+						}
+					}
 					//noOfThread++;
 					forkOrig.writeLog("final Orig 1");
 					forkOrig.closeLogFile();
@@ -923,6 +942,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					synchronized (this) {
 						noOfThread--;
 						Set<Set<UnifyPair>> fork_res = fork.join();
+						synchronized (usedTasks) {
+							if (this.myIsCancelled()) {
+								return new HashSet<>();
+							}
+						}
 						//noOfThread++;
 						writeLog("Join " + new Integer(fork.thNo).toString());
 						//noOfThread--; an das Ende von compute verschoben
@@ -1014,6 +1038,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					writeLog("wait "+ forkOrig.thNo);
 					noOfThread--;
 					res = forkOrig.join();
+					synchronized (usedTasks) {
+						if (this.myIsCancelled()) {
+							return new HashSet<>();
+						}
+					}
 					//noOfThread++;
 					forkOrig.writeLog("final Orig -1");
 					forkOrig.closeLogFile();
@@ -1029,6 +1058,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					synchronized (this) {
 						noOfThread--;
 						Set<Set<UnifyPair>> fork_res = fork.join();
+						synchronized (usedTasks) {
+							if (this.myIsCancelled()) {
+								return new HashSet<>();
+							}
+						}
 						//noOfThread++;
 						writeLog("Join " + new Integer(fork.thNo).toString());
 						//noOfThread--; an das Ende von compute verschoben 
@@ -1069,7 +1103,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				}
 		    	while (!nextSetasListRest.isEmpty()) {
 		    		Set<UnifyPair> nSaL = nextSetasListRest.remove(0);
-		    		nextSetasList.remove(nSaL); //PL einkommentiert 20-02-03
+		    		//nextSetasList.remove(nSaL);
 		    		Set<UnifyPair> newEq = new HashSet<>(eq);
 		    		Set<Set<UnifyPair>> newElems = new HashSet<>(elems);
 		    		List<Set<Set<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
@@ -1090,6 +1124,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		    		writeLog("wait "+ forkOrig.thNo);
 		    		noOfThread--;
 					res = forkOrig.join();
+					synchronized (usedTasks) {
+						if (this.myIsCancelled()) {
+							return new HashSet<>();
+						}
+					}
 					//noOfThread++;
 					forkOrig.writeLog("final Orig 2");
 					forkOrig.closeLogFile();
@@ -1104,6 +1143,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		    		synchronized (this) {
 		    			noOfThread--;
 						Set<Set<UnifyPair>> fork_res = fork.join();
+						synchronized (usedTasks) {
+							if (this.myIsCancelled()) {
+								return new HashSet<>();
+							}
+						}
 						//noOfThread++;
 						writeLog("Join " + new Integer(fork.thNo).toString());
 						//noOfThread--; an das Ende von compute verschoben 
@@ -1225,7 +1269,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 						if (!isUndefinedPairSetSet(par_res) && isUndefinedPairSetSet(result)) {
 							//wenn korrektes Ergebnis gefunden alle Fehlerfaelle loeschen
 							result = par_res;
-							if (par_res.iterator().next() instanceof WildcardType) {
+							if (!par_res.isEmpty() && par_res.iterator().next() instanceof WildcardType) {
 								System.out.println("");
 							}
 						}
@@ -1446,7 +1490,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			//else result.stream().filter(y -> !isUndefinedPairSet(y));
 			writeLog("res: " + res.toString());
 		}
-		//2020-02-02: if (variance ==2) Hier Aufruf von filterOverriding einfuegen
+		
 		writeLog("Return computeCR: " + result.toString());
 		return result;
 	}
@@ -1765,7 +1809,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	 * (as in case 1 where sigma is added to the innermost set).
 	 */
 	protected Set<Set<Set<Set<UnifyPair>>>> calculatePairSets(Set<UnifyPair> eq2s, List<Set<Set<UnifyPair>>> oderConstraintsInput, IFiniteClosure fc, Set<UnifyPair> undefined, List<Set<Set<UnifyPair>>> oderConstraintsOutput) {
-		writeLog("eq2s: " + eq2s.toString());
 		oderConstraintsOutput.addAll(oderConstraintsInput);
 		List<Set<Set<Set<UnifyPair>>>> result = new ArrayList<>(9);
 
@@ -1775,30 +1818,17 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		
 		ArrayList<UnifyPair> eq2sprime = new ArrayList<>(eq2s);
 		Iterator<UnifyPair> eq2sprimeit = eq2sprime.iterator();
-		ArrayList<UnifyPair> eq2sAsListFst = new ArrayList<>();
-		ArrayList<UnifyPair> eq2sAsListSnd = new ArrayList<>();
-		ArrayList<UnifyPair> eq2sAsListBack = new ArrayList<>();
 		ArrayList<UnifyPair> eq2sAsList = new ArrayList<>();
 		Boolean first = true;
 		while(eq2sprimeit.hasNext()) {// alle mit Variance != 0 nach vorne schieben
 			UnifyPair up = eq2sprimeit.next();
-			if ((up.getLhsType() instanceof PlaceholderType && ((PlaceholderType)up.getLhsType()).getVariance() != 0 && !((PlaceholderType)up.getLhsType()).isInnerType())
-					|| (up.getRhsType() instanceof PlaceholderType && ((PlaceholderType)up.getRhsType()).getVariance() != 0) && !((PlaceholderType)up.getRhsType()).isInnerType()) {
-				eq2sAsListFst.add(up);
-				eq2s.remove(up);
-			}
-			else if ((up.getLhsType() instanceof PlaceholderType && ((PlaceholderType)up.getLhsType()).getVariance() != 0 && ((PlaceholderType)up.getLhsType()).isInnerType())
-					|| (up.getRhsType() instanceof PlaceholderType && ((PlaceholderType)up.getRhsType()).getVariance() != 0) && ((PlaceholderType)up.getRhsType()).isInnerType()) {
-				eq2sAsListSnd.add(up);
-				eq2s.remove(up);
-			}
-			else if ((up.getLhsType() instanceof PlaceholderType && ((PlaceholderType)up.getLhsType()).isInnerType())
-					|| (up.getRhsType() instanceof PlaceholderType && ((PlaceholderType)up.getRhsType()).isInnerType())) {
-				eq2sAsListBack.add(up);
+			if ((up.getLhsType() instanceof PlaceholderType && ((PlaceholderType)up.getLhsType()).getVariance() != 0)
+					|| (up.getRhsType() instanceof PlaceholderType && ((PlaceholderType)up.getRhsType()).getVariance() != 0)) {
+				eq2sAsList.add(up);
 				eq2s.remove(up);
 			}
 		}
-		if (eq2sAsListFst.isEmpty()) {
+		if (eq2sAsList.isEmpty()) {
 			List<Set<Set<UnifyPair>>> oderConstraintsVariance = oderConstraintsOutput.stream() //Alle Elemente rauswerfen, die Variance 0 haben oder keine TPH in LHS oder RHS sind
 			.filter(x -> x.stream()
 					.filter(y -> 
@@ -1813,24 +1843,13 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				oderConstraintsOutput.remove(ret);
 				//Set<UnifyPair> retFlat = new HashSet<>(); 
 			    //ret.stream().forEach(x -> retFlat.addAll(x)); 
-				ret.stream().forEach(x -> x.stream().forEach(y -> { Set<UnifyPair> x_new = new HashSet<>(x); //PL 2020-03-18: y selbst darf nicht in die Substitutionen
-																	x_new.remove(y);
-																	y.addSubstitutions(x_new);
-																  })); 
+				ret.stream().forEach(x -> x.stream().forEach(y -> y.addSubstitutions(x))); 
 				result.get(8).add(ret);
 				first = false;
 			}
 		}
 		
-		writeLog("eq2s: " + eq2s.toString());
-		writeLog("eq2sAsListFst: " + eq2sAsListFst.toString());
-		writeLog("eq2sAsListSnd: " + eq2sAsListSnd.toString());
-		writeLog("eq2sAsListBack: " + eq2sAsListBack.toString());
-		
-		eq2sAsList.addAll(eq2sAsListFst);
-		eq2sAsList.addAll(eq2sAsListSnd);
 		eq2sAsList.addAll(eq2s);
-		eq2sAsList.addAll(eq2sAsListBack);
 		
 		if (eq2sAsList.isEmpty() && first) {//Alle eq2s sind empty und alle oderConstraints mit Variance != 0 sind bearbeitet 
 			if (!oderConstraintsOutput.isEmpty()) {
@@ -1839,10 +1858,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				//	System.out.println("M");
 				//Set<UnifyPair> retFlat = new HashSet<>(); 
 			    //ret.stream().forEach(x -> retFlat.addAll(x)); 
-				ret.stream().forEach(x -> x.stream().forEach(y -> { Set<UnifyPair> x_new = new HashSet<>(x); //PL 2020-03-18: y selbst darf nicht in die Substitutionen
-																	x_new.remove(y);
-																	y.addSubstitutions(x_new);
-															      })); 				
+				ret.stream().forEach(x -> x.stream().forEach(y -> y.addSubstitutions(x))); 				
 				result.get(8).add(ret);
 				first = false;
 			}
@@ -2062,15 +2078,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	protected Set<Set<UnifyPair>> unifyCase1(UnifyPair pair, IFiniteClosure fc) {
 		PlaceholderType a = (PlaceholderType)pair.getLhsType(); 
 		UnifyType thetaPrime = pair.getRhsType(); 
+		byte variance = pair.getVariance();
 		
-		if (thetaPrime instanceof ExtendsType) {
-			thetaPrime = ((ExtendsType)thetaPrime).getExtendedType();
-		}
-		
-		if (thetaPrime instanceof SuperType) {
-			//HIER MUSS NOCH WAS UEBERLEGT WERDEN
-		}
-			
 		Set<Set<UnifyPair>> result = new HashSet<>();
 		
 		boolean allGen = thetaPrime.getTypeParams().size() > 0;
@@ -2088,7 +2097,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		//}
 		Set<UnifyType> cs = fc.getAllTypesByName(thetaPrime.getName());//cs= [java.util.Vector<NP>, java.util.Vector<java.util.Vector<java.lang.Integer>>, ????java.util.Vector<gen_hv>???]
 		
-		writeLog("cs: " + cs.toString());
+		
 		//PL 18-02-06 entfernt, kommt durch unify wieder rein
 		//cs.add(thetaPrime);
 		//PL 18-02-06 entfernt
@@ -2102,19 +2111,13 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			return x.accept(new freshPlaceholder(), hm);
 		}).collect(Collectors.toCollection(HashSet::new));
 				
-		IMatch match = new Match();		
+				
 		for(UnifyType c : csPHRenamed) {
 			//PL 18-02-05 getChildren durch smaller ersetzt in getChildren werden die Varianlen nicht ersetzt.
 			Set<UnifyType> thetaQs = new HashSet<>();
 			//TODO smaller wieder reinnehmen? 
 			//thetaQs.add(c);//
 			thetaQs = fc.smaller(c, new HashSet<>()).stream().collect(Collectors.toCollection(HashSet::new));
-			ArrayList<UnifyPair> ml = new ArrayList<>();
-			ml.add(new UnifyPair(c, thetaPrime, PairOperator.EQUALSDOT));
-			if (!(match.match(ml)).isPresent()) {
-				thetaQs.remove(c);
-			}
-			writeLog("thetaQs von " + c + ": " + thetaQs.toString());
 			//Set<UnifyType> thetaQs = fc.getChildren(c).stream().collect(Collectors.toCollection(HashSet::new));
 		    //thetaQs.add(thetaPrime); //PL 18-02-05 wieder geloescht
 			                           //PL 2017-10-03: War auskommentiert habe ich wieder einkommentiert, 
@@ -2122,7 +2125,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			
 			//PL 18-02-06: eingefuegt, thetaQs der Form V<V<...>> <. V'<V<...>> werden entfernt
 			//TODO PL 19-01-14 wieder reinnehmen kurzfristig auskommentiert 
-			//thetaQs = thetaQs.stream().filter(ut -> ut.getTypeParams().arePlaceholders()).collect(Collectors.toCollection(HashSet::new));
+			thetaQs = thetaQs.stream().filter(ut -> ut.getTypeParams().arePlaceholders()).collect(Collectors.toCollection(HashSet::new));
 			//PL 18-02-06: eingefuegt
 			
 			Set<UnifyType> thetaQPrimes = new HashSet<>();
@@ -2138,8 +2141,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				for(TypeParams tp : permuteParams(candidateParams))
 					thetaQPrimes.add(c.setTypeParams(tp));
 			}
-			writeLog("thetaQPrimes von " + c + ": " + thetaQPrimes.toString());
-			for(UnifyType tqp : thetaQPrimes) {//PL 2020-03-08 umbauen in der Schleife wird nur unifizierbarer Typ gesucht break am Ende
+			
+			for(UnifyType tqp : thetaQPrimes) {
 				Collection<PlaceholderType> tphs = tqp.getInvolvedPlaceholderTypes();
 				Optional<Unifier> opt = stdUnify.unify(tqp, thetaPrime);
 				if (!opt.isPresent()) {                     
@@ -2158,10 +2161,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				}
 				//List<UnifyType> freshTphs = new ArrayList<>(); PL 18-02-06 in die For-Schleife verschoben
 				for (UnifyType tq : thetaQs) {
-					//geaendert PL 20-03-07 
-					Set<UnifyType> smaller = new HashSet<>();
-					smaller.add(unifier.apply(tq));
-					//Set<UnifyType> smaller = fc.smaller(unifier.apply(tq), new HashSet<>()); 
+					Set<UnifyType> smaller = fc.smaller(unifier.apply(tq), new HashSet<>()); 
 					//eingefuegt PL 2018-03-29 Anfang ? ext. theta hinzufuegen
 					if (a.isWildcardable()) {
 						Set<UnifyType> smaller_ext = smaller.stream().filter(x -> !(x instanceof ExtendsType) && !(x instanceof SuperType)) 
@@ -2203,14 +2203,16 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 						}
 						resultPrime.addAll(substitutionSet);
 						//writeLog("Substitution: " + substitutionSet.toString());
+						resultPrime = resultPrime.stream().map(x -> { x.setVariance(variance); return x;}).collect(Collectors.toCollection(HashSet::new));
 						result.add(resultPrime);
 						//writeLog("Result: " + resultPrime.toString());
 						//writeLog("MAX: " + oup.max(resultPrime.iterator()).toString());
 					}
 				}
+
 			}
 		}
-		writeLog("result von " + pair + ": " + result.toString());
+		
 		return result;
 	}
 	
@@ -2220,6 +2222,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	private Set<Set<UnifyPair>> unifyCase2(UnifyPair pair, IFiniteClosure fc) {
 		PlaceholderType a = (PlaceholderType) pair.getLhsType();
 		ExtendsType extThetaPrime = (ExtendsType) pair.getRhsType();
+		byte variance = pair.getVariance();
 		Set<Set<UnifyPair>> result = new HashSet<>();
 		
 		UnifyType aPrime = PlaceholderType.freshPlaceholder();
@@ -2234,6 +2237,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		resultPrime = new HashSet<>();
 		resultPrime.add(new UnifyPair(a, extAPrime, PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
 		resultPrime.add(new UnifyPair(aPrime, thetaPrime, PairOperator.SMALLERDOT, pair.getSubstitution(), pair));
+		resultPrime = resultPrime.stream().map(x -> { x.setVariance(variance); return x;}).collect(Collectors.toCollection(HashSet::new));
 		result.add(resultPrime);
 		//writeLog("Result: " + resultPrime.toString());
 		return result;
@@ -2246,6 +2250,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		PlaceholderType a = (PlaceholderType) pair.getLhsType();
 		a.reversVariance();
 		SuperType subThetaPrime = (SuperType) pair.getRhsType();
+		byte variance = pair.getVariance();
 		Set<Set<UnifyPair>> result = new HashSet<>();
 		
 		UnifyType aPrime = PlaceholderType.freshPlaceholder();
@@ -2261,6 +2266,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		resultPrime = new HashSet<>();
 		resultPrime.add(new UnifyPair(a, supAPrime, PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
 		resultPrime.add(new UnifyPair(thetaPrime, aPrime, PairOperator.SMALLERDOT, pair.getSubstitution(), pair));
+		resultPrime = resultPrime.stream().map(x -> { x.setVariance(variance); return x;}).collect(Collectors.toCollection(HashSet::new));
 		result.add(resultPrime);
 		//writeLog(resultPrime.toString());
 		
@@ -2273,6 +2279,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	private Set<Set<UnifyPair>> unifyCase5(UnifyPair pair, IFiniteClosure fc) {
 		UnifyType theta = pair.getLhsType();
 		PlaceholderType a = (PlaceholderType) pair.getRhsType();
+		byte variance = pair.getVariance();
 		Set<Set<UnifyPair>> result = new HashSet<>();
 		
 		boolean allGen = theta.getTypeParams().size() > 0;
@@ -2336,6 +2343,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				resultPrime.add(new UnifyPair(a, thetaS, PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
 			else
 				resultPrime.add(new UnifyPair(a, thetaS.setTypeParams(new TypeParams(freshTphs)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
+			resultPrime = resultPrime.stream().map(x -> { x.setVariance(variance); return x;}).collect(Collectors.toCollection(HashSet::new));
 			result.add(resultPrime);
 			//writeLog("FBOUNDED2: " + pair.getfBounded());
 			//writeLog("resultPrime Theta < a: " + greater + pair + "THETA: " + theta + "FBOUNDED: " + pair.getfBounded() + " " + resultPrime.toString());
@@ -2350,7 +2358,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	private Set<Set<UnifyPair>> unifyCase8(UnifyPair pair, IFiniteClosure fc) {
 		UnifyType theta = pair.getLhsType();
 	    PlaceholderType a = (PlaceholderType) pair.getRhsType();
-	    Set<Set<UnifyPair>> result = new HashSet<>();
+	    byte variance = pair.getVariance();
+		Set<Set<UnifyPair>> result = new HashSet<>();
 		//for(UnifyType thetaS : fc.grArg(theta)) {
 		Set<UnifyPair> resultPrime = new HashSet<>();
 		resultPrime.add(new UnifyPair(a, theta, PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
@@ -2370,6 +2379,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		resultPrime = new HashSet<>();
 		resultPrime.add(new UnifyPair(a, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
 		resultPrime.add(new UnifyPair(freshTph, theta, PairOperator.SMALLERDOT, pair.getSubstitution(), pair));
+		resultPrime = resultPrime.stream().map(x -> { x.setVariance(variance); return x;}).collect(Collectors.toCollection(HashSet::new));
 		result.add(resultPrime);
 		//writeLog(resultPrime.toString());
 		//}

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

@@ -711,15 +711,13 @@ implements IFiniteClosure  {
 		HashSet<UnifyPair> hs = new HashSet<>();
 		hs.add(up);
 		Set<UnifyPair> smallerRes = unifyTask.applyTypeUnificationRules(hs, this);
-		/*
-		//if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
+		if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
 		{try { 
 			logFile.write("\nsmallerRes: " + smallerRes);//"smallerHash: " + greaterHash.toString());
 			logFile.flush();
 		}
 		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)
@@ -734,15 +732,13 @@ implements IFiniteClosure  {
 			hs = new HashSet<>();
 			hs.add(up);
 			Set<UnifyPair> greaterRes = unifyTask.applyTypeUnificationRules(hs, this);
-			/*
-			//if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
+			if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
 			{try { 
 				logFile.write("\ngreaterRes: " + greaterRes);//"smallerHash: " + greaterHash.toString());
 				logFile.flush();
 			}
 			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();
 			if (greaterLen == 0) return 1;

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

@@ -293,25 +293,24 @@ public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
 			} else {
 				if (leftlewc.size() > 0) {
 					Set<UnifyPair> subst;
-					subst = leftlewc.stream().map(x -> { 
-						if (x.getLhsType() instanceof PlaceholderType) {
-							return new UnifyPair(x.getLhsType(), x.getRhsType(), PairOperator.EQUALSDOT);
-						}
-						else {
-							return new UnifyPair(x.getRhsType(), x.getLhsType(), PairOperator.EQUALSDOT);
-						}}).collect(Collectors.toCollection(HashSet::new));
+					if (leftlewc.iterator().next().getLhsType() instanceof PlaceholderType) {
+						subst = leftlewc.stream().map(x -> new UnifyPair(x.getLhsType(), x.getRhsType(), PairOperator.EQUALSDOT)).collect(Collectors.toCollection(HashSet::new));
+					}
+					else {
+						subst = leftlewc.stream().map(x -> new UnifyPair(x.getRhsType(), x.getLhsType(), PairOperator.EQUALSDOT)).collect(Collectors.toCollection(HashSet::new));
+					}
 					Unifier uni = new Unifier();
+					subst.stream().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
 					lseq = uni.apply(lseq);
 				}
 				else {
 					Set<UnifyPair> subst;
-					subst = rightlewc.stream().map(x -> { 
-						if (x.getLhsType() instanceof PlaceholderType) {
-							return new UnifyPair(x.getLhsType(), x.getRhsType(), PairOperator.EQUALSDOT);
-						}
-						else {
-							return new UnifyPair(x.getRhsType(), x.getLhsType(), PairOperator.EQUALSDOT);
-						}}).collect(Collectors.toCollection(HashSet::new));
+					if (rightlewc.iterator().next().getLhsType() instanceof PlaceholderType) {
+						subst = rightlewc.stream().map(x -> new UnifyPair(x.getLhsType(), x.getRhsType(), PairOperator.EQUALSDOT)).collect(Collectors.toCollection(HashSet::new));
+					}
+					else {
+						subst = rightlewc.stream().map(x -> new UnifyPair(x.getRhsType(), x.getLhsType(), PairOperator.EQUALSDOT)).collect(Collectors.toCollection(HashSet::new));
+					}
 					Unifier uni = new Unifier();
 					subst.stream().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
 					rseq = uni.apply(rseq);

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

@@ -28,6 +28,15 @@ public class UnifyPair {
 	 * The operator that determines the relation between the left and right hand side type.
 	 */
 	private PairOperator pairOp;
+	
+	/** wieder loesecn wird nicht mehr benoetigt PL 2018-03-31
+     * variance shows the variance of the pair
+     * -1: contravariant
+     * 1 covariant
+     * 0 invariant
+     * PL 2018-03-21
+     */
+    private byte variance = 0;
     
     private boolean undefinedPair = false;
     
@@ -74,6 +83,7 @@ public class UnifyPair {
 		pairOp = op;
 		substitution = uni;
 		basePair = base;
+		this.variance = variance;
 		
 		
 		// Caching hashcode
@@ -115,6 +125,14 @@ public class UnifyPair {
 		substitution.addAll(sup);
 	}
 	
+	public byte getVariance() {
+		return variance;
+	}
+	
+	public void setVariance(byte v) {
+		variance = v;
+	}
+	
 	public void setUndefinedPair() {
 		undefinedPair = true;
 	}
@@ -195,13 +213,11 @@ public class UnifyPair {
 			if (other.getBasePair() != basePair || (other.getBasePair() == null && basePair == null)) { 
 				return false;
 			}
-			
 			if (!other.getBasePair().equals(basePair) ||
 				!other.getAllSubstitutions().equals(getAllSubstitutions())) {
 				return false;
 			}
 		}
-
 		
 		return other.getPairOp() == pairOp 
 				&& other.getLhsType().equals(lhs) 

src/test/java/asp/ClingoTest.java

@@ -0,0 +1,52 @@
+package asp;
+
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.sat.asp.parser.ASPParser;
+import de.dhbwstuttgart.sat.asp.writer.ASPFactory;
+import de.dhbwstuttgart.sat.asp.Clingo;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import org.junit.Test;
+
+import javax.json.Json;
+import javax.json.JsonObject;
+import java.io.*;
+import java.util.*;
+
+public class ClingoTest {
+    public static final String tempDirectory = "/tmp/";
+    private final TypePlaceholder testType = TypePlaceholder.fresh(new NullToken());
+    @Test
+    public void test() throws IOException, InterruptedException, ClassNotFoundException {
+        String content = "";
+        content = ASPFactory.generateASP(this.getPairs(), this.getFC());
+        
+        PrintWriter writer = new PrintWriter(tempDirectory + "test.lp", "UTF-8");
+        writer.println(content);
+        writer.close();
+
+        Clingo clingo = new Clingo(Arrays.asList(new File(tempDirectory + "test.lp")));
+        String result = clingo.runClingo();
+        System.out.println(result);
+        ResultSet resultSet = ASPParser.parse(result, Arrays.asList(testType));
+        RefTypeOrTPHOrWildcardOrGeneric resolvedType = resultSet.resolveType(testType).resolvedType;
+        assert resolvedType.toString().equals(ASTFactory.createObjectType().toString());
+    }
+
+    public Collection<ClassOrInterface> getFC() {
+        Set<ClassOrInterface> ret = new HashSet<>();
+        return ret;
+    }
+
+    public ConstraintSet<Pair> getPairs() {
+        ConstraintSet<Pair> ret = new ConstraintSet<>();
+        ret.addUndConstraint(new Pair(testType, ASTFactory.createObjectType(), PairOperator.EQUALSDOT));
+        return ret;
+    }
+}

src/test/java/asp/UnifyWithoutWildcards.java

@@ -0,0 +1,103 @@
+package asp;
+
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.sat.asp.Clingo;
+import de.dhbwstuttgart.sat.asp.parser.ASPParser;
+import de.dhbwstuttgart.sat.asp.writer.ASPFactory;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.syntaxtree.visual.ResultSetPrinter;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.sql.Ref;
+import java.util.*;
+
+public class UnifyWithoutWildcards {
+
+    public static final String tempDirectory = "/tmp/";
+
+    @Test
+    public void adapt() throws InterruptedException, IOException, ClassNotFoundException {
+        ConstraintSet<Pair> testSet = new ConstraintSet<>();
+        List<RefTypeOrTPHOrWildcardOrGeneric> list1 = Arrays.asList(TypePlaceholder.fresh(new NullToken()));
+        List<RefTypeOrTPHOrWildcardOrGeneric> list2 = Arrays.asList(TypePlaceholder.fresh(new NullToken()),TypePlaceholder.fresh(new NullToken()));
+        RefType t1 = new RefType(new JavaClassName("asp.UnifyWithoutWildcards$Matrix"), list1, new NullToken());
+        RefType t2 = new RefType(new JavaClassName("java.util.HashMap"), list2, new NullToken());
+        testSet.addUndConstraint(new Pair(t1, t2, PairOperator.SMALLERDOT));
+        ResultSet resultSet = run(testSet);
+        System.out.println(ResultSetPrinter.print(resultSet));
+        assert resultSet.results.size() > 0;
+    }
+
+    public ResultSet run(ConstraintSet<Pair> toTest) throws IOException, InterruptedException, ClassNotFoundException {
+        String content = "";
+        content = ASPFactory.generateASP(toTest, this.getFC());
+
+        PrintWriter writer = new PrintWriter(tempDirectory + "test.lp", "UTF-8");
+        writer.println(content);
+        writer.close();
+        Clingo clingo = new Clingo(Arrays.asList(new File(tempDirectory + "test.lp")));
+        String result = clingo.runClingo();
+        ResultSet resultSet = ASPParser.parse(result, getInvolvedTPHS(toTest));
+        return resultSet;
+    }
+
+    private static class TPHExtractor implements TypeVisitor<List<TypePlaceholder>>{
+        @Override
+        public List<TypePlaceholder> visit(RefType refType) {
+            ArrayList<TypePlaceholder> ret = new ArrayList<>();
+            for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
+                ret.addAll(param.acceptTV(this));
+            }
+            return ret;
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(SuperWildcardType superWildcardType) {
+            return superWildcardType.getInnerType().acceptTV(this);
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(TypePlaceholder typePlaceholder) {
+            return Arrays.asList(typePlaceholder);
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(ExtendsWildcardType extendsWildcardType) {
+            return extendsWildcardType.getInnerType().acceptTV(this);
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(GenericRefType genericRefType) {
+            return new ArrayList<>();
+        }
+    }
+
+    protected Collection<TypePlaceholder> getInvolvedTPHS(ConstraintSet<Pair> toTest) {
+        List<TypePlaceholder> ret = new ArrayList<>();
+        toTest.map((Pair p)-> {
+            ret.addAll(p.TA1.acceptTV(new TPHExtractor()));
+            ret.addAll(p.TA2.acceptTV(new TPHExtractor()));
+            return p;
+        });
+        return ret;
+    }
+
+    private Collection<ClassOrInterface> getFC() {
+        Set<ClassOrInterface> ret = new HashSet<>();
+        ret.add(ASTFactory.createClass(Matrix.class));
+        //ret.add(ASTFactory.createObjectClass());
+        //ret.add(ASTFactory.createClass(java.util.List.class));
+        return ret;
+    }
+    private class Matrix<A> extends HashMap<A,Map<Integer, A>>{}
+}

src/test/java/asp/gencay/GeneratorTest.java

@@ -0,0 +1,63 @@
+package asp.gencay;
+
+import asp.UnifyWithoutWildcards;
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.sat.asp.Clingo;
+import de.dhbwstuttgart.sat.asp.parser.ASPParser;
+import de.dhbwstuttgart.sat.asp.writer.ASPFactory;
+import de.dhbwstuttgart.sat.asp.writer.ASPGencayFactory;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.visual.ResultSetPrinter;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.*;
+import java.util.concurrent.ArrayBlockingQueue;
+
+public class GeneratorTest extends UnifyWithoutWildcards{
+    @Test
+    public void simple() throws ClassNotFoundException {
+        ConstraintSet<Pair> testSet = new ConstraintSet<>();
+        List<RefTypeOrTPHOrWildcardOrGeneric> list1 = Arrays.asList(TypePlaceholder.fresh(new NullToken()));
+        List<RefTypeOrTPHOrWildcardOrGeneric> list2 = Arrays.asList(TypePlaceholder.fresh(new NullToken()));
+        RefType t1 = new RefType(new JavaClassName("java.util.List"), list1, new NullToken());
+        RefType t2 = new RefType(new JavaClassName("java.util.List"), list2, new NullToken());
+        testSet.addUndConstraint(new Pair(t1, t2, PairOperator.SMALLERDOT));
+        String resultSet = ASPGencayFactory.generateASP(testSet,
+                new HashSet<>(Arrays.asList(ASTFactory.createClass(List.class))));
+        System.out.println(resultSet);
+    }
+
+    @Test
+    public void matrix() throws ClassNotFoundException {
+        ConstraintSet<Pair> testSet = new ConstraintSet<>();
+        List<RefTypeOrTPHOrWildcardOrGeneric> list1 = Arrays.asList(TypePlaceholder.fresh(new NullToken()));
+        List<RefTypeOrTPHOrWildcardOrGeneric> list2 = Arrays.asList(TypePlaceholder.fresh(new NullToken()),TypePlaceholder.fresh(new NullToken()));
+        RefType t1 = new RefType(new JavaClassName("asp.UnifyWithoutWildcards$Matrix"), list1, new NullToken());
+        RefType t2 = new RefType(new JavaClassName("java.util.HashMap"), list2, new NullToken());
+        testSet.addUndConstraint(new Pair(t1, t2, PairOperator.SMALLERDOT));
+        String resultSet = ASPGencayFactory.generateASP(testSet, this.getFC());
+        System.out.println(resultSet);
+    }
+
+    private Collection<ClassOrInterface> getFC() {
+        Set<ClassOrInterface> ret = new HashSet<>();
+        ret.add(ASTFactory.createClass(Matrix.class));
+        //ret.add(ASTFactory.createObjectClass());
+        //ret.add(ASTFactory.createClass(java.util.List.class));
+        return ret;
+    }
+}
+
+class Matrix extends Vector<Vector<Integer>> {}

src/test/java/asp/typeinference/ASPTest.java

@@ -0,0 +1,70 @@
+package asp.typeinference;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.sat.asp.writer.ASPFactory;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class ASPTest {
+
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/javFiles/";
+    private static final List<File> filesToTest = new ArrayList<>();
+    protected File fileToTest = null;
+
+    public ASPTest(){
+    }
+
+
+    @Test
+    public void test() throws IOException, ClassNotFoundException {
+        if(fileToTest != null)filesToTest.add(fileToTest);
+        else return;
+        //filesToTest.add(new File(rootDirectory+"Faculty.jav"));
+        //filesToTest.add(new File(rootDirectory+"mathStruc.jav"));
+        //filesToTest.add(new File(rootDirectory+"test.jav"));
+        filesToTest.add(new File(rootDirectory+"EmptyMethod.jav"));
+        //filesToTest.add(new File(rootDirectory+"fc.jav"));
+        //filesToTest.add(new File(rootDirectory+"Lambda.jav"));
+        //filesToTest.add(new File(rootDirectory+"Lambda2.jav"));
+        //filesToTest.add(new File(rootDirectory+"Lambda3.jav"));
+        //filesToTest.add(new File(rootDirectory+"Vector.jav"));
+        //filesToTest.add(new File(rootDirectory+"Generics.jav"));
+        //filesToTest.add(new File(rootDirectory+"MethodsEasy.jav"));
+        //filesToTest.add(new File(rootDirectory+"Matrix.jav"));
+        //filesToTest.add(new File(rootDirectory+"Import.jav"));
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        Set<ClassOrInterface> allClasses = new HashSet<>();
+        for(SourceFile sf : compiler.sourceFiles.values()) {
+            allClasses.addAll(compiler.getAvailableClasses(sf));
+        }
+        for(SourceFile sf : compiler.sourceFiles.values()) {
+            allClasses.addAll(sf.getClasses());
+        }
+
+        final ConstraintSet<Pair> cons = compiler.getConstraints();
+        String asp = ASPFactory.generateASP(cons, allClasses);
+        System.out.println(asp);
+    }
+
+    static String readFile(String path, Charset encoding)
+            throws IOException
+    {
+        byte[] encoded = Files.readAllBytes(Paths.get(path));
+        return new String(encoded, encoding);
+    }
+
+}
+

src/test/java/asp/typeinference/GenericsTest.java

@@ -0,0 +1,9 @@
+package asp.typeinference;
+
+import java.io.File;
+
+public class GenericsTest extends ASPTest {
+    public GenericsTest() {
+        this.fileToTest = new File(rootDirectory+"Generics.jav");
+    }
+}

src/test/java/asp/typeinference/VectorTest.java

@@ -0,0 +1,9 @@
+package asp.typeinference;
+
+import java.io.File;
+
+public class VectorTest extends ASPTest {
+    public VectorTest() {
+        this.fileToTest = new File(rootDirectory+"Vector.jav");
+    }
+}

src/test/java/asp/unifywithoutwildcards/ASPTests.java

@@ -0,0 +1,10 @@
+package asp.unifywithoutwildcards;
+
+import org.junit.Test;
+
+public class ASPTests {
+    @Test
+    public void test(){
+
+    }
+}

src/test/java/bytecode/OLTest.java

@@ -35,7 +35,7 @@ public class OLTest {
 		pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
 		List<ResultSet> typeinferenceResult = compiler.typeInference();
 		List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(typeinferenceResult);
-		compiler.generateBytecode(new File(pathToClassFile),typeinferenceResult,simplifyResultsForAllSourceFiles);
+		compiler.generateBytecode(pathToClassFile,typeinferenceResult,simplifyResultsForAllSourceFiles);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 		classToTest = loader.loadClass("OL");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();

src/test/java/finiteClosure/SuperInterfacesTest.java

@@ -14,14 +14,14 @@ public class SuperInterfacesTest {
     public void test() throws ClassNotFoundException {
         Collection<ClassOrInterface> classes = new ArrayList<>();
         classes.add(ASTFactory.createClass(TestClass.class));
-        System.out.println(FCGenerator.toFC(classes, ClassLoader.getSystemClassLoader()));
+        System.out.println(FCGenerator.toFC(classes));
     }
 
     @Test
     public void testGeneric() throws ClassNotFoundException {
         Collection<ClassOrInterface> classes = new ArrayList<>();
         classes.add(ASTFactory.createClass(TestClassGeneric.class));
-        System.out.println(FCGenerator.toFC(classes, ClassLoader.getSystemClassLoader()));
+        System.out.println(FCGenerator.toFC(classes));
     }
 }
 

src/test/java/packages/Bytecode.java

@@ -1,52 +0,0 @@
-package packages;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import junit.framework.TestCase;
-import org.junit.Test;
-
-import java.io.File;
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.net.URL;
-import java.net.URLClassLoader;
-
-public class Bytecode extends TestCase {
-
-    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/";
-    @Test
-    public void testSetPackageNameInBytecode() throws Exception {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"de/test/TestClass.jav"));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "de/test/TestClass.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode();
-        f = new File(rootDirectory + "de/test/TestClass.class");
-        assertTrue(f.exists());
-
-
-        URLClassLoader loader = new URLClassLoader(new URL[]{new URL("file://" + rootDirectory)});
-        Class<?> classToTest = loader.loadClass("de.test.TestClass");
-        Object instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
-    }
-
-    @Test
-    public void testSetPackageNameInBytecodeAndOutputFolder() throws Exception {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"de/test/TestClass.jav"));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "de/test/output/de/test/TestClass.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode(rootDirectory + "de/test/output/");
-        f = new File(rootDirectory + "de/test/output/de/test/TestClass.class");
-        assertTrue(f.exists());
-
-        URLClassLoader loader = new URLClassLoader(new URL[]{new URL("file://" + rootDirectory + "de/test/output/")});
-        Class<?> classToTest = loader.loadClass("de.test.TestClass");
-        Object instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
-    }
-
-
-}

src/test/java/packages/CheckPackageFolder.java

@@ -1,80 +0,0 @@
-package packages;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
-import junit.framework.TestCase;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Arrays;
-
-public class CheckPackageFolder extends TestCase {
-
-    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/de/test/";
-
-    @Test
-    public void testCorrectFolder1FileWithWrongPackageName() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"packageNameTestWrongPackage.jav"));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "TestClass.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode();
-        f = new File(rootDirectory + "TestClass.class");
-        assertTrue(f.exists()); //Es ist erlaubt falsche package Namen zu verwenden. Warnung wäre optional
-    }
-
-    @Test
-    public void testCorrectFolder1File() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"TestClass.jav"));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "TestClass.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode();
-        f = new File(rootDirectory + "TestClass.class");
-        assertTrue(f.exists()); //Es ist erlaubt falsche package Namen zu verwenden. Warnung wäre optional
-    }
-
-    @Test
-    public void testCorrectFolder1FileAndOutputDirectory() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"TestClass.jav"));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "output/de/test/TestClass.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode(rootDirectory+"output/");
-        f = new File(rootDirectory + "output/de/test/TestClass.class");
-        assertTrue(f.exists()); //Es ist erlaubt falsche package Namen zu verwenden. Warnung wäre optional
-    }
-
-    /*
-    * Dieser Test wird übersprungen, da der Bytecode-Generator nicht mit zwei Eingabedateien gleichzeitig umgehen kann
-    @Test
-    public void testCorrectFolder2Files() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(Arrays.asList(
-                new File(rootDirectory+"subpackage1/Test1.jav"),
-                new File(rootDirectory+"subpackage2/Test2.jav")
-                ));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "subpackage1/Test1.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        File f2 = new File(rootDirectory + "subpackage2/Test2.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode();
-        f = new File(rootDirectory + "subpackage1/Test1.class");
-        f2 = new File(rootDirectory + "subpackage2/Test2.class");
-        assertTrue(f.exists());
-        assertTrue(f2.exists());
-    }
-     */
-}

src/test/java/packages/ConsoleInterfaceTest.java

@@ -1,133 +0,0 @@
-package packages;
-
-import de.dhbwstuttgart.core.ConsoleInterface;
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import junit.framework.TestCase;
-import org.junit.Test;
-
-import java.io.File;
-import java.net.URL;
-import java.net.URLClassLoader;
-
-public class ConsoleInterfaceTest extends TestCase {
-
-    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/";
-
-    @Test
-    public void testCompileSingleJavFile() throws Exception {
-        File f = new File(rootDirectory + "de/test/TestClass.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-
-        ConsoleInterface.main(new String[]{rootDirectory + "de/test/TestClass.jav"});
-
-        f = new File(rootDirectory + "de/test/TestClass.class");
-        assertTrue(f.exists());
-    }
-
-    @Test
-    public void testCompileSingleJavFileWithOutputDirectory() throws Exception {
-        File f = new File(rootDirectory + "de/test/output/de/test/TestClass.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-
-        ConsoleInterface.main(new String[]{"-d", rootDirectory + "de/test/output/" ,rootDirectory + "de/test/TestClass.jav"});
-
-        f = new File(rootDirectory + "de/test/output/de/test/TestClass.class");
-        assertTrue(f.exists());
-    }
-
-    @Test
-    public void testCpNotEndsWithSlash() throws Exception {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"/de/test/ToImport.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode(rootDirectory + "output/");
-        File f = new File(rootDirectory + "output/de/test/ToImport.class");
-        assertTrue(f.exists());
-
-        f = new File(rootDirectory + "de/test/ImportTest.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-
-        ConsoleInterface.main(new String[]{"-cp", rootDirectory + "de/test/output" , rootDirectory + "de/test/ImportTest.jav"});
-
-        f = new File(rootDirectory + "de/test/ImportTest.class");
-        assertTrue(f.exists());
-    }
-
-    @Test
-    public void testOutputDirNotEndsWithSlash() throws Exception {
-        File f = new File(rootDirectory + "de/test/output/de/test/TestClass.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-
-        ConsoleInterface.main(new String[]{"-d", rootDirectory + "de/test/output" ,rootDirectory + "de/test/TestClass.jav"});
-
-        f = new File(rootDirectory + "de/test/output/de/test/TestClass.class");
-        assertTrue(f.exists());
-    }
-
-    @Test
-    public void testCompileSingleJavFileWithClassPath() throws Exception {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"/de/test/ToImport.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode(rootDirectory + "output/");
-        File f = new File(rootDirectory + "output/de/test/ToImport.class");
-        assertTrue(f.exists());
-
-        f = new File(rootDirectory + "de/test/ImportTest.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-
-        ConsoleInterface.main(new String[]{"-cp", rootDirectory + "de/test/output/" ,rootDirectory + "de/test/ImportTest.jav"});
-
-        f = new File(rootDirectory + "de/test/ImportTest.class");
-        assertTrue(f.exists());
-    }
-
-    @Test
-    public void testCompileSingleJavFileWithMultipleClassPath() throws Exception {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"/de/test/ToImport.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode(rootDirectory + "output/");
-        File f = new File(rootDirectory + "output/de/test/ToImport.class");
-        assertTrue(f.exists());
-
-        f = new File(rootDirectory + "de/test/ImportTest.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-
-        ConsoleInterface.main(new String[]{"-cp", rootDirectory + "de/test/output/:"+rootDirectory+"de",
-                rootDirectory + "de/test/ImportTest.jav"});
-
-        f = new File(rootDirectory + "de/test/ImportTest.class");
-        assertTrue(f.exists());
-    }
-
-    @Test
-    public void testCompileSingleJavFileWithClassPathAndOutputDir() throws Exception {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"/de/test/ToImport.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode(rootDirectory + "output/");
-        File f = new File(rootDirectory + "output/de/test/ToImport.class");
-        assertTrue(f.exists());
-
-        f = new File(rootDirectory + "de/test/output/de/test/ImportTest.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-
-        ConsoleInterface.main(new String[]{"-cp", rootDirectory + "de/test/output/",
-                "-d"+rootDirectory + "de/test/output/" ,rootDirectory + "de/test/ImportTest.jav"});
-
-        f = new File(rootDirectory + "de/test/output/de/test/ImportTest.class");
-        assertTrue(f.exists());
-    }
-
-}

src/test/java/packages/ImportTest.java

@@ -1,108 +0,0 @@
-package packages;
-
-import com.google.common.collect.Lists;
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import junit.framework.TestCase;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.URL;
-
-public class ImportTest extends TestCase {
-
-    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/de/test/";
-
-
-    public ImportTest() throws ClassNotFoundException, IOException {
-        /*
-        Generate ToImport class in rootDirectory and in output-Directory
-         */
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"ToImport.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode(rootDirectory + "output/");
-        File f = new File(rootDirectory + "output/de/test/ToImport.class");
-        assertTrue(f.exists());
-
-        compiler = new JavaTXCompiler(new File(rootDirectory+"ToImport.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode();
-        f = new File(rootDirectory + "ToImport.class");
-        assertTrue(f.exists());
-
-        compiler = new JavaTXCompiler(new File(rootDirectory+"subpackage1/ToImport2.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode(rootDirectory + "output/");
-        f = new File(rootDirectory + "output/de/test/subpackage1/ToImport2.class");
-        assertTrue(f.exists());
-
-        compiler = new JavaTXCompiler(new File(rootDirectory+"subpackage2/ToImport3.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode(rootDirectory + "output/");
-        f = new File(rootDirectory + "output/de/test/subpackage2/ToImport3.class");
-        assertTrue(f.exists());
-    }
-
-    @Test
-    public void testSetPackageNameInBytecodeAndOutputFolder() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(
-                Lists.newArrayList(new File(rootDirectory+"ImportTest.jav")),
-                Lists.newArrayList(new File(rootDirectory+"output/")));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "output/de/test/ImportTest.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode(rootDirectory + "output/");
-        f = new File(rootDirectory + "output/de/test/ImportTest.class");
-        assertTrue(f.exists());
-    }
-
-    @Test
-    public void testSetPackageNameInBytecodeAndStandardOutputFolder() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(
-                Lists.newArrayList(new File(rootDirectory+"ImportTest.jav")),
-                Lists.newArrayList(new File(rootDirectory+"output/")));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "ImportTest.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode();
-        f = new File(rootDirectory + "ImportTest.class");
-        assertTrue(f.exists());
-    }
-
-
-    @Test
-    public void testImportTwoClasses() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(
-                Lists.newArrayList(new File(rootDirectory+"ImportTest2.jav")),
-                Lists.newArrayList(new File(rootDirectory+"output/")));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "ImportTest2.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode();
-        f = new File(rootDirectory + "ImportTest2.class");
-        assertTrue(f.exists());
-    }
-
-    @Test
-    public void testImportDefaultPackage() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(
-                Lists.newArrayList(new File(rootDirectory+"ImportTestDefault.jav")));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "ImportTestDefault.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode();
-        f = new File(rootDirectory + "ImportTestDefault.class");
-        assertTrue(f.exists());
-    }
-
-
-}

src/test/java/packages/LoadDefaultPackageClassesTest.java

@@ -1,55 +0,0 @@
-package packages;
-
-import com.google.common.collect.Lists;
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.environment.CompilationEnvironment;
-import junit.framework.TestCase;
-import org.junit.Test;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.URL;
-import java.net.URLClassLoader;
-
-public class LoadDefaultPackageClassesTest extends TestCase {
-
-    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/";
-
-
-    public LoadDefaultPackageClassesTest() throws ClassNotFoundException, IOException {
-        /*
-        Generate ToImport class in rootDirectory and in output-Directory
-         */
-    	JavaTXCompiler compiler = new JavaTXCompiler(
-				Lists.newArrayList(new File(rootDirectory+"Gen.jav")),
-                Lists.newArrayList(new File(rootDirectory+"/de/test/output/")));
-        compiler.typeInference();
-        compiler.generateBytecode();
-        File f = new File(rootDirectory + "Gen.class");
-        assertTrue(f.exists());
-    }
-
-    public void testLoadGenClass() throws IOException, ClassNotFoundException {
-        CompilationEnvironment.loadDefaultPackageClasses(new File( rootDirectory + "Test.jav"), ClassLoader.getSystemClassLoader());
-    }
-
-    public void testURLClassLoader() throws IOException, ClassNotFoundException {
-        URLClassLoader cl = new URLClassLoader(new URL[]{new URL("file://"+rootDirectory)}, ClassLoader.getSystemClassLoader());
-        cl.loadClass("Gen");
-    }
-/*
-    public void testE2E() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"OL.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode();
-        File f = new File(rootDirectory + "OL.class");
-        assertTrue(f.exists());
-
-        compiler = new JavaTXCompiler(new File(rootDirectory+"OLMain.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode();
-        f = new File(rootDirectory + "OLMain.class");
-        assertTrue(f.exists());
-    }
-    */
-}

src/test/java/packages/OLOneFileTest.java

@@ -1,133 +0,0 @@
-package packages;
-
-import static org.junit.Assert.*;
-
-import java.io.File;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.List;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import com.google.common.collect.Lists;
-
-import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-
-public class OLOneFileTest {
-	private static String path;
-	private static File fileToTest;
-	private static JavaTXCompiler compiler;
-	private static ClassLoader loader;
-	private static Class<?> classToTest;
-	private static Class<?> classToTest1;
-	private static Class<?> classToTest2;
-	private static String pathToClassFile;
-	private static Object instanceOfClass;
-	private static Object instanceOfClass1;
-	private static Object instanceOfClass2;
-
-	public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/";
-	
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		path = rootDirectory +"OLOneFile.jav";
-		fileToTest = new File(path);
-		compiler = new JavaTXCompiler(
-				Lists.newArrayList(fileToTest),
-                Lists.newArrayList(new File(rootDirectory+"de/test/output/")));
-		pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/";
-		List<ResultSet> typeinferenceResult = compiler.typeInference();
-		List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(typeinferenceResult);
-		compiler.generateBytecode(new File(pathToClassFile),typeinferenceResult,simplifyResultsForAllSourceFiles);
-		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
-		classToTest = loader.loadClass("OLOneFile");
-		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
-		classToTest1 = loader.loadClass("OLextendsOneFile");
-		instanceOfClass1 = classToTest1.getDeclaredConstructor().newInstance();
-		classToTest2 = loader.loadClass("OLMainOneFile");
-		instanceOfClass2 = classToTest2.getDeclaredConstructor().newInstance();
-	}
-	
-	@Test
-	public void testOLClassName() {
-		assertEquals("OLOneFile", classToTest.getName());
-	}
-	
-	@Test
-	public void testmInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method m = classToTest.getDeclaredMethod("m2", Integer.class);
-		Integer result = (Integer) m.invoke(instanceOfClass, 5);
-		assertEquals(new Integer(10), result);
-	}
-	
-	@Test
-	public void testmDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method m = classToTest.getDeclaredMethod("m2", Double.class);
-		Double result = (Double) m.invoke(instanceOfClass, 5.0);
-		assertEquals(new Double(10.0), result);
-	}
-	
-	@Test
-	public void testmString() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method m = classToTest.getDeclaredMethod("m2", String.class);
-		String result = (String) m.invoke(instanceOfClass, "xxx");
-		assertEquals("xxxxxx", result);
-	}
-	
-	@Test
-	public void testOLextendsClassName() {
-		assertEquals("OLextendsOneFile", classToTest1.getName());
-	}
-	
-	@Test
-	public void testextendsInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest1.getMethod("m2", Integer.class);
-		Integer result = (Integer) main.invoke(instanceOfClass1, 5);
-		assertEquals(new Integer(10), result);
-	}
-	
-	@Test
-	public void testextendsDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest1.getMethod("m2", Double.class);
-		Double result = (Double) main.invoke(instanceOfClass1, 5.0);
-		assertEquals(new Double(10.0), result);
-	}
-	
-	@Test
-	public void testextendsString() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest1.getMethod("m2", String.class);
-		String result = (String) main.invoke(instanceOfClass1, "xxx");
-		assertEquals("xxxxxx", result);
-	}
-	
-	@Test
-	public void testOLMainClassName() {
-		assertEquals("OLMainOneFile", classToTest2.getName());
-	}
-	
-	@Test
-	public void testmainInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest2.getDeclaredMethod("main", Integer.class);
-		Integer result = (Integer) main.invoke(instanceOfClass2, 5);
-		assertEquals(new Integer(10), result);
-	}
-	
-	@Test
-	public void testmainDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest2.getDeclaredMethod("main", Double.class);
-		Double result = (Double) main.invoke(instanceOfClass2, 5.0);
-		assertEquals(new Double(10.0), result);
-	}
-	
-	@Test
-	public void testmainString() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest2.getDeclaredMethod("main", String.class);
-		String result = (String) main.invoke(instanceOfClass2, "xxx");
-		assertEquals("xxxxxx", result);
-	}
-}

src/test/java/packages/OLTest.java

@@ -1,147 +0,0 @@
-package packages;
-
-import static org.junit.Assert.*;
-
-import java.io.File;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.List;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import com.google.common.collect.Lists;
-
-import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-
-public class OLTest {
-	private static String path;
-	private static File fileToTest;
-	private static JavaTXCompiler compiler;
-	private static ClassLoader loader;
-	private static Class<?> classToTest;
-	private static Class<?> classToTest1;
-	private static Class<?> classToTest2;
-	private static String pathToClassFile;
-	private static Object instanceOfClass;
-	private static Object instanceOfClass1;
-	private static Object instanceOfClass2;
-	
-	public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest";
-	
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"/de/test/OL.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode(rootDirectory + "/de/test/output/");
-        loader = new URLClassLoader(new URL[] {new URL("file://"+ rootDirectory + "/de/test/output/")});
-        classToTest = loader.loadClass("de.test.OL");
-        instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
-        
-		path = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/OLextends.jav";
-		fileToTest = new File(path);
-		compiler = new JavaTXCompiler(
-                Lists.newArrayList(new File(rootDirectory+"/OLextends.jav")),
-                Lists.newArrayList(new File(rootDirectory+"/de/test/output/")));
-		//compiler = new JavaTXCompiler(fileToTest);
-		pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/";
-		compiler.generateBytecode(pathToClassFile);
-		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile), new URL("file://"+ rootDirectory + "/de/test/output/")});
-		classToTest1 = loader.loadClass("OLextends");
-		instanceOfClass1 = classToTest1.getDeclaredConstructor().newInstance();
-		
-		path = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/OLMain.jav";
-		fileToTest = new File(path);
-		compiler = new JavaTXCompiler(
-                Lists.newArrayList(new File(rootDirectory+"/OLMain.jav")),
-                Lists.newArrayList(new File(rootDirectory+"/de/test/output/")));
-		//compiler = new JavaTXCompiler(fileToTest);
-		pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/";
-		compiler.generateBytecode(pathToClassFile);
-		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile), new URL("file://"+ rootDirectory + "/de/test/output/")});
-		classToTest2 = loader.loadClass("OLMain");
-		instanceOfClass2 = classToTest2.getDeclaredConstructor().newInstance();
-	}
-	
-	@Test
-	public void testOLClassName() {
-		assertEquals("de.test.OL", classToTest.getName());
-	}
-	
-	@Test
-	public void testmInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method m = classToTest.getDeclaredMethod("m", Integer.class);
-		Integer result = (Integer) m.invoke(instanceOfClass, 5);
-		assertEquals(new Integer(10), result);
-	}
-	
-	@Test
-	public void testmDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method m = classToTest.getDeclaredMethod("m", Double.class);
-		Double result = (Double) m.invoke(instanceOfClass, 5.0);
-		assertEquals(new Double(10.0), result);
-	}
-	
-	@Test
-	public void testmString() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method m = classToTest.getDeclaredMethod("m", String.class);
-		String result = (String) m.invoke(instanceOfClass, "xxx");
-		assertEquals("xxxxxx", result);
-	}
-	
-	@Test
-	public void testOLextendsClassName() {
-		assertEquals("OLextends", classToTest1.getName());
-	}
-	
-	@Test
-	public void testextendsInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest1.getMethod("m", Integer.class);
-		Integer result = (Integer) main.invoke(instanceOfClass1, 5);
-		assertEquals(new Integer(10), result);
-	}
-	
-	@Test
-	public void testextendsDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest1.getMethod("m", Double.class);
-		Double result = (Double) main.invoke(instanceOfClass1, 5.0);
-		assertEquals(new Double(10.0), result);
-	}
-	
-	@Test
-	public void testextendsString() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest1.getMethod("m", String.class);
-		String result = (String) main.invoke(instanceOfClass1, "xxx");
-		assertEquals("xxxxxx", result);
-	}
-	
-	@Test
-	public void testOLMainClassName() {
-		assertEquals("OLMain", classToTest2.getName());
-	}
-	
-	@Test
-	public void testmainInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest2.getDeclaredMethod("main", Integer.class);
-		Integer result = (Integer) main.invoke(instanceOfClass2, 5);
-		assertEquals(new Integer(10), result);
-	}
-	
-	@Test
-	public void testmainDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest2.getDeclaredMethod("main", Double.class);
-		Double result = (Double) main.invoke(instanceOfClass2, 5.0);
-		assertEquals(new Double(10.0), result);
-	}
-	
-	@Test
-	public void testmainString() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-		Method main = classToTest2.getDeclaredMethod("main", String.class);
-		String result = (String) main.invoke(instanceOfClass2, "xxx");
-		assertEquals("xxxxxx", result);
-	}
-}

src/test/java/packages/ParsePackageName.java

@@ -1,21 +0,0 @@
-package packages;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
-import org.junit.Test;
-
-import java.io.File;
-import java.io.IOException;
-
-public class ParsePackageName {
-
-    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/de/test/";
-    @Test
-    public void parsePackage() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"TestClass.jav"));
-        for(File f : compiler.sourceFiles.keySet()){
-            SourceFile sf = compiler.sourceFiles.get(f);
-            assert sf.getPkgName().equals("de.test");
-        }
-    }
-}

src/test/java/packages/mathStrucVectorTest.java

@@ -1,54 +0,0 @@
-package packages;
-
-import com.google.common.collect.Lists;
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import junit.framework.TestCase;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.URL;
-
-public class mathStrucVectorTest extends TestCase {
-
-    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/javFiles/packageTest/de/test/";
-
-
-    public mathStrucVectorTest() throws ClassNotFoundException, IOException {
-        /*
-        Generate ToImport class in rootDirectory and in output-Directory
-         */
-
-/* PL 2020-01-07 kann z.Zt. nicht erzeugt werden (siehe Bug 170, http://bugzilla.ba-horb.de/show_bug.cgi?id=170)
-        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"mathStruc.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode(rootDirectory + "output/");
-        File f = new File(rootDirectory + "output/de/test/mathStruc.class");
-        assertTrue(f.exists());
- */
-    	JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"vectorAdd.jav"));
-        compiler.typeInference();
-        compiler.generateBytecode(rootDirectory + "output/");
-        File f = new File(rootDirectory + "output/de/test/vectorAdd.class");
-        assertTrue(f.exists());
-
-    }
-    
-    @Test
-    public void testSetPackageNameInBytecodeAndOutputFolder() throws IOException, ClassNotFoundException {
-        JavaTXCompiler compiler = new JavaTXCompiler(
-                Lists.newArrayList(new File(rootDirectory+"mathStrucVector.jav")),
-                Lists.newArrayList(new File(rootDirectory+"output/")));
-        compiler.typeInference();
-        File f = new File(rootDirectory + "output/de/test/mathStrucVector.class");
-        if(f.exists() && !f.isDirectory()) {
-            f.delete();
-        }
-        compiler.generateBytecode(rootDirectory + "output/");
-        f = new File(rootDirectory + "output/de/test/mathStrucVector.class");
-        assertTrue(f.exists());
-    }
-
-    
-}

src/test/java/typeinference/JavaTXCompilerTest.java

@@ -1,5 +1,6 @@
 package typeinference;
 
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
@@ -28,10 +29,6 @@ public class JavaTXCompilerTest {
         execute(new File(rootDirectory+"fc.jav"));
     }
     @Test
-    public void importTest() throws IOException, ClassNotFoundException {
-        execute(new File(rootDirectory+"Import.jav"));
-    }
-    @Test
     public void lambda() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"Lambda.jav"));
     }
@@ -137,7 +134,8 @@ public class JavaTXCompilerTest {
             System.out.println(ASTPrinter.print(sf));
         }
         List<ResultSet> results = compiler.typeInference();
-
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        //compiler.generateBytecode(rootDirectory+"xxx.class", results, simplifyResultsForAllSourceFiles);
         for(File f : compiler.sourceFiles.keySet()){
             SourceFile sf = compiler.sourceFiles.get(f);
             System.out.println(ASTTypePrinter.print(sf));
@@ -146,7 +144,7 @@ public class JavaTXCompilerTest {
             assert results.size()>0;
             Set<String> insertedTypes = new HashSet<>();
             for(ResultSet resultSet : results){
-                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results);
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
                 assert result.size()>0;
                 String content = readFile(f.getPath(), StandardCharsets.UTF_8);
                 for(TypeInsert tip : result){

src/test/java/typeinference/Meth_GenTest.java

@@ -1,5 +1,6 @@
 package typeinference;
 
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
@@ -105,6 +106,7 @@ public class Meth_GenTest {
             System.out.println(ASTPrinter.print(sf));
         }
         List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
 
         for(File f : compiler.sourceFiles.keySet()){
             SourceFile sf = compiler.sourceFiles.get(f);
@@ -114,7 +116,7 @@ public class Meth_GenTest {
             assert results.size()>0;
             Set<String> insertedTypes = new HashSet<>();
             for(ResultSet resultSet : results){
-                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results);
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
                 assert result.size()>0;
                 String content = readFile(f.getPath(), StandardCharsets.UTF_8);
                 for(TypeInsert tip : result){

src/test/java/typeinference/UnifyTest.java

@@ -1,5 +1,6 @@
 package typeinference;
 
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
@@ -131,6 +132,7 @@ public class UnifyTest {
             System.out.println(ASTPrinter.print(sf));
         }
         List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
 
         for(File f : compiler.sourceFiles.keySet()){
             SourceFile sf = compiler.sourceFiles.get(f);
@@ -140,7 +142,7 @@ public class UnifyTest {
             assert results.size()>0;
             Set<String> insertedTypes = new HashSet<>();
             for(ResultSet resultSet : results){
-                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results);
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
                 assert result.size()>0;
                 String content = readFile(f.getPath(), StandardCharsets.UTF_8);
                 for(TypeInsert tip : result){

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

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

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

@@ -1,7 +1,7 @@
 import java.lang.Integer;
 
 public class Field {
-	public Integer x = 5;
+	public x = 5;
 	
 	m(){
 		return x;

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

@@ -7,10 +7,9 @@ import java.lang.Boolean;
 
 public class OL     {
 
-     java.lang.Double m(java.lang.Double x) { return x + x; }
-     java.lang.Integer m(java.lang.Integer x) { return x + x; }
-     java.lang.String m(java.lang.String x) { return x + x; }
-     java.lang.Boolean m(Boolean x) { return x; } 
+     m(x) { return x + x; }
+     
+     m(Boolean x) { return x; } 
      
 // if the class contains just this method, then correct BC will be generated.
 // But if another methods are contained then the generated BC is not correct

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

@@ -37,5 +37,5 @@ public class VectorAdd {
 //	var y;
 //	x.add(y);
 //	z = x; 
-// }
+}
 }

src/test/resources/javFiles/IfTest.jav

@@ -2,7 +2,7 @@ import java.lang.Integer;
 import java.lang.Boolean;
 import java.lang.Object;
 
-public class IfTest{
+public class IfTest {
 	Object m1(b) {
 		Integer i;
 		if(b) {

src/test/resources/javFiles/Import.jav

@@ -2,7 +2,7 @@ import java.util.Vector;
 
 class Import {
     void methode(){
-        var v;
+        Vector v;
         v.add(v);
     }
 }

src/test/resources/javFiles/ListenerOverload.jav

@@ -14,7 +14,7 @@ call(String s){}
 
 }
 
-class Pair<A,B>{
-    A left;
-    B right;
+class Pair{
+     left;
+     right;
 }

src/test/resources/javFiles/fc.jav

@@ -8,7 +8,7 @@ class Test{
 }
 
 interface Klasse1{
-    Klasse1 meth(List p);
+    Klasse1 meth(p);
     Klasse1 meth(Klasse2 p);
 }
 

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

@@ -1,8 +0,0 @@
-import java.lang.Integer;
-import java.util.Vector;
-
-public class Gen{
-	Vector<Integer> m(Vector<Integer> v){
-		return v;
-	}
-}

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

@@ -1,12 +0,0 @@
-import java.lang.String;
-import java.lang.Integer;
-import java.lang.Double; 
-
-public class OLMain   {
-
-	main(x) { 
-		var ol;
-		ol = new OLextends(); 
-		return ol.m(x); 
-	}  
-}

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

@@ -1,22 +0,0 @@
-import java.lang.String;
-import java.lang.Integer;
-import java.lang.Double; 
-import java.lang.Boolean;
-
-
-public class OLOneFile     {
-
-     m2(x) { return x + x; }
-	
-}
-
-public class OLextendsOneFile extends OLOneFile { } 
-
-public class OLMainOneFile   {
-
-	main(x) { 
-		var ol;
-		ol = new OLextendsOneFile(); 
-		return ol.m2(x); 
-	}  
-}

src/test/resources/javFiles/packageTest/OLTest.txt

@@ -1,6 +0,0 @@
-java -jar ~/eclipse-workspace/JavaCompilerCore/target/JavaTXcompiler-0.2-jar-with-dependencies.jar de/test/OL.jav -d de/test/output
-java -jar ~/eclipse-workspace/JavaCompilerCore/target/JavaTXcompiler-0.2-jar-with-dependencies.jar OLextends.jav -cp de/test/output
-java -jar ~/eclipse-workspace/JavaCompilerCore/target/JavaTXcompiler-0.2-jar-with-dependencies.jar OLMain.jav -cp .:de/test/output
-javac UseOLMain.java
-java -cp .:de/test/output UseOLMain
-rm -f UseOLMain.class

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

@@ -1,7 +0,0 @@
-import de.test.OL; 
-
-
-public class OLextends extends OL     {
-
-	
-}

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

@@ -1,3 +0,0 @@
-
-public class Test{
-}

src/test/resources/javFiles/packageTest/UseOLMain.java

@@ -1,5 +0,0 @@
-class UseOLMain {
-    public static void main(String[] arg) {
-	System.out.println(new OLMain().main(1+1));
-    }
-}

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

@@ -1,9 +0,0 @@
-package de.test;
-
-import de.test.ToImport;
-
-class ImportTest{
-    void methode(){
-        new ToImport();
-    }
-}

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

@@ -1,11 +0,0 @@
-package de.test;
-
-import de.test.subpackage1.ToImport2;
-import de.test.subpackage2.ToImport3;
-
-class ImportTest2{
-    void methode(){
-        new ToImport2().m1();
-        new ToImport3().m2();
-    }
-}

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

@@ -1,7 +0,0 @@
-package de.test;
-
-class ImportTestDefault{
-    void methode(){
-        new ToImport();
-    }
-}

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

@@ -1,13 +0,0 @@
-package de.test;
-import java.lang.String;
-import java.lang.Integer;
-import java.lang.Double; 
-import java.lang.Boolean;
-//import java.util.Vector;
-
-
-public class OL     {
-
-     public m(x) { return x + x; }
-	
-}

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

@@ -1,3 +0,0 @@
-package de.test;
-
-public class TestClass{}

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

@@ -1,4 +0,0 @@
-package de.test;
-
-class ToImport{
-}

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

@@ -1,18 +0,0 @@
-package de.test;
-
-
-import java.util.Vector;
-import java.lang.Integer;
-
-public class mathStruc {
-	model; 
-	
-	//Fun1*<Fun2*<A,A,A>, Fun1*<MathStruc <A>,MathStruc <A>>> 
-	innerOp = (o) -> (ms) -> new mathStruc<>(o.apply(model,ms.model));
-
-	public mathStruc(m) {
-		model =m;
-		//innerOp = (o) -> (ms) -> new mathStruc<>(o.apply(this.model,ms.model));
-	}
-}
-

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

@@ -1,33 +0,0 @@
-package de.test;
-
-import java.util.Vector;
-import java.lang.Integer;
-import java.lang.Boolean;
-
-import de.test.mathStruc;
-import de.test.vectorAdd;
-
-
-public class mathStrucVector {
-
-    public main() {
-		Vector<Integer> v1 = new Vector<Integer>();
-		v1.addElement(2);
-		v1.addElement(2);
-		Vector<Integer> v2 = new Vector<Integer>();
-		v2.addElement(3);
-		v2.addElement(3);
-
-		vectorAdd va = new vectorAdd();
-
-		var ms;
-		ms = new mathStruc<>(v1);
-		var ms2;
-		ms2 = new mathStruc<>(v2);
-		var ms3;
-		
-		ms3 = ms.innerOp.apply(va.add).apply(ms2);
-		return ms3;
-		
-    }
-}

src/test/resources/javFiles/packageTest/de/test/output/de/test/mathStrucVectoruse.java

@@ -1,10 +0,0 @@
-package de.test;
-import de.test.mathStrucVector;
-
-
-class mathStrucVectorUse {
-
-    public static void main(String[] args) {
-	new mathStrucVector().main();
-    }
-}

src/test/resources/javFiles/packageTest/de/test/output/mathStrucVectoruse.java

@@ -1,8 +0,0 @@
-
-
-class mathStrucVectorUse {
-
-    public static void main(String[] args) {
-	new mathStrucVector().main();
-    }
-}

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

@@ -1,3 +0,0 @@
-package de.tesst;
-
-class TestClass{}

src/test/resources/javFiles/packageTest/de/test/subpackage1/Test1.jav

@@ -1,4 +0,0 @@
-package de.test.subpackage1;
-
-class Test1{
-}