Änderung von OLFun.jav zum originalen Sourcecode.

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

pom.xml

@@ -118,15 +118,6 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 					</descriptorRefs>
 				</configuration>
 			</plugin>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-compiler-plugin</artifactId>
-				<configuration>
-					<source>17</source>
-					<target>17</target>
-					<compilerArgs>--enable-preview</compilerArgs>
-				</configuration>
-			</plugin>
 		</plugins>
 	</build>
 	<repositories>
@@ -138,11 +129,8 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 	<properties>
 	    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-		<maven.compiler.source>17</maven.compiler.source>
-		<maven.compiler.target>17</maven.compiler.target>
-		<compilerArgs>
-			--enable-preview
-		</compilerArgs>
+		<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>

src/main/antlr4/sat/UnifyResult.g4

@@ -0,0 +1,37 @@
+grammar UnifyResult;
+
+answer : 'ANSWER' (resultSetRule '.')*;
+
+resultSetRule :
+      parameter
+    | equals
+    | smaller
+    | typeVar
+    | type
+    | otherRule
+    ;
+
+parameterList : '(' value (',' value)*  ')';
+value : NAME
+        | resultSetRule ;
+
+parameter : PARAMLIST_NAME parameterList;
+equals : EQUALS_NAME parameterList;
+smaller : SMALLER_NAME parameterList;
+typeVar : TYPEVAR_NAME parameterList;
+type : TYPE_NAME parameterList;
+otherRule : NAME parameterList;
+
+//TODO: Es sollte Regeln für das Result set geben, welche sich nicht mit den anderen überdecken, dann auch nur diese im Result ausgeben
+PARAMLIST_NAME : 'param';
+EQUALS_NAME : 'equals';
+SMALLER_NAME : 'smaller';
+TYPEVAR_NAME : 'typeVar';
+TYPE_NAME : 'type';
+NAME : [a-zA-Z0-9_]+;
+
+WS  :  [ \t\r\n\u000C]+ -> skip
+    ;
+LINE_COMMENT
+    :   '%' ~[\r\n]* -> skip
+    ;

src/main/antlr4/sat/UnifyResult.tokens

@@ -0,0 +1,23 @@
+T__0=1
+T__1=2
+T__2=3
+T__3=4
+T__4=5
+PARAMLIST_NAME=6
+EQUALS_NAME=7
+SMALLER_NAME=8
+TYPEVAR_NAME=9
+TYPE_NAME=10
+NAME=11
+WS=12
+LINE_COMMENT=13
+'ANSWER'=1
+'.'=2
+'('=3
+','=4
+')'=5
+'param'=6
+'equals'=7
+'smaller'=8
+'typeVar'=9
+'type'=10

src/main/antlr4/sat/UnifyResultLexer.tokens

@@ -0,0 +1,23 @@
+T__0=1
+T__1=2
+T__2=3
+T__3=4
+T__4=5
+PARAMLIST_NAME=6
+EQUALS_NAME=7
+SMALLER_NAME=8
+TYPEVAR_NAME=9
+TYPE_NAME=10
+NAME=11
+WS=12
+LINE_COMMENT=13
+'ANSWER'=1
+'.'=2
+'('=3
+','=4
+')'=5
+'param'=6
+'equals'=7
+'smaller'=8
+'typeVar'=9
+'type'=10

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

@@ -13,10 +13,7 @@ import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.stream.Collectors;
 
-import de.dhbwstuttgart.bytecode.funN.FunNGenerator;
-import de.dhbwstuttgart.bytecode.funN.FunNUtilities;
 import de.dhbwstuttgart.bytecode.utilities.*;
 import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
@@ -587,26 +584,16 @@ public class BytecodeGenMethod implements StatementVisitor {
 		}
 	}
 
+	//ToDo Etienne: Für Type Erasure relevant?!
 	@Override
 	public void visit(LambdaExpression lambdaExpression) {
 		this.lamCounter++;
 
 		String typeErasure = createDescriptorWithTypeErasure(lambdaExpression);
-		//ToDo Etienne: Double Check
-		RefTypeOrTPHOrWildcardOrGeneric returnType = resolver.resolve(lambdaExpression.getReturnType());
-		List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes = lambdaExpression
-				.params
-				.getFormalparalist()
-				.stream()
-				.map(FormalParameter::getType)
-				.map(resolver::resolve)
-				.collect(Collectors.toList());
-		FunNUtilities funNUtilities = FunNGenerator.getInstance();
-		FunNUtilities.writeClassFile(funNUtilities.getSuperClassName(argumentTypes.size()),
-				funNUtilities.generateSuperBytecode(argumentTypes.size()), path);
-		FunNUtilities.writeClassFile(funNUtilities.getSpecializedClassName(argumentTypes, returnType),
-				funNUtilities.generateSpecializedBytecode(argumentTypes, returnType), path);
 
+		ByteCodeForFunNGenerator.generateBCForFunN(lambdaExpression, typeErasure,path);
+		
+		
 		Lambda lam = new Lambda(lambdaExpression);
 		String lamDesc = lam.accept(new DescriptorToString(resultSet));
 		// Call site, which, when invoked, returns an instance of the functional
@@ -667,6 +654,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 //		generateBCForFunN(lambdaExpression, typeErasure);
 	}
 
+	//ToDo Etienne: Relevant?!
 	private String addUsedVarsToDesugaredMethodDescriptor(String lamDesc) {
 		String newDesc = "(";
 		int pos = 0;
@@ -688,6 +676,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		}
 	}
 
+	//ToDo Etienne: Relevant?!
 	private String createDescriptorWithTypeErasure(LambdaExpression lambdaExpression) {
 		String typeErasure = "(";
 		Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
@@ -781,6 +770,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		// This will be used if the class is not standard class (not in API)
 		ClassLoader cLoader2;
 
+		//ToDo methodCallType wird nicht korrekt resolved, da kein Constraint vorhanden ist
 		String methCallType = resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 		String[] typesOfParams = getTypes(methodCall.arglist.getArguments());
 		try {
@@ -825,23 +815,13 @@ public class BytecodeGenMethod implements StatementVisitor {
 					} catch (NotInCurrentPackageException | NotFoundException e) {
 						e.printStackTrace();
 					}
+					//ToDo Etienne: Für Type Erasure wichtig?!
 				} else if(!helper.isInCurrPkg(clazz)){
 					if(clazz.contains(CONSTANTS.$$)) {
+						//ToDo Methoden Deskriptor neu setzen
+						//ToDo Receiver neu setzen?!
 						mDesc = helper.getDescriptorOfApplyMethod(methCallType);
-						//ToDo Etienne: Double Check
-						RefTypeOrTPHOrWildcardOrGeneric returnType = resolver.resolve(methodCall.getType());
-						List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes = methodCall
-								.arglist
-								.getArguments()
-								.stream()
-								.map(TypableStatement::getType)
-								.map(resolver::resolve)
-								.collect(Collectors.toList());
-						FunNUtilities funNUtilities = FunNGenerator.getInstance();
-						FunNUtilities.writeClassFile(funNUtilities.getSuperClassName(argumentTypes.size()),
-								funNUtilities.generateSuperBytecode(argumentTypes.size()), path);
-						FunNUtilities.writeClassFile(funNUtilities.getSpecializedClassName(argumentTypes, returnType),
-								funNUtilities.generateSpecializedBytecode(argumentTypes, returnType), path);
+						helper.generateBCForFunN(typesOfParams, methCallType);
 					}else {
 						try {
 							cLoader2 = new DirectoryClassLoader(path, classLoader);
@@ -898,6 +878,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 			if(parentBinary || isBinaryExp) {
 				doUnboxing(resolver.getResolvedType(methodCall.getType()));
 			}
+			//ToDo Etienne: Für Type Erasure wichtig?!
 		} else if(receiverName.contains(CONSTANTS.$$) && !methCallType.equals(Type.getInternalName(Object.class))) {
 			helper.createCheckCast(methodCall,mv);
 		}
@@ -925,6 +906,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 		}
 	}
 
+	//ToDo Etienne: Für Type Erasure wichtig?!
 	private void visitInvokeInsn(MethodCall methodCall, String receiverName, java.lang.reflect.Method methodRefl, String clazz, String mDesc, String receiverRefl) {
 		// is methodCall.receiver functional Interface)?
 		if (varsFunInterface.contains(methodCall.receiver.getType()) || (methodRefl!= null && receiverRefl.contains("interface")) ||

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

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

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

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

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

@@ -1,24 +1,17 @@
 package de.dhbwstuttgart.bytecode.descriptor;
 
-import de.dhbwstuttgart.bytecode.funN.FunNGenerator;
-import de.dhbwstuttgart.bytecode.funN.FunNUtilities;
-import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
 
 public class TypeToDescriptor implements TypeVisitor<String>{
 
-	private final boolean specializedFunN;
-
-	public TypeToDescriptor(){ this(true); }
-
-	public TypeToDescriptor(boolean specializedFunN) { this.specializedFunN = specializedFunN; }
-
 	@Override
 	public String visit(RefType refType) {
-		if (refType.getName().toString().matches("Fun\\d+\\$\\$") && specializedFunN) {
-			FunNUtilities funNUtilities = FunNGenerator.getInstance();
-			return funNUtilities.getSpecializedDescriptor(funNUtilities.getArguments(refType.getParaList()), funNUtilities.getReturnType(refType.getParaList()));
-		}
-
 		return refType.getName().toString().replace(".", "/");
 //		String t = refType.getName().toString().replace(".", "/");
 //		return t.equals("Fun1")?(t+"$$"):t;
@@ -45,8 +38,6 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 		//throw new NotImplementedException();
 	}
 
-	//ToDo Etienne: bin der Meinung hier müsste immer der Descriptor der extends-Schranke sein, z.b. <T> => Ljava/lang/Object; oder <T extends String> => Ljava/lang/String;
-	//Tests sind aber damit grün?! => Fehler in Tests schon vorher aufgefallen und gut möglich!
 	@Override
 	public String visit(GenericRefType genericRefType) {
 		return genericRefType.getParsedName().replace(".", "/");

src/main/java/de/dhbwstuttgart/bytecode/funN/FunNGenerator.java

@@ -1,181 +0,0 @@
-package de.dhbwstuttgart.bytecode.funN;
-
-import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
-import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
-import de.dhbwstuttgart.bytecode.utilities.CONSTANTS;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.MethodVisitor;
-import org.objectweb.asm.Type;
-
-import javax.annotation.Nonnull;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.util.List;
-import java.util.Objects;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import static org.objectweb.asm.Opcodes.*;
-
-/**
- * Represents a Singleton-Service implementation for the {@link FunNUtilities} interface.
- *
- * @since Studienarbeit Type Erasure
- * @author etiennezink
- */
-public final class FunNGenerator implements FunNUtilities{
-
-    private static final FunNGenerator funNGenerator = new FunNGenerator();
-
-    /**
-     * @return the Singleton instance for {@link FunNGenerator}
-     */
-    public static FunNUtilities getInstance(){ return funNGenerator; }
-
-    private final String argumentGenericBase = "T";
-    private final String returnGeneric = "R";
-    private final String methodName = "apply";
-    private final int bytecodeVersion = V1_8;
-
-    private final String objectSuperType = Type.getInternalName(Object.class).replace('.','/');
-    private final RefType objectRefType = new RefType(new JavaClassName(objectSuperType), null);
-    private final String objectSignature = applySignature(objectRefType);
-
-    private FunNGenerator(){}
-
-    @Override
-    public byte[] generateSuperBytecode(int numberArguments) {
-        StringBuilder superFunNClassSignature = new StringBuilder("<");
-        StringBuilder superFunNMethodSignature = new StringBuilder("(");
-        StringBuilder superFunNMethodDescriptor = new StringBuilder("(");
-
-        for (int currentParameter = 1; currentParameter <= numberArguments; currentParameter++){
-            superFunNClassSignature.append(String.format("%s%d:%s",argumentGenericBase, currentParameter, objectSignature));
-            superFunNMethodSignature.append(applySignature( new GenericRefType(argumentGenericBase + currentParameter, null)));
-            superFunNMethodDescriptor.append(objectSignature);
-        }
-        superFunNClassSignature.append(String.format("%s:%s>%s", returnGeneric, objectSignature, objectSignature));
-        superFunNMethodSignature.append(String.format(")%s", applySignature(new GenericRefType(returnGeneric, null))));
-        superFunNMethodDescriptor.append(String.format(")%s", objectSignature));
-
-        ClassWriter classWriter = new ClassWriter(0);
-        MethodVisitor methodVisitor;
-        classWriter.visit(bytecodeVersion, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, getSuperClassName(numberArguments), superFunNClassSignature.toString(), objectSuperType, null);
-        methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, methodName, superFunNMethodDescriptor.toString(), superFunNMethodSignature.toString(), null);
-        methodVisitor.visitEnd();
-        classWriter.visitEnd();
-        return classWriter.toByteArray();
-    }
-
-    @Override
-    public String getSuperClassName(int numberArguments) {
-        return String.format("Fun%d$$", numberArguments);
-    }
-
-    @Override
-    public byte[] generateSpecializedBytecode(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) {
-        Objects.requireNonNull(argumentTypes);
-        Objects.requireNonNull(returnType);
-        //generates a list of all params and substitutes the TPH
-        List<RefTypeOrTPHOrWildcardOrGeneric> parameters = Stream
-                .concat(argumentTypes.stream(), Stream.of(returnType))
-                .map(this::substituteTPH)
-                .collect(Collectors.toList());
-        RefType superFunN = new RefType(new JavaClassName(getSuperClassName(argumentTypes.size())), parameters , null);
-        StringBuilder funNClassSignature = new StringBuilder(objectSignature + (superFunN.acceptTV(new TypeToSignature(false))));
-        boolean containsGeneric = false;
-
-        String genericSignature = "<";
-        for (RefTypeOrTPHOrWildcardOrGeneric typeArgument : parameters) {
-            if (typeArgument instanceof GenericRefType){
-                GenericRefType generic = (GenericRefType) typeArgument;
-                String signatureOfArgument = generic.getParsedName();
-                if(genericSignature.contains(signatureOfArgument)) continue;
-                genericSignature += String.format("%s:%s", signatureOfArgument, objectSignature);
-                containsGeneric = true;
-            }
-        }
-        genericSignature += ">";
-        if (containsGeneric) funNClassSignature.insert(0, genericSignature);
-
-        ClassWriter classWriter = new ClassWriter(0);
-        classWriter.visit(bytecodeVersion, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, getSpecializedClassName(argumentTypes, returnType), funNClassSignature.toString(), objectSuperType, new String[]{getSuperClassName(argumentTypes.size())});
-        classWriter.visitEnd();
-        return classWriter.toByteArray();
-    }
-
-    @Override
-    public String getSpecializedClassName(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) {
-        Objects.requireNonNull(argumentTypes);
-        Objects.requireNonNull(returnType);
-        return String.format("Fun%d$$%s%s",
-                        argumentTypes.size(),
-                        argumentTypes
-                                .stream()
-                                .map(this::applyNameDescriptor)
-                                .collect(Collectors.joining()),
-                        applyNameDescriptor(returnType))
-                .replace('/', '$')
-                .replace(";", "$_$");
-    }
-
-    @Override
-    public String getSpecializedDescriptor(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) {
-        Objects.requireNonNull(argumentTypes);
-        Objects.requireNonNull(returnType);
-        return applyDescriptor(getSpecializedFunNRefType(argumentTypes, returnType));
-    }
-
-    @Override
-    public String getSpecializedSignature(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType) {
-        Objects.requireNonNull(argumentTypes);
-        Objects.requireNonNull(returnType);
-        return applySignature(getSpecializedFunNRefType(argumentTypes, returnType));
-    }
-
-    @Override
-    public List<RefTypeOrTPHOrWildcardOrGeneric> getArguments(List<RefTypeOrTPHOrWildcardOrGeneric> list) {
-        Objects.requireNonNull(list);
-        return list
-                .stream()
-                .limit(Math.max(0, list.size() - 1))
-                .collect(Collectors.toList());
-    }
-
-    @Override
-    public RefTypeOrTPHOrWildcardOrGeneric getReturnType(List<RefTypeOrTPHOrWildcardOrGeneric> list) {
-        Objects.requireNonNull(list);
-        if(list.size() == 0) return null;
-        return list.get(list.size() - 1);
-    }
-
-    private String applyDescriptor(RefTypeOrTPHOrWildcardOrGeneric a) { return a.acceptTV(new TypeToDescriptor(true)); }
-    private String applySignature(RefTypeOrTPHOrWildcardOrGeneric a) { return a.acceptTV(new TypeToSignature(true)); }
-
-    /**
-     * @param a
-     * @return the name for the type {@code a} which should be used in the specialized name for FunN.
-     */
-    private String applyNameDescriptor(RefTypeOrTPHOrWildcardOrGeneric a){ return a instanceof TypePlaceholder ? "LTPH;" : String.format("L%s;", applyDescriptor(a)); }
-
-    private RefTypeOrTPHOrWildcardOrGeneric substituteTPH(RefTypeOrTPHOrWildcardOrGeneric t) {
-        if (t instanceof TypePlaceholder) {
-            TypePlaceholder tph = (TypePlaceholder) t;
-            return new GenericRefType(tph.getName()+"$", t.getOffset());
-        }
-        return t;
-    }
-    private RefType getSpecializedFunNRefType(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType){
-        return new RefType(new JavaClassName(getSpecializedClassName(argumentTypes, returnType)),
-                Stream
-                        .concat(argumentTypes.stream(), Stream.of(returnType))
-                        .filter(t -> t instanceof GenericRefType ||
-                                t instanceof TypePlaceholder)
-                        .collect(Collectors.toList()),null);
-    }
-}

src/main/java/de/dhbwstuttgart/bytecode/funN/FunNUtilities.java

@@ -1,90 +0,0 @@
-package de.dhbwstuttgart.bytecode.funN;
-
-import de.dhbwstuttgart.bytecode.utilities.CONSTANTS;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-
-import javax.annotation.Nonnull;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.util.List;
-
-/**
- * Interface which represents the functionality for specifying and generating the specified functional types (FunN).
- *
- * @since Studienarbeit Type Erasure
- * @author etiennezink
- */
-public interface FunNUtilities {
-
-    /**
-     * @param numberArguments (excluding the return type!)
-     * @return the bytecode for the super FunN-interface
-     */
-    byte[] generateSuperBytecode(int numberArguments);
-
-    /**
-     * @param numberArguments (excluding the return type!)
-     * @return the name for the super FunN-interface
-     */
-    String getSuperClassName(int numberArguments);
-
-    /**
-     * @param argumentTypes (excluding the return type!)
-     * @param returnType
-     * @return the bytecode for the specialized FunN-interface
-     */
-    byte[] generateSpecializedBytecode(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType);
-
-    /**
-     * @param argumentTypes (excluding the return type!)
-     * @param returnType
-     * @return the name for the specialized FunN-interface
-     */
-    String getSpecializedClassName(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType);
-
-    /**
-     * @param argumentTypes (excluding the return type!)
-     * @param returnType
-     * @return the descriptor for a specialized FunN-interface.
-     */
-    String getSpecializedDescriptor(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType);
-
-    /**
-     * @param argumentTypes (excluding the return type!)
-     * @param returnType
-     * @return the signature for a specialized FunN-interface.
-     */
-    String getSpecializedSignature(List<RefTypeOrTPHOrWildcardOrGeneric> argumentTypes, RefTypeOrTPHOrWildcardOrGeneric returnType);
-
-    /**
-     * @param list containing type arguments and the return type.
-     * @return a {@link List} containing only the arguments of the specialized FunN-interface.
-     */
-    List<RefTypeOrTPHOrWildcardOrGeneric> getArguments(List<RefTypeOrTPHOrWildcardOrGeneric> list);
-
-    /**
-     * @param list containing type arguments and the return type.
-     * @return the return type of the {@code list} (last member)
-     */
-    RefTypeOrTPHOrWildcardOrGeneric getReturnType(List<RefTypeOrTPHOrWildcardOrGeneric> list);
-
-    /**
-     * Should be refactored into a central API.
-     *
-     * @param className
-     * @param bytecode
-     * @param directory
-     * @return {@code true} iff the file could be generated and {@code false} if not
-     */
-    @Deprecated
-    static boolean writeClassFile(String className, byte[] bytecode, File directory) {
-        try (FileOutputStream output = new FileOutputStream(new File(directory , className + CONSTANTS.EXTENSIONCLASS))){
-            output.write(bytecode);
-            output.flush();
-            return true;
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return false;
-    }
-}

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

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

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

@@ -5,8 +5,6 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Optional;
 
-import de.dhbwstuttgart.bytecode.funN.FunNGenerator;
-import de.dhbwstuttgart.bytecode.funN.FunNUtilities;
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericsGeneratorResult;
 import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
@@ -19,29 +17,18 @@ import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
 public class TypeToSignature implements TypeVisitor<String> {
 	private List<GenericsGeneratorResult> constraints;
 
-	private final boolean specializedFunN;
-
-	public TypeToSignature() { this(new ArrayList<>(), true); }
-
-	public TypeToSignature(boolean specializedFunN) { this(new ArrayList<>(), specializedFunN); }
-
-	public TypeToSignature(List<GenericsGeneratorResult> constraints) {
-		this(constraints, true);
+	public TypeToSignature() {
+		this.constraints = new ArrayList<>();
 	}
 
-	public TypeToSignature(List<GenericsGeneratorResult> constraints, boolean specializedFunN){
+	public TypeToSignature(List<GenericsGeneratorResult> constraints) {
 		this.constraints = constraints;
-		this.specializedFunN = specializedFunN;
 	}
 
 	@Override
 	public String visit(RefType refType) {
 		if(refType.getName().toString().equals("void"))
 			return "V";
-		if (refType.getName().toString().matches("Fun\\d+\\$\\$") && specializedFunN){
-			FunNUtilities funNUtilities = FunNGenerator.getInstance();
-			return funNUtilities.getSpecializedSignature(funNUtilities.getArguments(refType.getParaList()), funNUtilities.getReturnType(refType.getParaList()));
-		}
 //		return refType.toString().replace(".", "/");
 		String params = "";
         if(refType.getParaList().size()>0){
@@ -102,20 +89,9 @@ public class TypeToSignature implements TypeVisitor<String> {
 		return sig;
 	}
 
-	/**
-	 * Changed that the correct signature is returned:
-	 * returns now T...; expect of only ...
-	 * where ... is {@code genericRefType.getParsedName()}
-	 *
-	 * @since Studienarbeit Type Erasure
-	 * @author etiennezink
-	 *
-	 * @param genericRefType
-	 * @return
-	 */
 	@Override
 	public String visit(GenericRefType genericRefType) {
-		return String.format("T%s;", genericRefType.getParsedName()).replace(".", "/");
+		return genericRefType.getParsedName().replace(".", "/");
 	}
 
 	private Optional<GenericsGeneratorResult> getEqualTPHFromClassConstraints(List<GenericsGeneratorResult> listOfConstraints, String tph) {
@@ -123,4 +99,34 @@ public class TypeToSignature implements TypeVisitor<String> {
 				.filter(c -> c.getConstraint().getLeft().equals(tph) || c.getEqualsTPHs().contains(tph))
 				.findFirst();
 	}
+
+	/**
+	 * //ToDo beschreiben
+	 *
+	 * @param type
+	 * @return
+	 *
+	 * @since Studienarbeit Type Erasure
+	 * @author Etienne Zink
+	 */
+	public String visit(RefTypeOrTPHOrWildcardOrGeneric type){
+		String returnString = "";
+		if (type instanceof GenericRefType){
+			GenericRefType genericRefType = (GenericRefType) type;
+			returnString += visit(genericRefType);
+		} else if (type instanceof RefType){
+			RefType refType = (RefType) type;
+			returnString += visit(refType);
+		} else if (type instanceof TypePlaceholder){
+			TypePlaceholder typePlaceholder = (TypePlaceholder) type;
+			returnString += visit(typePlaceholder);
+		} else if (type instanceof SuperWildcardType){
+			SuperWildcardType superWildcardType = (SuperWildcardType) type;
+			returnString += visit(superWildcardType);
+		} else if (type instanceof ExtendsWildcardType) {
+			ExtendsWildcardType extendsWildcardType = (ExtendsWildcardType) type;
+			returnString += visit(extendsWildcardType);
+		}
+		return returnString;
+	}
 }

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

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

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

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

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

@@ -25,8 +25,4 @@ public class Resolver {
 	public String getResolvedType(RefTypeOrTPHOrWildcardOrGeneric type) {
 		return resultSet.resolveType(type).resolvedType.acceptTV(new TypeToDescriptor());
 	}
-
-	public RefTypeOrTPHOrWildcardOrGeneric resolve(RefTypeOrTPHOrWildcardOrGeneric type) {
-		return resultSet.resolveType(type).resolvedType;
-	}
 }

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

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

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

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

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

@@ -4,8 +4,6 @@ import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
 import org.antlr.v4.runtime.Token;
 
-import java.util.Objects;
-
 public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
 {
     private String name;
@@ -35,20 +33,12 @@ public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
         visitor.visit(this);
     }
 
-    /**
-     * @since Studienarbeit Type Erasure
-     * @author etiennezink
-     *
-     * @param o
-     * @return
-     */
 	@Override
 	public boolean equals(Object o) {
-		if((! (o instanceof GenericRefType))) return false;
-        GenericRefType genericRefType = (GenericRefType) o;
-        return getParsedName().equals(genericRefType.getParsedName()) &&
-               Objects.equals(getOffset(), genericRefType.getOffset());
- 	}
+		// TODO Auto-generated method stub
+		return false;
+	}
+	
 	    
 	 @Override
 	public String toString()

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

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

src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java

@@ -1,78 +0,0 @@
-package de.dhbwstuttgart.target.generate;
-
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
-import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.Field;
-import de.dhbwstuttgart.syntaxtree.Method;
-import de.dhbwstuttgart.syntaxtree.statement.Block;
-import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.target.tree.*;
-import de.dhbwstuttgart.target.tree.expression.TargetBlock;
-import de.dhbwstuttgart.target.tree.type.*;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-public class ASTToTargetAST {
-
-    public TargetClass convert(ClassOrInterface input, Map<TypePlaceholder, TargetType> sigma){
-        List<TargetConstructor> targetConstructors = new ArrayList<>();
-        //TODO constructor conversion -> also reduce syntactic sugar
-        return new TargetClass(input.getModifiers(),input.getClassName().toString(), null,
-                sigma.get(input.getSuperClass()),
-                input.getSuperInterfaces().stream().map(it -> sigma.get(it)).collect(Collectors.toList()),
-                targetConstructors,
-                input.getFieldDecl().stream().map(it -> convert(it, sigma)).collect(Collectors.toList()),
-                input.getMethods().stream().map(it -> convert(it, sigma)).collect(Collectors.toList()));
-    }
-
-    private TargetMethod convert(Method input, Map<TypePlaceholder, TargetType> sigma) {
-        List<MethodParameter> params = input.getParameterList().getFormalparalist().stream()
-                .map(param -> new MethodParameter(convert(param.getType(), sigma), param.getName())).collect(Collectors.toList());
-        return new TargetMethod(input.name, params, convert(input.block));
-    }
-
-    private TargetBlock convert(Block block) {
-        return new TargetBlock(block.statements.stream().map(e -> {
-            StatementToTargetExpression converter = new StatementToTargetExpression();
-            e.accept(converter);
-            return converter.result;
-        }).collect(Collectors.toList()));
-    }
-
-    private TargetField convert(Field input, Map<TypePlaceholder, TargetType> sigma) {
-        return new TargetField(convert(input.getType(), sigma), input.getName());
-    }
-
-    private TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, Map<TypePlaceholder, TargetType> sigma) {
-        return input.acceptTV(new TypeVisitor<>() {
-            @Override
-            public TargetType visit(RefType refType) {
-                return new TargetRefType(refType.getName().toString(),
-                        refType.getParaList().stream().map((it) -> convert(it, sigma)).collect(Collectors.toList()));
-            }
-
-            @Override
-            public TargetType visit(SuperWildcardType superWildcardType) {
-                return new TargetSuperWildcard(convert(superWildcardType.getInnerType(), sigma));
-            }
-
-            @Override
-            public TargetType visit(TypePlaceholder typePlaceholder) {
-                return sigma.get(typePlaceholder);
-            }
-
-            @Override
-            public TargetType visit(ExtendsWildcardType extendsWildcardType) {
-                return new TargetExtendsWildcard(convert(extendsWildcardType.getInnerType(), sigma));
-            }
-
-            @Override
-            public TargetType visit(GenericRefType genericRefType) {
-                return new TargetGenericType(genericRefType.getParsedName());
-            }
-        });
-    }
-}

src/main/java/de/dhbwstuttgart/target/generate/StatementToTargetExpression.java

@@ -1,156 +0,0 @@
-package de.dhbwstuttgart.target.generate;
-
-import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
-import de.dhbwstuttgart.syntaxtree.StatementVisitor;
-import de.dhbwstuttgart.syntaxtree.statement.*;
-import de.dhbwstuttgart.target.tree.expression.TargetExpression;
-
-public class StatementToTargetExpression implements StatementVisitor {
-    public TargetExpression result;
-
-    @Override
-    public void visit(ArgumentList argumentList) {
-        
-    }
-
-    @Override
-    public void visit(LambdaExpression lambdaExpression) {
-
-    }
-
-    @Override
-    public void visit(Assign assign) {
-
-    }
-
-    @Override
-    public void visit(BinaryExpr binary) {
-
-    }
-
-    @Override
-    public void visit(Block block) {
-
-    }
-
-    @Override
-    public void visit(CastExpr castExpr) {
-
-    }
-
-    @Override
-    public void visit(EmptyStmt emptyStmt) {
-
-    }
-
-    @Override
-    public void visit(FieldVar fieldVar) {
-
-    }
-
-    @Override
-    public void visit(ForStmt forStmt) {
-
-    }
-
-    @Override
-    public void visit(IfStmt ifStmt) {
-
-    }
-
-    @Override
-    public void visit(InstanceOf instanceOf) {
-
-    }
-
-    @Override
-    public void visit(LocalVar localVar) {
-
-    }
-
-    @Override
-    public void visit(LocalVarDecl localVarDecl) {
-
-    }
-
-    @Override
-    public void visit(MethodCall methodCall) {
-
-    }
-
-    @Override
-    public void visit(NewClass methodCall) {
-
-    }
-
-    @Override
-    public void visit(NewArray newArray) {
-
-    }
-
-    @Override
-    public void visit(Return aReturn) {
-
-    }
-
-    @Override
-    public void visit(ReturnVoid aReturn) {
-
-    }
-
-    @Override
-    public void visit(StaticClassName staticClassName) {
-
-    }
-
-    @Override
-    public void visit(Super aSuper) {
-
-    }
-
-    @Override
-    public void visit(This aThis) {
-
-    }
-
-    @Override
-    public void visit(WhileStmt whileStmt) {
-
-    }
-
-    @Override
-    public void visit(DoStmt whileStmt) {
-
-    }
-
-    @Override
-    public void visit(AssignToField assignLeftSide) {
-
-    }
-
-    @Override
-    public void visit(AssignToLocal assignLeftSide) {
-
-    }
-
-    @Override
-    public void visit(SuperCall superCall) {
-
-    }
-
-    @Override
-    public void visit(ExpressionReceiver expressionReceiver) {
-
-    }
-
-    @Override
-    public void visit(UnaryExpr unaryExpr) {
-
-    }
-
-    @Override
-    public void visit(Literal literal) {
-
-    }
-}

src/main/java/de/dhbwstuttgart/target/tree/GenericDeclaration.java

@@ -1,7 +0,0 @@
-package de.dhbwstuttgart.target.tree;
-
-import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.target.tree.type.TargetType;
-
-public record GenericDeclaration(GenericRefType generic, TargetType bound) {
-}

src/main/java/de/dhbwstuttgart/target/tree/MethodParameter.java

@@ -1,6 +0,0 @@
-package de.dhbwstuttgart.target.tree;
-
-import de.dhbwstuttgart.target.tree.type.TargetType;
-
-public record MethodParameter(TargetType type, String name) {
-}

src/main/java/de/dhbwstuttgart/target/tree/TargetClass.java

@@ -1,11 +0,0 @@
-package de.dhbwstuttgart.target.tree;
-
-import de.dhbwstuttgart.target.tree.type.TargetRefType;
-import de.dhbwstuttgart.target.tree.type.TargetType;
-
-import java.util.List;
-
-public record TargetClass(int modifiers, String qualifiedName, List<GenericDeclaration> generics, TargetType superType,
-                          List<TargetType> implementingInterfaces,
-                          List<TargetConstructor> constructors, List<TargetField> fields, List<TargetMethod> methods) {}
-

src/main/java/de/dhbwstuttgart/target/tree/TargetConstructor.java

@@ -1,9 +0,0 @@
-package de.dhbwstuttgart.target.tree;
-
-import de.dhbwstuttgart.target.tree.expression.TargetBlock;
-
-import java.util.List;
-
-public record TargetConstructor(List<MethodParameter> parameterTypes, TargetBlock block) {
-}
-

src/main/java/de/dhbwstuttgart/target/tree/TargetField.java

@@ -1,7 +0,0 @@
-package de.dhbwstuttgart.target.tree;
-
-import de.dhbwstuttgart.target.tree.type.TargetType;
-
-public record TargetField(TargetType type, String name) {
-}
-

src/main/java/de/dhbwstuttgart/target/tree/TargetMethod.java

@@ -1,9 +0,0 @@
-package de.dhbwstuttgart.target.tree;
-
-import de.dhbwstuttgart.target.tree.expression.TargetBlock;
-
-import java.util.List;
-
-public record TargetMethod(String name, List<MethodParameter> parameterTypes, TargetBlock block) {
-}
-

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetAssign.java

@@ -1,4 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-public record TargetAssign(TargetExpression leftSide, TargetExpression rightSide) implements TargetExpression {
-}

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetBlock.java

@@ -1,6 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-import java.util.List;
-
-public record TargetBlock(List<TargetExpression> statememts) implements TargetExpression {
-}

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetExpression.java

@@ -1,7 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-import de.dhbwstuttgart.target.tree.type.*;
-
-public sealed interface TargetExpression
-        permits TargetBlock, TargetLambdaExpression, TargetReturn, TargetThis, TargetSuper, TargetNew, TargetAssign {
-}

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetLambdaExpression.java

@@ -1,8 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-import de.dhbwstuttgart.target.tree.MethodParameter;
-
-import java.util.List;
-
-public record TargetLambdaExpression(List<MethodParameter> params, TargetExpression block) implements TargetExpression {
-}

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetNew.java

@@ -1,8 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-import de.dhbwstuttgart.target.tree.type.TargetType;
-
-import java.util.List;
-
-public record TargetNew(TargetType instantiatedType, List<TargetExpression> params) implements TargetExpression {
-}

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetReturn.java

@@ -1,4 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-public record TargetReturn(TargetExpression expression) implements TargetExpression {
-}

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetSuper.java

@@ -1,4 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-public record TargetSuper() implements TargetExpression {
-}

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetThis.java

@@ -1,4 +0,0 @@
-package de.dhbwstuttgart.target.tree.expression;
-
-public record TargetThis() implements TargetExpression {
-}

src/main/java/de/dhbwstuttgart/target/tree/type/TargetExtendsWildcard.java

@@ -1,5 +0,0 @@
-package de.dhbwstuttgart.target.tree.type;
-
-public record TargetExtendsWildcard(TargetType innerType) implements TargetType{
-}
-

src/main/java/de/dhbwstuttgart/target/tree/type/TargetFunNType.java

@@ -1,6 +0,0 @@
-package de.dhbwstuttgart.target.tree.type;
-
-import java.util.List;
-
-public record TargetFunNType(int N, List<TargetRefType> params) implements TargetType {
-}

src/main/java/de/dhbwstuttgart/target/tree/type/TargetGenericType.java

@@ -1,4 +0,0 @@
-package de.dhbwstuttgart.target.tree.type;
-
-public record TargetGenericType(String name) implements TargetType {
-}

src/main/java/de/dhbwstuttgart/target/tree/type/TargetRefType.java

@@ -1,8 +0,0 @@
-package de.dhbwstuttgart.target.tree.type;
-
-import de.dhbwstuttgart.target.tree.type.TargetType;
-
-import java.util.List;
-
-public record TargetRefType(String name, List<TargetType> params) implements TargetType {
-}

src/main/java/de/dhbwstuttgart/target/tree/type/TargetSuperWildcard.java

@@ -1,4 +0,0 @@
-package de.dhbwstuttgart.target.tree.type;
-
-public record TargetSuperWildcard(TargetType innerType) implements TargetType {
-}

src/main/java/de/dhbwstuttgart/target/tree/type/TargetType.java

@@ -1,5 +0,0 @@
-package de.dhbwstuttgart.target.tree.type;
-
-public sealed interface TargetType
-        permits TargetExtendsWildcard, TargetFunNType, TargetGenericType, TargetRefType, TargetSuperWildcard {
-}

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

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

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

@@ -68,6 +68,7 @@ public class TYPEStmt implements StatementVisitor{
         lambdaParams.add(tphRetType);
         //lambdaParams.add(0,tphRetType);
         constraintsSet.addUndConstraint(
+                //ToDo Etienne: Für Type Erasure wichtig?!
                 new Pair(lambdaExpression.getType(),
                 		new RefType(new JavaClassName("Fun"+(lambdaParams.size()-1)+"$$"), lambdaParams, new NullToken()),
                         //new FunN(lambdaParams),

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

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

src/test/java/bytecode/OLFun2Test.java

@@ -1,75 +0,0 @@
-package bytecode;
-
-import java.io.File;
-import java.lang.reflect.Method;
-import java.net.URL;
-import java.net.URLClassLoader;
-
-import general.TestCleanUp;
-import org.junit.*;
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import static org.junit.Assert.*;
-
-/**
- *  Test for the file {@code OLFun2.jav}.
- *  Tests if the expected overloading for the method {@code m} exists.
- *
- * @since Studienarbeit Type Erasure
- * @author etiennezink
- */
-public class OLFun2Test {
-    private static String path;
-    private static File fileToTest;
-    private static JavaTXCompiler compiler;
-    private static ClassLoader loader;
-    private static Class<?> classToTest;
-    private static Class<?> classFun1IntInt;
-    private static Class<?> classFun1IntDouble;
-    private static Class<?> classFun1DoubleDouble;
-    private static Class<?> classFun1DoubleInt;
-
-    private static String generatedByteCodeDirectory = System.getProperty("user.dir") + "/src/test/resources/testBytecode/generatedBC/";
-
-    @BeforeClass
-    public static void setUp() throws Exception {
-        path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/OLFun2.jav";
-        fileToTest = new File(path);
-        compiler = new JavaTXCompiler(fileToTest);
-        compiler.generateBytecode(generatedByteCodeDirectory);
-        loader = new URLClassLoader(new URL[] {new URL("file://"+generatedByteCodeDirectory)});
-        classToTest = loader.loadClass("OLFun2");
-        classFun1IntInt = loader.loadClass("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$");
-        classFun1IntDouble = loader.loadClass("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Double$_$");
-        classFun1DoubleDouble = loader.loadClass("Fun1$$Ljava$lang$Double$_$Ljava$lang$Double$_$");
-        classFun1DoubleInt = loader.loadClass("Fun1$$Ljava$lang$Double$_$Ljava$lang$Integer$_$");
-    }
-
-    @Test
-    public void mExistsWithIntegerInteger() throws Exception{
-        Method m = classToTest.getDeclaredMethod("m", classFun1IntInt);
-        assertNotNull(m);
-    }
-
-    @Test
-    public void mExistsWithIntegerDouble() throws Exception{
-        Method m = classToTest.getDeclaredMethod("m", classFun1IntDouble);
-        assertNotNull(m);
-    }
-
-    @Test
-    public void mExistsWithDoubleInteger() throws Exception{
-        Method m = classToTest.getDeclaredMethod("m", classFun1DoubleInt);
-        assertNotNull(m);
-    }
-
-    @Test
-    public void mExistsWithDoubleDouble() throws Exception{
-        Method m = classToTest.getDeclaredMethod("m", classFun1DoubleDouble);
-        assertNotNull(m);
-    }
-
-    @AfterClass
-    public static void cleanUp() {
-        TestCleanUp.cleanUpDirectory(new File(generatedByteCodeDirectory), f -> f.getName().contains(".class"));
-    }
-}

src/test/java/bytecode/OLFunTest.java

@@ -11,11 +11,11 @@ import de.dhbwstuttgart.core.JavaTXCompiler;
 import static org.junit.Assert.*;
 
 /**
- *  Test for the file {@code OLFun.jav}.
- *  Tests if the expected overloading for the method {@code m} exists.
+ * Test which only checks if the class {@code OLFun} was correctly compiled.
+ * This is achived by verifying the existence of the three implementations of {@code m}.
  *
  * @since Studienarbeit Type Erasure
- * @author etiennezink
+ * @author Etienne Zink
  */
 public class OLFunTest {
 	private static String path;
@@ -23,15 +23,11 @@ public class OLFunTest {
 	private static JavaTXCompiler compiler;
 	private static ClassLoader loader;
 	private static Class<?> classToTest;
-	private static Class<?> classFun1IntInt;
-	private static Class<?> classFun1IntDouble;
-	private static Class<?> classFun1DoubleDouble;
-	private static Class<?> classFun1DoubleInt;
-	private static Class<?> classFun1StringInt;
-	private static Class<?> classFun1StringDouble;
+	private static Class<?> classFun1;
+	private static Object instanceOfClass;
 
 	private static String generatedByteCodeDirectory = System.getProperty("user.dir") + "/src/test/resources/testBytecode/generatedBC/";
-
+	
 	@BeforeClass
 	public static void setUp() throws Exception {
 		path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/OLFun.jav";
@@ -40,47 +36,25 @@ public class OLFunTest {
 		compiler.generateBytecode(generatedByteCodeDirectory);
 		loader = new URLClassLoader(new URL[] {new URL("file://"+generatedByteCodeDirectory)});
 		classToTest = loader.loadClass("OLFun");
-		classFun1IntInt = loader.loadClass("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$");
-		classFun1IntDouble = loader.loadClass("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Double$_$");
-		classFun1DoubleDouble = loader.loadClass("Fun1$$Ljava$lang$Double$_$Ljava$lang$Double$_$");
-		classFun1DoubleInt = loader.loadClass("Fun1$$Ljava$lang$Double$_$Ljava$lang$Integer$_$");
-		classFun1StringInt = loader.loadClass("Fun1$$Ljava$lang$String$_$Ljava$lang$Integer$_$");
-		classFun1StringDouble = loader.loadClass("Fun1$$Ljava$lang$String$_$Ljava$lang$Double$_$");
+		classFun1 = loader.loadClass("Fun1$$");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}
 
 	@Test
-	public void mExistsWithIntegerInteger() throws Exception{
-		Method m = classToTest.getDeclaredMethod("m", classFun1IntInt, Integer.class);
+	public void mExistsWithInteger() throws Exception{
+		Method m = classToTest.getDeclaredMethod("m", classFun1 ,Integer.class);
 		assertNotNull(m);
 	}
 
 	@Test
-	public void mExistsWithIntegerDouble() throws Exception{
-		Method m = classToTest.getDeclaredMethod("m", classFun1IntDouble, Integer.class);
+	public void mExistsWithString() throws Exception{
+		Method m = classToTest.getDeclaredMethod("m", classFun1 ,String.class);
 		assertNotNull(m);
 	}
 
 	@Test
-	public void mExistsWithDoubleInteger() throws Exception{
-		Method m = classToTest.getDeclaredMethod("m", classFun1DoubleInt, Double.class);
-		assertNotNull(m);
-	}
-
-	@Test
-	public void mExistsWithDoubleDouble() throws Exception{
-		Method m = classToTest.getDeclaredMethod("m", classFun1DoubleDouble, Double.class);
-		assertNotNull(m);
-	}
-
-	@Test
-	public void mExistsWithStringInteger() throws Exception{
-		Method m = classToTest.getDeclaredMethod("m", classFun1StringInt, String.class);
-		assertNotNull(m);
-	}
-
-	@Test
-	public void mExistsWithStringDouble() throws Exception{
-		Method m = classToTest.getDeclaredMethod("m", classFun1StringDouble, String.class);
+	public void mExistsWithDouble() throws Exception{
+		Method m = classToTest.getDeclaredMethod("m", classFun1 ,Double.class);
 		assertNotNull(m);
 	}
 

src/test/java/bytecode/funN/FunNGeneratorTest.java

@@ -1,248 +0,0 @@
-package bytecode.funN;
-
-import de.dhbwstuttgart.bytecode.funN.FunNGenerator;
-import de.dhbwstuttgart.bytecode.funN.FunNUtilities;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.Type;
-
-import java.util.Arrays;
-
-import static org.junit.Assert.*;
-import static org.objectweb.asm.Opcodes.*;
-
-public class FunNGeneratorTest {
-
-    static FunNUtilities funNGenerator;
-    static RefType voidType;
-    static RefType integerType;
-    static GenericRefType genericT;
-    static TypePlaceholder tph;
-
-    @BeforeClass
-    public static void setUp(){
-
-        funNGenerator = FunNGenerator.getInstance();
-        voidType = new RefType(new JavaClassName(Type.getInternalName(Void.class)), null);
-        integerType = new RefType(new JavaClassName(Type.getInternalName(Integer.class)), null);
-        genericT = new GenericRefType("T", null);
-        tph = TypePlaceholder.fresh(null);
-    }
-
-    @Test
-    public void superClassName_0(){
-        var superClassName = funNGenerator.getSuperClassName(0);
-        assertEquals("Fun0$$", superClassName);
-    }
-
-    @Test
-    public void superClassName_1(){
-        var superClassName = funNGenerator.getSuperClassName(1);
-        assertEquals("Fun1$$", superClassName);
-    }
-
-    @Test
-    public void specializedClassName_VoidVoid(){
-        var specializedClassName = funNGenerator.getSpecializedClassName(Arrays.asList(), voidType);
-        assertEquals("Fun0$$Ljava$lang$Void$_$", specializedClassName);
-    }
-
-    @Test
-    public void specializedClassName_VoidInt(){
-        var specializedClassName = funNGenerator.getSpecializedClassName(Arrays.asList(), integerType);
-        assertEquals("Fun0$$Ljava$lang$Integer$_$", specializedClassName);
-    }
-
-    @Test
-    public void specializedClassName_IntInt(){
-        var specializedClassName = funNGenerator.getSpecializedClassName(Arrays.asList(integerType), integerType);
-        assertEquals("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$", specializedClassName);
-    }
-
-    @Test
-    public void specializedClassName_IntT(){
-        var specializedClassName = funNGenerator.getSpecializedClassName(Arrays.asList(integerType), genericT);
-        assertEquals("Fun1$$Ljava$lang$Integer$_$LT$_$", specializedClassName);
-    }
-
-    @Test
-    public void specializedClassName_IntTPH(){
-        var specializedClassName = funNGenerator.getSpecializedClassName(Arrays.asList(integerType), TypePlaceholder.fresh(null));
-        assertEquals("Fun1$$Ljava$lang$Integer$_$LTPH$_$", specializedClassName);
-    }
-
-    @Test
-    public void signature_IntInt(){
-        var classSignature = funNGenerator.getSpecializedSignature(Arrays.asList(integerType), integerType);
-        assertEquals("LFun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$;", classSignature);
-    }
-
-    @Test
-    public void signature_IntT(){
-        var classSignature = funNGenerator.getSpecializedSignature(Arrays.asList(integerType), genericT);
-        assertEquals("LFun1$$Ljava$lang$Integer$_$LT$_$<TT;>;", classSignature);
-    }
-
-    @Test
-    public void signature_TPHTPH(){
-        var classSignature = funNGenerator.getSpecializedSignature(Arrays.asList(tph), tph);
-        assertEquals(String.format("LFun1$$LTPH$_$LTPH$_$<T%s$;T%s$;>;",tph.getName(), tph.getName()), classSignature);
-    }
-
-    @Test
-    public void descriptor_IntInt(){
-        var classDescriptor = funNGenerator.getSpecializedDescriptor(Arrays.asList(integerType), integerType);
-        //does not have to contain L and ; because TypeToDescriptor returns the descriptor without these characters as well
-        assertEquals("Fun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$", classDescriptor);
-    }
-
-    @Test
-    public void descriptor_IntT(){
-        var classDescriptor = funNGenerator.getSpecializedDescriptor(Arrays.asList(integerType), genericT);
-        //does not have to contain L and ; because TypeToDescriptor returns the descriptor without these characters as well
-        assertEquals("Fun1$$Ljava$lang$Integer$_$LT$_$", classDescriptor);
-    }
-
-    @Test
-    public void descriptor_TPHTPH(){
-        var classDescriptor = funNGenerator.getSpecializedDescriptor(Arrays.asList(tph), tph);
-        //does not have to contain L and ; because TypeToDescriptor returns the descriptor without these characters as well
-        assertEquals("Fun1$$LTPH$_$LTPH$_$", classDescriptor);
-    }
-
-    @Test
-    public void getArguments_Empty(){
-        var arguments = funNGenerator.getArguments(Arrays.asList());
-        assertTrue(arguments.isEmpty());
-    }
-
-    @Test
-    public void getArguments_Int(){
-        var arguments = funNGenerator.getArguments(Arrays.asList(integerType));
-        assertTrue(arguments.isEmpty());
-    }
-
-    @Test
-    public void getArguments_IntT(){
-        var arguments = funNGenerator.getArguments(Arrays.asList(integerType, genericT));
-        assertTrue(arguments.size() == 1);
-        assertTrue(arguments.contains(integerType));
-    }
-
-    @Test
-    public void getArguments_IntTInt(){
-        var arguments = funNGenerator.getArguments(Arrays.asList(integerType, genericT, integerType));
-        assertTrue(arguments.size() == 2);
-        assertTrue(arguments.contains(integerType));
-        assertTrue(arguments.contains(genericT));
-    }
-
-    @Test
-    public void getReturnType_Empty(){
-        var returnType = funNGenerator.getReturnType(Arrays.asList());
-        assertNull(returnType);
-    }
-
-    @Test
-    public void getReturnType_Int(){
-        var returnType = funNGenerator.getReturnType(Arrays.asList(integerType));
-        assertEquals(integerType, returnType);
-    }
-
-    @Test
-    public void getReturnType_IntT(){
-        var returnType = funNGenerator.getReturnType(Arrays.asList(integerType, genericT));
-        assertEquals(genericT, returnType);
-    }
-
-    @Test
-    public void superBytecode_0(){
-        var superBytecode = funNGenerator.generateSuperBytecode(0);
-        assertArrayEquals(superBytecodeReference_0(), superBytecode);
-    }
-
-    @Test
-    public void superBytecode_1(){
-        var superBytecode = funNGenerator.generateSuperBytecode(1);
-        assertArrayEquals(superBytecodeReference_1(), superBytecode);
-    }
-
-    @Test
-    public void superBytecode_2(){
-        var superBytecode = funNGenerator.generateSuperBytecode(2);
-        assertArrayEquals(superBytecodeReference_2(), superBytecode);
-    }
-
-    @Test
-    public void specializedBytecode_VoidInt(){
-        var specializedBytecode = funNGenerator.generateSpecializedBytecode(Arrays.asList(), integerType);
-        assertArrayEquals(specializedBytecodeReference_VoidInt(), specializedBytecode);
-    }
-
-    @Test
-    public void specializedBytecode_IntInt(){
-        var specializedBytecode = funNGenerator.generateSpecializedBytecode(Arrays.asList(integerType), integerType);
-        assertArrayEquals(specializedBytecodeReference_IntInt(), specializedBytecode);
-    }
-
-    @Test
-    public void specializedBytecode_TIntInt(){
-        var specializedBytecode = funNGenerator.generateSpecializedBytecode(Arrays.asList(genericT, integerType), integerType);
-        assertArrayEquals(specializedBytecodeReference_TIntInt(), specializedBytecode);
-    }
-
-    //super bytecode reference methods
-    private static byte[] superBytecodeReference_0() {
-        var classWriter = new ClassWriter(0);
-        classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun0$$", "<R:Ljava/lang/Object;>Ljava/lang/Object;", "java/lang/Object", null);
-        var methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, "apply", "()Ljava/lang/Object;", "()TR;", null);
-        methodVisitor.visitEnd();
-        classWriter.visitEnd();
-        return classWriter.toByteArray();
-    }
-
-    private static byte[] superBytecodeReference_1() {
-        var classWriter = new ClassWriter(0);
-        classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun1$$", "<T1:Ljava/lang/Object;R:Ljava/lang/Object;>Ljava/lang/Object;", "java/lang/Object", null);
-        var methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, "apply", "(Ljava/lang/Object;)Ljava/lang/Object;", "(TT1;)TR;", null);
-        methodVisitor.visitEnd();
-        classWriter.visitEnd();
-        return classWriter.toByteArray();
-    }
-
-    private static byte[] superBytecodeReference_2() {
-        ClassWriter classWriter = new ClassWriter(0);
-        classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun2$$", "<T1:Ljava/lang/Object;T2:Ljava/lang/Object;R:Ljava/lang/Object;>Ljava/lang/Object;", "java/lang/Object", null);
-        var methodVisitor = classWriter.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, "apply", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", "(TT1;TT2;)TR;", null);
-        methodVisitor.visitEnd();
-        classWriter.visitEnd();
-        return classWriter.toByteArray();
-    }
-
-    //specialized bytecode reference methods
-    private static byte[] specializedBytecodeReference_VoidInt() {
-        ClassWriter classWriter = new ClassWriter(0);
-        classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun0$$Ljava$lang$Integer$_$", "Ljava/lang/Object;LFun0$$<Ljava/lang/Integer;>;", "java/lang/Object", new String[]{"Fun0$$"});
-        classWriter.visitEnd();
-        return classWriter.toByteArray();
-    }
-
-    private static byte[] specializedBytecodeReference_IntInt() {
-        ClassWriter classWriter = new ClassWriter(0);
-        classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun1$$Ljava$lang$Integer$_$Ljava$lang$Integer$_$", "Ljava/lang/Object;LFun1$$<Ljava/lang/Integer;Ljava/lang/Integer;>;", "java/lang/Object", new String[]{"Fun1$$"});
-        classWriter.visitEnd();
-        return classWriter.toByteArray();
-    }
-
-    private static byte[] specializedBytecodeReference_TIntInt() {
-        ClassWriter classWriter = new ClassWriter(0);
-        classWriter.visit(V1_8, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "Fun2$$LT$_$Ljava$lang$Integer$_$Ljava$lang$Integer$_$", "<T:Ljava/lang/Object;>Ljava/lang/Object;LFun2$$<TT;Ljava/lang/Integer;Ljava/lang/Integer;>;", "java/lang/Object", new String[]{"Fun2$$"});
-        classWriter.visitEnd();
-        return classWriter.toByteArray();
-    }
-}

src/test/java/parser/AntlrTest.jav

@@ -1,4 +1,3 @@
-
 class Test{
 method(){
 	if(true)i++;

src/test/java/parser/GeneralParserTest.java

@@ -20,17 +20,18 @@ import org.junit.Test;
  *
  */
 public class GeneralParserTest{
+	private static final String rootDirectory = System.getProperty("user.dir")+"/test/parser/";
+	
 	@Test
 	public void run(){
 
 		
 		List<String> filenames = new ArrayList<String>();
-
-		filenames.add("javFiles/parser/NewTest.jav");
-		//filenames.add("CastTest.jav");
 		/*
+		filenames.add("NewTest.jav");
 		filenames.add("FieldInitializationTest.jav");
 		filenames.add("ImportTest.jav");
+		filenames.add("CastTest.jav");
 		filenames.add("StatementsTest.jav");
 		//filenames.add("Methods.jav");
 		filenames.add("ImportTestGeneric.jav");
@@ -39,14 +40,11 @@ public class GeneralParserTest{
 		//filenames.add("GenericFieldVarTest.jav");
 		filenames.add("FieldVarTest.jav");
 		filenames.add("StructuralTypes.jav");
-		filenames.add("ExtendsTest.jav");
 		*/
-
-		//filenames.add("PackageNameTest.jav");
+//		filenames.add("ExtendsTest.jav");
+		filenames.add("PackageNameTest.jav");
 		try{
-			for(String filename : filenames){
-				new JavaTXCompiler(new File(Thread.currentThread().getContextClassLoader().getResource(filename).getPath()));
-			}
+			new JavaTXCompiler(filenames.stream().map(s -> new File(rootDirectory + s)).collect(Collectors.toList()));
 		}catch(Exception exc){
 			exc.printStackTrace();
 			fail();

src/test/java/targetast/ASTToTargetTest.java

@@ -1,5 +0,0 @@
-package targetast;
-
-public class ASTToTargetTest {
-
-}

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

@@ -4,9 +4,13 @@ import java.lang.Double;
 import java.util.Vector;
 import java.lang.Boolean; 
 
+
+
+
 public class OLFun    {
 
+	//f = x -> {return x + x;};
 	m(f, x) {
-	    var y = f.apply(x + x) + 1;
+		x = f.apply(x+x);
 	}
 }

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

@@ -1,13 +0,0 @@
-import java.lang.String;
-import java.lang.Integer;
-import java.lang.Double;
-import java.util.Vector;
-import java.lang.Boolean;
-
-public class OLFun2 {
-
-	m(f){
-	    var x = 1;
-	    var y = f.apply(x + x) + 1;
-	}
-}

src/test/resources/testBytecode/manually/OLFunTest.java

@@ -1,9 +0,0 @@
-public class OLFunTest{
-    public static void main(String[] args){
-        var olFun2 = new OLFun2();
-        olFun2.m((Integer x) -> x);
-        olFun2.m((Integer x) -> (Double) Double.valueOf(x));
-        olFun2.m((Double x) -> x);
-        olFun2.m((Double x) -> x.intValue());
-    }
-}