From 2eb7a63480d1f5406ac7f2973084ec7bd8aa8f86 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= <pl@dhbw.de>
Date: Sat, 23 Jun 2018 01:05:13 +0200
Subject: [PATCH 01/13] 	modified:  
 src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java FunN$$
 eingefuegt

	modified:   src/de/dhbwstuttgart/syntaxtree/type/FunN.java
	modified:   src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java
	modified:   src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java
	modified:   src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
Methodcall einige Bugs sowohl beim apply als uch bei allen anderen gefixt.

	modified:   test/javFiles/Lambda.jav
---
 .../syntaxtree/factory/UnifyTypeFactory.java     |  2 +-
 src/de/dhbwstuttgart/syntaxtree/type/FunN.java   |  2 +-
 .../typeinference/assumptions/FunNClass.java     | 16 ++++++++++------
 .../assumptions/MethodAssumption.java            |  8 +++++---
 .../typeinference/typeAlgo/TYPEStmt.java         | 12 ++++++++----
 test/javFiles/Lambda.jav                         |  4 ++++
 6 files changed, 29 insertions(+), 15 deletions(-)

diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java
index b05dd0ee..71985334 100644
--- a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java
+++ b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java
@@ -208,7 +208,7 @@ public class UnifyTypeFactory {
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(FunNType t, Map<String,TypePlaceholder> tphs) {
-        RefType ret = new RefType(new JavaClassName(t.getName()), convert(t.getTypeParams(), tphs), new NullToken());
+        RefType ret = new RefType(new JavaClassName(t.getName()+"$$"), convert(t.getTypeParams(), tphs), new NullToken());
         return ret;
     }
 
diff --git a/src/de/dhbwstuttgart/syntaxtree/type/FunN.java b/src/de/dhbwstuttgart/syntaxtree/type/FunN.java
index 84fe1ace..46de6566 100644
--- a/src/de/dhbwstuttgart/syntaxtree/type/FunN.java
+++ b/src/de/dhbwstuttgart/syntaxtree/type/FunN.java
@@ -24,7 +24,7 @@ public class FunN extends RefType {
 	 * @return
 	 */
 	public FunN(List<RefTypeOrTPHOrWildcardOrGeneric> params) {
-		super(new JavaClassName("Fun"+params.size()), params, new NullToken());
+		super(new JavaClassName("Fun"+(params.size())), params, new NullToken());
 	}
 
 	/**
diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java b/src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java
index 3518c16a..0c8220f1 100644
--- a/src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java
+++ b/src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java
@@ -8,32 +8,36 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
+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.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class FunNClass extends ClassOrInterface {
-    public FunNClass(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
-        super(0, new JavaClassName("Fun"+(funNParams.size()-1)), new ArrayList<>(),
+    public FunNClass(List<GenericRefType> funNParams) {
+        super(0, new JavaClassName("Fun"+(funNParams.size())), new ArrayList<>(),
                 createMethods(funNParams), new ArrayList<>(), createGenerics(funNParams),
                 ASTFactory.createObjectType(), true, new ArrayList<>(), new NullToken());
 
 
         }
 
-    private static GenericDeclarationList createGenerics(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
+    private static GenericDeclarationList createGenerics(List<GenericRefType> funNParams) {
+    	//PL 2018-06-22: so geaendert, dass generierte Generics den Namen der funParams entsprechen.
         List<GenericTypeVar> generics = new ArrayList<>();
-        for(RefTypeOrTPHOrWildcardOrGeneric param : funNParams){
-            generics.add(new GenericTypeVar(NameGenerator.makeNewName(),
+        for(GenericRefType param : funNParams){
+            generics.add(new GenericTypeVar(param.getParsedName(),//NameGenerator.makeNewName(),
                     new ArrayList<>(), new NullToken(), new NullToken()));
         }
         return new GenericDeclarationList(generics, new NullToken());
     }
 
-    private static List<Method> createMethods(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
+    private static List<Method> createMethods(List<GenericRefType> funNParams) {
         return null;
     }
 }
diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java b/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java
index e17281e5..294c8507 100644
--- a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java
+++ b/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java
@@ -16,10 +16,10 @@ import java.util.List;
 public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;
     private RefTypeOrTPHOrWildcardOrGeneric retType;
-    List<RefTypeOrTPHOrWildcardOrGeneric> params;
+    List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
 
     public MethodAssumption(ClassOrInterface receiver, RefTypeOrTPHOrWildcardOrGeneric retType,
-                            List<RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
+                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
         super(scope);
         this.receiver = receiver;
         this.retType = retType;
@@ -38,7 +38,9 @@ public class MethodAssumption extends Assumption{
     }
 
     public RefTypeOrTPHOrWildcardOrGeneric getReturnType(GenericsResolver resolver) {
-        if(retType instanceof GenericRefType)return resolver.resolve(retType);
+        if(retType instanceof GenericRefType) {
+        	return resolver.resolve(retType);
+        }
         return retType;
     }
 
diff --git a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
index fcd8ecfa..44fc5e88 100644
--- a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
+++ b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
@@ -6,6 +6,7 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
@@ -451,11 +452,14 @@ public class TYPEStmt implements StatementVisitor{
         List<MethodAssumption> ret = new ArrayList<>();
         //TODO: apply Methoden wieder anfügen. Diese könnten möglicherweise auch in den Assumptions auftauchen (überdenken)
         if(name.equals("apply")){
-            List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
+            List<GenericRefType> funNParams = new ArrayList<>();
             for(int i = 0; i< numArgs + 1 ; i++){
-                funNParams.add(TypePlaceholder.fresh(new NullToken()));
+                //funNParams.add(TypePlaceholder.fresh(new NullToken()));
+            	funNParams.add(new GenericRefType(NameGenerator.makeNewName(),
+                        new NullToken()));
             }
-            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(0), funNParams.subList(1, funNParams.size()),
+            funNParams.get(funNParams.size()-1);
+            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(funNParams.size()-1), funNParams.subList(0, funNParams.size()-1),
                     new TypeScope() {
                         @Override
                         public Iterable<? extends GenericTypeVar> getGenerics() {
@@ -498,7 +502,7 @@ public class TYPEStmt implements StatementVisitor{
          */
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
         for(FormalParameter fp : parameterList.getFormalparalist()){
-            params.add(info.checkGTV(fp.getType()));
+            params.add(fp.getType()); //info.checkGTV(fp.getType())); //PL 2018-06-22 GTV sollen in Argumenten erhalten bleiben
         }
         return params;
     }
diff --git a/test/javFiles/Lambda.jav b/test/javFiles/Lambda.jav
index 02e8b51b..7a3aee0b 100644
--- a/test/javFiles/Lambda.jav
+++ b/test/javFiles/Lambda.jav
@@ -1,9 +1,13 @@
 import java.lang.Integer;
 import java.lang.Number;
+import java.util.Vector;
 
 public class Lambda {
 
   m () {
+   var v;
+   v.addElement(3);
+   v.elementAt(1);
    var lam1 = (x) -> {
         return x;
    };

From 0ecaf36648cff60ddb7e4771bd6cf34d34aabbf3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= <pl@dhbw.de>
Date: Sat, 23 Jun 2018 10:42:46 +0200
Subject: [PATCH 02/13] 	modified:  
 src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java Bei Literal die
 Zuweisung des Typs eingefuegt aber wieder auskommentiert, weil es im Moment
 nur double Literals gibt. 	modified:   test/javFiles/Lambda.jav

---
 .../typeinference/typeAlgo/TYPEStmt.java              | 11 ++++++++++-
 test/javFiles/Lambda.jav                              |  9 ++-------
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
index 44fc5e88..e87f2f55 100644
--- a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
+++ b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
@@ -328,7 +328,16 @@ public class TYPEStmt implements StatementVisitor{
 
     @Override
     public void visit(Literal literal) {
-        //Nothing to do here. Literale erzeugen keine Constraints
+        //Nothing to do here. Literale erzeugen keine Constraints 
+    	//PL 2018-06-23 Sie haben einen Typ. Der muesste hier eingefuegt werden
+    	//wie hier fuer double gezeigt. Im Momment auskommentiert, weil zu wenige Literaltypen
+    	//funktionieren
+    	//if (literal.value instanceof Double) {
+    	//	constraintsSet.addUndConstraint(new Pair(literal.getType(), doublee, PairOperator.EQUALSDOT));
+    	//}
+    	//else {
+    	//	throw new NotImplementedException();
+    	//}
     }
 
     @Override
diff --git a/test/javFiles/Lambda.jav b/test/javFiles/Lambda.jav
index 7a3aee0b..b9a2c3f9 100644
--- a/test/javFiles/Lambda.jav
+++ b/test/javFiles/Lambda.jav
@@ -1,17 +1,12 @@
-import java.lang.Integer;
-import java.lang.Number;
-import java.util.Vector;
+class Apply { } 
 
 public class Lambda {
 
   m () {
-   var v;
-   v.addElement(3);
-   v.elementAt(1);
    var lam1 = (x) -> {
         return x;
    };
-   return lam1.apply(1);
+   return lam1.apply(new Apply());
   }
 }
 

From d8bb4d61881e3f84a2a4223d3bec14b57db3538c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= <pl@dhbw.de>
Date: Sat, 23 Jun 2018 10:54:14 +0200
Subject: [PATCH 03/13] 	modified:   test/bytecode/javFiles/Lambda.jav Lambda
 auf apply angepasst

---
 test/bytecode/javFiles/Lambda.jav | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/test/bytecode/javFiles/Lambda.jav b/test/bytecode/javFiles/Lambda.jav
index de434271..b9a2c3f9 100644
--- a/test/bytecode/javFiles/Lambda.jav
+++ b/test/bytecode/javFiles/Lambda.jav
@@ -1,11 +1,12 @@
-import java.lang.Integer;
+class Apply { } 
 
 public class Lambda {
 
   m () {
-   var lam1 = (Integer x) -> {
+   var lam1 = (x) -> {
         return x;
    };
-   return lam1.apply(1);
+   return lam1.apply(new Apply());
   }
 }
+

From b4c604e2b172e10c3323b10a8d35abefac5f3676 Mon Sep 17 00:00:00 2001
From: Fayez Abu Alia <fayez@Fayezs-MacBook-Pro.local>
Date: Wed, 27 Jun 2018 14:49:22 +0200
Subject: [PATCH 04/13] =?UTF-8?q?Bug=20in=20der=20Methode=20simplifyPairs?=
 =?UTF-8?q?=20gefixt.=20Bug=2082=20gefixt.=20TPHs=20in=20paramtrisierten?=
 =?UTF-8?q?=20Typen=20als=20TypeVariablen=20in=20Signature=20hinzugef?=
 =?UTF-8?q?=C3=BCgt.=20Lambda.jav=20funktioniert.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/de/dhbwstuttgart/.DS_Store                | Bin 6148 -> 6148 bytes
 .../dhbwstuttgart/bytecode/BytecodeGen.java   |  40 ++++-
 .../bytecode/BytecodeGenMethod.java           |  13 ++
 .../descriptor/DescriptorToString.java        |  33 +++-
 .../bytecode/signature/Signature.java         | 143 +++++++++++++++++-
 .../bytecode/signature/TypeToSignature.java   |   7 +-
 test/bytecode/javFiles/Lambda.jav             |   5 +-
 test/bytecode/javFiles/Matrix.jav             |  12 +-
 8 files changed, 230 insertions(+), 23 deletions(-)

diff --git a/src/de/dhbwstuttgart/.DS_Store b/src/de/dhbwstuttgart/.DS_Store
index f20299e87666851977a6b404d3ad84ba10b1fb67..aa8a1074b6c8b435c3b9b58fbf5afc60d45b908c 100644
GIT binary patch
delta 358
zcmZoMXfc=|#>B)qu~2NHo}wr-0|Nsi1A_nqLo!1?LkdG`Qh9N~#*NDv>p?Oc3`q=?
z3?&Sy$g)W}`AI;z6G;U*nZ+dr2G<#xm|0la*f}`3IJkJZVuLgC%Y#c2OG=BK5{sfi
zynw`#j3g*KBtJg~&Q44U%S<hg7Z7pI&nrpH%u6i-YtBqbP0C6viV4rmOUW;H$}i1J
zDFz!943bGK;^5%q;EWd#udX&W&`~fpF|5^5s5UnTvQ3Q5YHK+;#8nM#Jri;(tEy{i
z>t+BQ3j~ZnZ-N0ol!j3=C-x}FV)(QyxF|0tKQA4qigDw{Yb=}DIruq%;kI$(cjn3b
ZBDx|V?I0r?AT-$Y%^@Nim?t){008kdTL1t6

delta 94
zcmZoMXfc=|#>CJzu~2NHo}wrt0|NsP3otMwGvqU*Fr=mwC+AEoRG%!sEIOHknP;;J
t^JSLJ4$K`)o7p+|Ie;2B8!~@qp3E<z%L&qZ0EihT+we$ljuBbH3;+ZC6?Fgr

diff --git a/src/de/dhbwstuttgart/bytecode/BytecodeGen.java b/src/de/dhbwstuttgart/bytecode/BytecodeGen.java
index 0dd57374..a3103657 100644
--- a/src/de/dhbwstuttgart/bytecode/BytecodeGen.java
+++ b/src/de/dhbwstuttgart/bytecode/BytecodeGen.java
@@ -121,7 +121,7 @@ public class BytecodeGen implements ASTVisitor {
 			// Nur einmal ausführen!!
 			if(!isVisited) {
 				classOrInterface.accept(tphExtractor);
-				
+
 				getCommonTPHS(tphExtractor);
 
 				String sig = null;
@@ -275,6 +275,11 @@ public class BytecodeGen implements ASTVisitor {
 	}
 	
 	private ArrayList<GenericInsertPair> simplifyPairs(String methodName, ArrayList<GenericInsertPair> allPairs) {
+		allPairs.forEach(p->System.out.print(p.TA1 + " < "+ p.TA2+ " ; "));
+		
+		if(allPairs.size() < 2)
+			return allPairs;
+		
 		ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
 		
 		MethodAndTPH method;
@@ -320,22 +325,41 @@ public class BytecodeGen implements ASTVisitor {
 				numOfVisitedPairs++;
 			}
 			
-			// TODO: teste noch den Fall X < Y und Y nicht in TPHS der Methode
-			// 		 Dann hat man nach der While-Schleife X < Y
-			//		 Y muss durch Object ersetzt.
-			
 			// Subtype
 			TypePlaceholder subTphRes = tphsInRel.get(0);
 			// Die größte Supertype
 			TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
+			
+			while(subAndSuperTph.containsValue(subTphRes)) {
+				for(TypePlaceholder tph : subAndSuperTph.keySet()) {
+					if(methodTphs.contains(tph) && subAndSuperTph.get(tph).equals(subTphRes)) {
+						subTphRes = tph;
+						break;
+					}
+				}
+				if(subTphRes.equals(tphsInRel.get(0))) {
+					break;
+				}
+				tphsInRel.put(0, subTphRes);
+				numOfVisitedPairs++;
+			}
+			
+			subTphRes = tphsInRel.get(0);
+			
 			int i = 2;
 			while(!methodTphs.contains(superTphRes) && (tphsInRel.size()-i) >0) {
 				superTphRes = tphsInRel.get(tphsInRel.size()-i);
 				i++;
 			}
+			// teste noch den Fall X < Y und Y nicht in TPHS der Methode
+			// 		 Dann hat man nach der While-Schleife X < Y
+			//		 Y muss durch Object ersetzt.
 			
-			GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
-			simplifiedPairs.add(sPair);
+			// Zweite Operand für die Fälle wie in Lambda.jav (Paramtrisierte Typen) 
+			if(methodTphs.contains(superTphRes) || !tphExtractor.allTPHS.containsKey(superTphRes)) {
+				GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
+				simplifiedPairs.add(sPair);
+			}
 		}
 		return simplifiedPairs;
 	}
@@ -599,7 +623,6 @@ public class BytecodeGen implements ASTVisitor {
 					methodAndTph.getTphs().add(resolvedTPH);
 				
 				allTPHS.put(resolvedTPH,inMethod);
-				ResolvedType rst = resultSet.resolveType(tph);
 				resultSet.resolveType(tph).additionalGenerics.forEach(ag ->{
 					if(ag.contains(resolvedTPH)&&ag.TA1.equals(resolvedTPH)&&!contains(allPairs,ag)) {
 						if(inMethod)
@@ -625,6 +648,7 @@ public class BytecodeGen implements ASTVisitor {
 			inMethod = false;
 			ListOfMethodsAndTph.add(methodAndTph);
 		}
+		
 	}
 
 }
diff --git a/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java b/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
index 9d03979f..b5486df7 100644
--- a/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
+++ b/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
@@ -639,6 +639,19 @@ public class BytecodeGenMethod implements StatementVisitor {
 	public void visit(MethodCall methodCall) {
 		
 		//ClassLoader.getSystemClassLoader().loadClass(className).getMethod(name, parameterTypes)
+		String receiverName = getResolvedType(methodCall.receiver.getType());
+		System.out.println("Methods of " + receiverName + " ");
+		ClassLoader cl = ClassLoader.getSystemClassLoader();
+		try {
+			java.lang.reflect.Method[] methods = cl.loadClass("java.util.Vector").getMethods();
+			System.out.println("Methods of " + receiverName + " ");
+			for(java.lang.reflect.Method m : methods) {
+				System.out.println(m.getName() + " " + m.toGenericString()+ " ==> ");
+			}
+		} catch (Exception e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
 		
 		System.out.println("Methodcall type : " + resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor()));
 		methodCall.receiver.accept(this);
diff --git a/src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java b/src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java
index b22109c1..2b9bb931 100644
--- a/src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java
+++ b/src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java
@@ -123,9 +123,21 @@ public class DescriptorToString implements DescriptorVisitor{
 		Iterator<FormalParameter> itr = lambdaExpression.getParams().iterator();
 		while(itr.hasNext()) {
 			FormalParameter fp = itr.next();
-			desc = desc + "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()) + ";";
+			String d = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
+				desc += "L"+Type.getInternalName(Object.class)+ ";";
+			}else {
+				desc = desc + "L"+ d + ";";
+			}
+		}
+		
+		String retType = resultSet.resolveType(lambdaExpression.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+		
+		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
+			desc += ")L"+Type.getInternalName(Object.class)+ ";";
+		}else {
+			desc = desc + ")"+"L"+retType+";";
 		}
-		desc = addReturnType(desc, lambdaExpression.getReturnType(), resultSet);
 		return desc;
 	}
 
@@ -135,9 +147,22 @@ public class DescriptorToString implements DescriptorVisitor{
 		Iterator<RefTypeOrTPHOrWildcardOrGeneric> itr = samMethod.getArgumentList().iterator();
 		while(itr.hasNext()) {
 			RefTypeOrTPHOrWildcardOrGeneric rt = itr.next();
-			desc = desc + "L"+resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor())+";";
+			String d = resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor());
+			
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
+				desc += "L"+Type.getInternalName(Object.class)+ ";";
+			}else {
+				desc += "L"+ d + ";";
+				
+			}
+		}
+		String retType = resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+		
+		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
+			desc += ")L"+Type.getInternalName(Object.class)+ ";";
+		}else {
+			desc = desc + ")"+"L"+retType+";";
 		}
-		desc = desc + ")"+"L"+resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
 		return desc;
 	}
 
diff --git a/src/de/dhbwstuttgart/bytecode/signature/Signature.java b/src/de/dhbwstuttgart/bytecode/signature/Signature.java
index 7b222770..09a2788f 100644
--- a/src/de/dhbwstuttgart/bytecode/signature/Signature.java
+++ b/src/de/dhbwstuttgart/bytecode/signature/Signature.java
@@ -9,6 +9,7 @@ import org.objectweb.asm.signature.SignatureVisitor;
 import org.objectweb.asm.signature.SignatureWriter;
 
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
+import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Constructor;
@@ -16,9 +17,11 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
+import de.dhbwstuttgart.typeinference.result.ResolvedType;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
 public class Signature {
@@ -106,7 +109,7 @@ public class Signature {
 		// z.B: Type = TPH K => wird eine Formal Type Parameter K$ erzeugt und Bound = Object
 		String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
 		if(ret.substring(0,4).equals("TPH ")) {
-			String g = ret.substring(4)+"$";
+			String g = ret.substring(4,ret.length())+"$";
 			if(genericsAndBounds.containsKey(g)) {
 				genericsAndBoundsMethod.put(g, genericsAndBounds.get(g));
 			}else {
@@ -117,13 +120,21 @@ public class Signature {
 			}
 		}
 		
+		if(ret.contains("<")) {
+			RefType ref = (RefType) resultSet.resolveType(method.getReturnType()).resolvedType;
+			if(hasTPHs(ref)) {
+				createSignatureForParameterizedType(ref);
+			}
+			
+		}
+		
 		// Parameters
 		for(String paramName : methodParamsAndTypes.keySet()) {
 			RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
 			String pT = t.acceptTV(new TypeToSignature()); 
 			// S.o
 			if(pT.substring(0,4).equals("TPH ")) {
-				String gP = pT.substring(4)+"$";
+				String gP = pT.substring(4,pT.length())+"$";
 				if(!genericsAndBounds.containsKey(gP) && !genericsAndBoundsMethod.containsKey(gP)) {
 					sw.visitFormalTypeParameter(gP);
 					String bound = Type.getInternalName(Object.class);
@@ -147,6 +158,12 @@ public class Signature {
 				}
 			}
 			
+			if(pT.contains("<")) {
+				RefType ref = (RefType) methodParamsAndTypes.get(paramName);
+				if(hasTPHs(ref))
+					createSignatureForParameterizedType(ref);
+			}
+			
 			for(GenericInsertPair p:methodPairs) {
 				String name = p.TA1.getName()+"$";
 				if(!genericsAndBoundsMethod.containsKey(name)) {
@@ -191,6 +208,128 @@ public class Signature {
 		}
 //		sw.visitEnd();
 	}
+	
+	private void createSignatureForParameterizedType(RefType ref) {
+		ArrayList<GenericInsertPair> allPairs = getAllPairs(ref);
+		allPairs.addAll(methodPairs);
+		ArrayList<GenericInsertPair> simplifiedPairs = simplifyPairs(allPairs);
+		
+		HashMap<String, String> names = new HashMap<>();
+		
+		for(GenericInsertPair pair : simplifiedPairs) {
+			String sub = pair.TA1.getName()+"$";
+			String superT = pair.TA2.getName()+"$";
+			names.put(sub, superT);
+		}
+		
+		for(String sub : names.keySet()) {
+			if(!genericsAndBoundsMethod.containsKey(sub) && !genericsAndBounds.containsKey(sub)) {
+				sw.visitFormalTypeParameter(sub);
+				String bound = names.get(sub);
+				sw.visitClassBound().visitTypeVariable(bound);
+				genericsAndBoundsMethod.put(sub, bound);
+			}
+		}
+		
+		for(String superT : names.values()) {
+			if(!names.containsKey(superT)) {
+				if(!genericsAndBoundsMethod.containsKey(superT) && !genericsAndBounds.containsKey(superT)) {
+					sw.visitFormalTypeParameter(superT);
+					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+					sw.visitClassBound().visitEnd();
+					genericsAndBoundsMethod.put(superT, Type.getInternalName(Object.class));
+				}
+			}
+		}
+	}
+
+	private ArrayList<GenericInsertPair> getAllPairs(RefType ref) {
+		final ArrayList<GenericInsertPair> res = new ArrayList<>();
+		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
+			RefTypeOrTPHOrWildcardOrGeneric resolved = resultSet.resolveType(p).resolvedType;
+			if(resolved instanceof TypePlaceholder) {
+				resultSet.resolveType(p).additionalGenerics.forEach(ag ->{
+					if(!contains(res,ag)) {
+						res.add(ag);
+					}
+				});
+			}
+				
+		}
+		return res;
+	}
+	
+	private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
+		for(int i=0; i<pairs.size();++i) {
+			GenericInsertPair p = pairs.get(i);
+			if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
+				return true;
+		}
+		return false;
+	}
+	
+	private ArrayList<GenericInsertPair> simplifyPairs(ArrayList<GenericInsertPair> allPairs) {
+		ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
+		
+		HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
+		for(GenericInsertPair p : allPairs) {
+			subAndSuperTph.put(p.TA1, p.TA2);
+		}
+		
+		subAndSuperTph.forEach((k,v)->System.out.println(k.getName() + " || " + v.getName()));
+		
+		int numOfVisitedPairs = 0;
+		for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
+			
+			if(numOfVisitedPairs>=subAndSuperTph.size())
+				break;
+			
+			HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
+			
+			tphsInRel.put(tphsInRel.size(), subTph);
+			TypePlaceholder superTph = subAndSuperTph.get(subTph);
+			tphsInRel.put(tphsInRel.size(), superTph);
+			
+			numOfVisitedPairs++;
+			
+			while(subAndSuperTph.containsKey(superTph)) {
+				superTph = subAndSuperTph.get(superTph);
+				tphsInRel.put(tphsInRel.size(), superTph);
+				numOfVisitedPairs++;
+			}
+			
+			// Subtype
+			TypePlaceholder subTphRes = tphsInRel.get(0);
+			// Die größte Supertype
+			TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
+			
+			
+			while(subAndSuperTph.containsValue(subTphRes)) {
+				for(TypePlaceholder tph : subAndSuperTph.keySet()) {
+					if(subAndSuperTph.get(tph).equals(subTphRes)) {
+						subTphRes = tph;
+						break;
+					}
+				}
+				tphsInRel.put(0, subTphRes);
+				numOfVisitedPairs++;
+			}
+			
+			subTphRes = tphsInRel.get(0);
+			GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
+			simplifiedPairs.add(sPair);
+		}
+		return simplifiedPairs;
+	}
+	
+	private boolean hasTPHs(RefType ref) {
+		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
+			if(resultSet.resolveType(p).resolvedType instanceof TypePlaceholder)
+				return true;
+		}
+		return false;
+	}
+
 	/**
 	 * Visits parameter type or return type with {@link SignatureVisitor} to create
 	 * the method signature
diff --git a/src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java b/src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java
index a1357d4c..62227c8e 100644
--- a/src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java
+++ b/src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java
@@ -22,7 +22,12 @@ public class TypeToSignature implements TypeVisitor<String> {
             Iterator<RefTypeOrTPHOrWildcardOrGeneric> it = refType.getParaList().iterator();
             while(it.hasNext()){
                 RefTypeOrTPHOrWildcardOrGeneric param = it.next();
-                params += "L"+param.toString().replace(".", "/");
+                if(param instanceof TypePlaceholder) {
+                		params += "T" + ((TypePlaceholder) param).getName() + "$";
+                } else {
+                		params += "L"+param.toString().replace(".", "/");
+                }
+                
                 if(it.hasNext())params += ";";
             }
             params += ";>";
diff --git a/test/bytecode/javFiles/Lambda.jav b/test/bytecode/javFiles/Lambda.jav
index b9a2c3f9..5ee83868 100644
--- a/test/bytecode/javFiles/Lambda.jav
+++ b/test/bytecode/javFiles/Lambda.jav
@@ -1,4 +1,4 @@
-class Apply { } 
+//class Apply { } 
 
 public class Lambda {
 
@@ -6,7 +6,8 @@ public class Lambda {
    var lam1 = (x) -> {
         return x;
    };
-   return lam1.apply(new Apply());
+//   return lam1.apply(new Apply());
+   return lam1;
   }
 }
 
diff --git a/test/bytecode/javFiles/Matrix.jav b/test/bytecode/javFiles/Matrix.jav
index f0ea0356..eff095c7 100644
--- a/test/bytecode/javFiles/Matrix.jav
+++ b/test/bytecode/javFiles/Matrix.jav
@@ -8,9 +8,9 @@ public class Matrix extends Vector<Vector<Integer>> {
         var i = 0;
         while(i < size()) {
             var v1 = this.elementAt(i);
-            var v2 = new Vector<Integer>();
-            var j = 0;
-            while(j < v1.size()) {
+//            var v2 = new Vector<Integer>();
+//            var j = 0;
+//            while(j < v1.size()) {
 //                var erg = 0;
  //               var k = 0;
   //              while(k < v1.size()) {
@@ -18,9 +18,9 @@ public class Matrix extends Vector<Vector<Integer>> {
  //                            * m.elementAt(k).elementAt(j);
    //                 k++; }
     //            v2.addElement(new Integer(erg));
-                j++; }
-            ret.addElement(v2);
-            i++; 
+//                j++; }
+//            ret.addElement(v2);
+//            i++; 
          }
         return ret;
     }

From 7926c25c7d2254e7a607005c410991e17be7014d Mon Sep 17 00:00:00 2001
From: Fayez Abu Alia <fayez@Fayezs-MacBook-Pro.local>
Date: Wed, 27 Jun 2018 15:20:35 +0200
Subject: [PATCH 05/13] =?UTF-8?q?Soviel=20wie=20m=C3=B6glich=20unn=C3=B6ti?=
 =?UTF-8?q?ge=20TPHs=20aus=20Signaturen=20von=20Paramtrisierten=20Typen=20?=
 =?UTF-8?q?entfernt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../bytecode/signature/Signature.java         | 20 ++++-
 test/bytecode/javFiles/Lambda.jav             |  4 +-
 test/logFiles/log                             | 83 +++++++++++++++++++
 3 files changed, 103 insertions(+), 4 deletions(-)
 create mode 100644 test/logFiles/log

diff --git a/src/de/dhbwstuttgart/bytecode/signature/Signature.java b/src/de/dhbwstuttgart/bytecode/signature/Signature.java
index 09a2788f..11f3ca20 100644
--- a/src/de/dhbwstuttgart/bytecode/signature/Signature.java
+++ b/src/de/dhbwstuttgart/bytecode/signature/Signature.java
@@ -217,9 +217,11 @@ public class Signature {
 		HashMap<String, String> names = new HashMap<>();
 		
 		for(GenericInsertPair pair : simplifiedPairs) {
-			String sub = pair.TA1.getName()+"$";
-			String superT = pair.TA2.getName()+"$";
-			names.put(sub, superT);
+			if(ref.getParaList().contains(pair.TA1)) {
+				String sub = pair.TA1.getName()+"$";
+				String superT = pair.TA2.getName()+"$";
+				names.put(sub, superT);
+			}
 		}
 		
 		for(String sub : names.keySet()) {
@@ -241,6 +243,18 @@ public class Signature {
 				}
 			}
 		}
+		
+		for(RefTypeOrTPHOrWildcardOrGeneric p: ref.getParaList()) {
+			if(p instanceof TypePlaceholder) {
+				String name = ((TypePlaceholder) p).getName() + "$";
+				if(!genericsAndBoundsMethod.containsKey(name) && !genericsAndBounds.containsKey(name)) {
+					sw.visitFormalTypeParameter(name);
+					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+					sw.visitClassBound().visitEnd();
+					genericsAndBoundsMethod.put(name, Type.getInternalName(Object.class));
+				}
+			}
+		}
 	}
 
 	private ArrayList<GenericInsertPair> getAllPairs(RefType ref) {
diff --git a/test/bytecode/javFiles/Lambda.jav b/test/bytecode/javFiles/Lambda.jav
index 5ee83868..620440cd 100644
--- a/test/bytecode/javFiles/Lambda.jav
+++ b/test/bytecode/javFiles/Lambda.jav
@@ -1,4 +1,5 @@
-//class Apply { } 
+import java.util.Vector;
+class Apply { } 
 
 public class Lambda {
 
@@ -8,6 +9,7 @@ public class Lambda {
    };
 //   return lam1.apply(new Apply());
    return lam1;
+//   return new Vector();
   }
 }
 
diff --git a/test/logFiles/log b/test/logFiles/log
new file mode 100644
index 00000000..25a6eae5
--- /dev/null
+++ b/test/logFiles/log
@@ -0,0 +1,83 @@
+FC:\{java.util.AbstractList<DHR>=Elem: Node(java.util.AbstractList<DHR>)
+Prec: [java.util.Collection<DHR>, java.lang.Object, java.util.List<DHR>, java.lang.Iterable<DHR>, java.util.AbstractCollection<DHR>]
+Desc: [java.util.Vector<DHR>]
+
+, java.util.Collection<DHR>=Elem: Node(java.util.Collection<DHR>)
+Prec: [java.lang.Object, java.lang.Iterable<DHR>]
+Desc: [java.util.AbstractList<DHR>, java.util.List<DHR>, java.util.Vector<DHR>, java.util.AbstractCollection<DHR>]
+
+, java.lang.Cloneable=Elem: Node(java.lang.Cloneable)
+Prec: [java.lang.Object]
+Desc: [java.util.Vector<DHR>]
+
+, java.lang.Object=Elem: Node(java.lang.Object)
+Prec: [java.lang.Object]
+Desc: [java.util.AbstractList<DHR>, java.lang.Cloneable, java.util.Collection<DHR>, java.lang.Object, java.util.RandomAccess, Lambda, java.io.Serializable, java.util.List<DHR>, java.util.Vector<DHR>, java.lang.Iterable<DHR>, java.util.AbstractCollection<DHR>, Apply]
+
+, java.util.RandomAccess=Elem: Node(java.util.RandomAccess)
+Prec: [java.lang.Object]
+Desc: [java.util.Vector<DHR>]
+
+, java.util.List<DHR>=Elem: Node(java.util.List<DHR>)
+Prec: [java.util.Collection<DHR>, java.lang.Object, java.lang.Iterable<DHR>]
+Desc: [java.util.AbstractList<DHR>, java.util.Vector<DHR>]
+
+, Lambda=Elem: Node(Lambda)
+Prec: [java.lang.Object]
+Desc: []
+
+, java.io.Serializable=Elem: Node(java.io.Serializable)
+Prec: [java.lang.Object]
+Desc: [java.util.Vector<DHR>]
+
+, java.util.Vector<DHR>=Elem: Node(java.util.Vector<DHR>)
+Prec: [java.util.AbstractList<DHR>, java.lang.Cloneable, java.util.Collection<DHR>, java.lang.Object, java.util.RandomAccess, java.io.Serializable, java.util.List<DHR>, java.lang.Iterable<DHR>, java.util.AbstractCollection<DHR>]
+Desc: []
+
+, java.lang.Iterable<DHR>=Elem: Node(java.lang.Iterable<DHR>)
+Prec: [java.lang.Object]
+Desc: [java.util.AbstractList<DHR>, java.util.Collection<DHR>, java.util.List<DHR>, java.util.Vector<DHR>, java.util.AbstractCollection<DHR>]
+
+, java.util.AbstractCollection<DHR>=Elem: Node(java.util.AbstractCollection<DHR>)
+Prec: [java.util.Collection<DHR>, java.lang.Object, java.lang.Iterable<DHR>]
+Desc: [java.util.AbstractList<DHR>, java.util.Vector<DHR>]
+
+, Apply=Elem: Node(Apply)
+Prec: [java.lang.Object]
+Desc: []
+
+}
+class Apply {
+
+  Apply()({
+    super(());
+  })::TPH M
+
+}class Lambda {
+
+  TPH X m()({
+    TPH Y lam1;
+    (lam1)::TPH Y = ((TPH Z x) -> ({
+      return (x)::TPH Z;
+    })::TPH AA)::TPH AD;
+    return (lam1)::TPH Y;
+  })::TPH AE
+
+  Lambda()({
+    super(());
+  })::TPH AH
+
+}0 AA: [(AA =. BFC, 1, -1)]
+1 Unifikation: [(AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Z <. AA, 1, 1), (AD <. Y, -1, -1), (Y <. X, -1, -1)]
+1 AA: [(AA =. BFC, 1, -1)]
+2 Unifikation: [(Fun1<Z,BFC> <. Y, , -1), (AD =. Fun1<Z,BFC>, -1), (Z <. BFC, 1, -1), (AA =. BFC, 1, -1), (Y <. X, -1, -1)]
+2 AA: [(AA =. BFC, 1, -1)]
+3 Unifikation: [(Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (Fun1<gen_hv,gen_bf> <. X, , -1), (BFC <. gen_bf, -1, -1), (gen_hv <. Z, 1, 1)]
+3 AA: [(AA =. BFC, 1, -1)]
+4 Unifikation: [(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]
+[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]
+Result1 [[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]]
+Result1 [[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]]
+Result1 [[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]]
+Result1 [[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]]
+RES: [[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]]

From 29bd9a3f4f8ddb7c15c65ec0f45229a93c649e30 Mon Sep 17 00:00:00 2001
From: Fayez Abu Alia <fayez@Fayezs-MacBook-Pro.local>
Date: Wed, 27 Jun 2018 15:39:04 +0200
Subject: [PATCH 06/13] remove logFile

---
 test/logFiles/log | 83 -----------------------------------------------
 1 file changed, 83 deletions(-)
 delete mode 100644 test/logFiles/log

diff --git a/test/logFiles/log b/test/logFiles/log
deleted file mode 100644
index 25a6eae5..00000000
--- a/test/logFiles/log
+++ /dev/null
@@ -1,83 +0,0 @@
-FC:\{java.util.AbstractList<DHR>=Elem: Node(java.util.AbstractList<DHR>)
-Prec: [java.util.Collection<DHR>, java.lang.Object, java.util.List<DHR>, java.lang.Iterable<DHR>, java.util.AbstractCollection<DHR>]
-Desc: [java.util.Vector<DHR>]
-
-, java.util.Collection<DHR>=Elem: Node(java.util.Collection<DHR>)
-Prec: [java.lang.Object, java.lang.Iterable<DHR>]
-Desc: [java.util.AbstractList<DHR>, java.util.List<DHR>, java.util.Vector<DHR>, java.util.AbstractCollection<DHR>]
-
-, java.lang.Cloneable=Elem: Node(java.lang.Cloneable)
-Prec: [java.lang.Object]
-Desc: [java.util.Vector<DHR>]
-
-, java.lang.Object=Elem: Node(java.lang.Object)
-Prec: [java.lang.Object]
-Desc: [java.util.AbstractList<DHR>, java.lang.Cloneable, java.util.Collection<DHR>, java.lang.Object, java.util.RandomAccess, Lambda, java.io.Serializable, java.util.List<DHR>, java.util.Vector<DHR>, java.lang.Iterable<DHR>, java.util.AbstractCollection<DHR>, Apply]
-
-, java.util.RandomAccess=Elem: Node(java.util.RandomAccess)
-Prec: [java.lang.Object]
-Desc: [java.util.Vector<DHR>]
-
-, java.util.List<DHR>=Elem: Node(java.util.List<DHR>)
-Prec: [java.util.Collection<DHR>, java.lang.Object, java.lang.Iterable<DHR>]
-Desc: [java.util.AbstractList<DHR>, java.util.Vector<DHR>]
-
-, Lambda=Elem: Node(Lambda)
-Prec: [java.lang.Object]
-Desc: []
-
-, java.io.Serializable=Elem: Node(java.io.Serializable)
-Prec: [java.lang.Object]
-Desc: [java.util.Vector<DHR>]
-
-, java.util.Vector<DHR>=Elem: Node(java.util.Vector<DHR>)
-Prec: [java.util.AbstractList<DHR>, java.lang.Cloneable, java.util.Collection<DHR>, java.lang.Object, java.util.RandomAccess, java.io.Serializable, java.util.List<DHR>, java.lang.Iterable<DHR>, java.util.AbstractCollection<DHR>]
-Desc: []
-
-, java.lang.Iterable<DHR>=Elem: Node(java.lang.Iterable<DHR>)
-Prec: [java.lang.Object]
-Desc: [java.util.AbstractList<DHR>, java.util.Collection<DHR>, java.util.List<DHR>, java.util.Vector<DHR>, java.util.AbstractCollection<DHR>]
-
-, java.util.AbstractCollection<DHR>=Elem: Node(java.util.AbstractCollection<DHR>)
-Prec: [java.util.Collection<DHR>, java.lang.Object, java.lang.Iterable<DHR>]
-Desc: [java.util.AbstractList<DHR>, java.util.Vector<DHR>]
-
-, Apply=Elem: Node(Apply)
-Prec: [java.lang.Object]
-Desc: []
-
-}
-class Apply {
-
-  Apply()({
-    super(());
-  })::TPH M
-
-}class Lambda {
-
-  TPH X m()({
-    TPH Y lam1;
-    (lam1)::TPH Y = ((TPH Z x) -> ({
-      return (x)::TPH Z;
-    })::TPH AA)::TPH AD;
-    return (lam1)::TPH Y;
-  })::TPH AE
-
-  Lambda()({
-    super(());
-  })::TPH AH
-
-}0 AA: [(AA =. BFC, 1, -1)]
-1 Unifikation: [(AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Z <. AA, 1, 1), (AD <. Y, -1, -1), (Y <. X, -1, -1)]
-1 AA: [(AA =. BFC, 1, -1)]
-2 Unifikation: [(Fun1<Z,BFC> <. Y, , -1), (AD =. Fun1<Z,BFC>, -1), (Z <. BFC, 1, -1), (AA =. BFC, 1, -1), (Y <. X, -1, -1)]
-2 AA: [(AA =. BFC, 1, -1)]
-3 Unifikation: [(Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (Fun1<gen_hv,gen_bf> <. X, , -1), (BFC <. gen_bf, -1, -1), (gen_hv <. Z, 1, 1)]
-3 AA: [(AA =. BFC, 1, -1)]
-4 Unifikation: [(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]
-[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]
-Result1 [[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]]
-Result1 [[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]]
-Result1 [[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]]
-Result1 [[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]]
-RES: [[(gen_ah <. gen_hv, 1, 1), (Z <. BFC, 1, -1), (AD =. Fun1<Z,BFC>, -1), (AA =. BFC, 1, -1), (Y =. Fun1<gen_hv,gen_bf>, -1), (gen_bf <. gen_sr, -1, -1), (BFC <. gen_bf, -1, -1), (X =. Fun1<gen_ah,gen_sr>, -1), (gen_hv <. Z, 1, 1)]]

From 9123e222f4b2bc15b07baf3416e58af027677abd Mon Sep 17 00:00:00 2001
From: JanUlrich <andi@michlaustderaffe.de>
Date: Thu, 28 Jun 2018 16:47:05 +0200
Subject: [PATCH 07/13] =?UTF-8?q?Vector=20TEst=20anf=C3=BCgen?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 test/javFiles/Vector.jav          | 9 +++++++--
 test/typeinference/UnifyTest.java | 7 ++++++-
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/test/javFiles/Vector.jav b/test/javFiles/Vector.jav
index 40072fe4..9d2eadd7 100644
--- a/test/javFiles/Vector.jav
+++ b/test/javFiles/Vector.jav
@@ -1,8 +1,13 @@
-import java.util.Vector;
+import java.util.ArrayList;
+import java.lang.Object;
 
 class MyVector{
 
 id(x){
-  return (x.elementAt(0));
+  Object i;
+  x.add(i);
+  x.add(i);
+  x.add(i);
+  return x;
 }
 }
\ No newline at end of file
diff --git a/test/typeinference/UnifyTest.java b/test/typeinference/UnifyTest.java
index 995890ab..e2e6206c 100644
--- a/test/typeinference/UnifyTest.java
+++ b/test/typeinference/UnifyTest.java
@@ -28,13 +28,18 @@ public class UnifyTest {
     public void finiteClosure() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"fc.jav"));
     }
-    */
 
     @Test
     public void lambda() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"Lambda.jav"));
     }
 
+    */
+    @Test
+    public void vector() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"Vector.jav"));
+    }
+
     /*
     @Test
     public void lambda2() throws IOException, ClassNotFoundException {

From e0c5afcd6da0c8697ba01c497b7bee7ca2cc17d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= <pl@dhbw.de>
Date: Mon, 2 Jul 2018 11:11:29 +0200
Subject: [PATCH 08/13] 	modified:   test/bytecode/javFiles/Lambda.jav 
 modified:   test/javFiles/Vector.jav 	modified:  
 test/typeinference/UnifyTest.java

---
 test/bytecode/javFiles/Lambda.jav |  4 ++--
 test/javFiles/Vector.jav          | 10 ++++++++++
 test/typeinference/UnifyTest.java |  6 ++++--
 3 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/test/bytecode/javFiles/Lambda.jav b/test/bytecode/javFiles/Lambda.jav
index 620440cd..9c68de79 100644
--- a/test/bytecode/javFiles/Lambda.jav
+++ b/test/bytecode/javFiles/Lambda.jav
@@ -7,8 +7,8 @@ public class Lambda {
    var lam1 = (x) -> {
         return x;
    };
-//   return lam1.apply(new Apply());
-   return lam1;
+	return lam1.apply(new Apply());
+   //return lam1;
 //   return new Vector();
   }
 }
diff --git a/test/javFiles/Vector.jav b/test/javFiles/Vector.jav
index 9d2eadd7..5c21cfff 100644
--- a/test/javFiles/Vector.jav
+++ b/test/javFiles/Vector.jav
@@ -1,4 +1,5 @@
 import java.util.ArrayList;
+import java.util.Vector;
 import java.lang.Object;
 
 class MyVector{
@@ -8,6 +9,15 @@ id(x){
   x.add(i);
   x.add(i);
   x.add(i);
+  x.add(i);
+  x.add(i);
+  x.add(i);
+  x.add(i);
+  x.add(i);
+  x.add(i);
+  x.add(i);
+  x.add(i);
+  x.add(i);
   return x;
 }
 }
\ No newline at end of file
diff --git a/test/typeinference/UnifyTest.java b/test/typeinference/UnifyTest.java
index e2e6206c..8ce8c71a 100644
--- a/test/typeinference/UnifyTest.java
+++ b/test/typeinference/UnifyTest.java
@@ -35,10 +35,12 @@ public class UnifyTest {
     }
 
     */
+    /*
     @Test
     public void vector() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"Vector.jav"));
     }
+    */
 
     /*
     @Test
@@ -79,7 +81,7 @@ public class UnifyTest {
     }
  */
  
-    /*
+    
  
     @Test
     public void matrix() throws IOException, ClassNotFoundException {
@@ -87,7 +89,7 @@ public class UnifyTest {
     		//JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+"Matrix.jav"));
     		//compiler.generateBytecode();
     }
-    */
+    
  
 /*    
     @Test

From b8e229cf3fbbab0c7f5c521f7e372a28eec8dd20 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= <pl@dhbw.de>
Date: Mon, 2 Jul 2018 17:24:16 +0200
Subject: [PATCH 09/13] 	modified:  
 ../../src/de/dhbwstuttgart/typeinference/unify/RuleSet.java 	modified:  
 ../../src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java 
 modified:   ../../src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java
 	modified:  
 ../../src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java 
 modified:   ../javFiles/Matrix.jav

---
 .../typeinference/unify/RuleSet.java          |  4 +-
 .../typeinference/unify/TypeUnifyTask.java    | 38 ++++++++++++++++---
 .../typeinference/unify/model/Unifier.java    |  2 +-
 .../typeinference/unify/model/UnifyPair.java  | 19 +++++++++-
 test/javFiles/Matrix.jav                      |  6 +--
 5 files changed, 57 insertions(+), 12 deletions(-)

diff --git a/src/de/dhbwstuttgart/typeinference/unify/RuleSet.java b/src/de/dhbwstuttgart/typeinference/unify/RuleSet.java
index b40dee30..6c3cfaad 100644
--- a/src/de/dhbwstuttgart/typeinference/unify/RuleSet.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/RuleSet.java
@@ -938,7 +938,9 @@ public class RuleSet implements IRuleSet{
 		else {
 			UnifyType freshTph = PlaceholderType.freshPlaceholder();
 			result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
-			result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+			Set<UnifyType> fBounded = pair.getfBounded();
+			fBounded.add(lhsType);
+			result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair(), fBounded));
 		}
 		
 		return Optional.of(result);
diff --git a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
index 0545fb95..1519faa5 100644
--- a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
@@ -13,6 +13,7 @@ import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.RecursiveTask;
+import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -447,6 +448,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			System.out.print("");
 		if (nextSetasList.iterator().next().stream().filter(x -> x.getLhsType().getName().equals("D")).findFirst().isPresent() && nextSetasList.size()>1) 
 			System.out.print("");
+		writeLog("nextSetasList: " + nextSetasList.toString());
 		while (nextSetasList.size() > 0) {  //(nextSetasList.size() != 0) {
 			Set<UnifyPair> a = null;
 			if (variance == 1) {
@@ -488,6 +490,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			Set<Set<UnifyPair>> elems = new HashSet<Set<UnifyPair>>(fstElems);
 			elems.add(a);
 			//if (remainingSets.isEmpty()) {//muss immer gegeben sein, weil nur 1 Element der topLevelSets mehr als ein Elemet enthaelt
+				writeLog("Vor unify2 Aufruf: " + eq.toString());
 				Set<Set<UnifyPair>> res = unify2(elems, eq, fc, parallel);
 				if (!isUndefinedPairSetSet(res) && isUndefinedPairSetSet(result)) {
 					//wenn korrektes Ergebnis gefunden alle Fehlerfaelle loeschen
@@ -512,7 +515,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			//else {//duerfte gar nicht mehr vorkommen PL 2018-04-03
 				//result.addAll(computeCartesianRecursive(elems, remainingSets, eq, fc, parallel)); 
 			//}
-			
+				
+			/* auskommentiert um alle Loesungen zu bekommen ANFANG
 			if (!result.isEmpty() && !isUndefinedPairSetSet(res)) {
 				if (nextSetasList.iterator().hasNext() && nextSetasList.iterator().next().stream().filter(x -> x.getLhsType().getName().equals("D")).findFirst().isPresent() && nextSetasList.size()>1) 
 					System.out.print("");
@@ -582,6 +586,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			//	result.removeIf(y -> isUndefinedPairSet(y));
 			//}
 			//else result.stream().filter(y -> !isUndefinedPairSet(y));
+			 * auskommentiert um alle Loesungen zu bekommen ENDE
+			 */
 		}
 		return result;
 	}
@@ -1094,7 +1100,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		UnifyType supAPrime = new SuperType(aPrime);
 		UnifyType thetaPrime = subThetaPrime.getSuperedType();
 		Set<UnifyPair> resultPrime = new HashSet<>();
-		resultPrime.add(new UnifyPair(thetaPrime, a, PairOperator.SMALLERDOT, pair.getSubstitution(), pair));
+		resultPrime.add(new UnifyPair(thetaPrime, a, PairOperator.SMALLERDOT, pair.getSubstitution(), pair, pair.getfBounded()));
 		result.add(resultPrime);
 		//writeLog(resultPrime.toString());
 			
@@ -1124,14 +1130,34 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				break;
 			}
 		
-		for(UnifyType thetaS : fc.greater(theta, new HashSet<>())) {
+		for(UnifyType thetaS : fc.greater(theta, pair.getfBounded())) {
 			Set<UnifyPair> resultPrime = new HashSet<>();
+			Match match = new Match();
 			
 			UnifyType[] freshTphs = new UnifyType[thetaS.getTypeParams().size()];
 			for(int i = 0; !allGen && i < freshTphs.length; i++) {
 				freshTphs[i] = PlaceholderType.freshPlaceholder();
 				((PlaceholderType)freshTphs[i]).setVariance(((PlaceholderType)a).getVariance());
-				resultPrime.add(new UnifyPair(thetaS.getTypeParams().get(i), freshTphs[i], PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair));
+				Set<UnifyType> fBounded = pair.getfBounded();
+			
+				int i_ef = i;
+				BiFunction<Boolean,UnifyType,Boolean> f = (x,y) -> 
+				{
+					ArrayList<UnifyPair> termList = new ArrayList<UnifyPair>();
+				    termList.add(new UnifyPair(y,t.getTypeParams().get(i_ef), PairOperator.EQUALSDOT));
+				    return ((match.match(termList).isPresent()) || x);
+				};
+				//if (parai.getName().equals("java.lang.Integer")) {
+				//	System.out.println("");
+				//}
+				BinaryOperator<Boolean> bo = (x,y) -> (x || y);
+				if (fBounded.stream().reduce(false,f,bo)) {
+					resultPrime.add(new UnifyPair(thetaS.getTypeParams().get(i), freshTphs[i], PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
+				}
+				else {
+					fBounded.add(theta);
+					resultPrime.add(new UnifyPair(thetaS.getTypeParams().get(i), freshTphs[i], PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair, fBounded));
+				}	
 			}
 			
 			if(allGen)
@@ -1165,9 +1191,9 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		((PlaceholderType)freshTph).setVariance(a.getVariance());
 		resultPrime = new HashSet<>();
 		resultPrime.add(new UnifyPair(a, new ExtendsType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
-		resultPrime.add(new UnifyPair(theta, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair));
+		resultPrime.add(new UnifyPair(theta, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair, pair.getfBounded()));
 		result.add(resultPrime);
-		//writeLog(resultPrime.toString());
+		writeLog("resultPrime: " + resultPrime.toString());
 
 		resultPrime = new HashSet<>();
 		resultPrime.add(new UnifyPair(a, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
diff --git a/src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java b/src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java
index 8f594844..f2bc5277 100644
--- a/src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java
@@ -102,7 +102,7 @@ public class Unifier implements Function<UnifyType, UnifyType>, Iterable<Entry<P
 			}
 			return new UnifyPair(newLhs, newRhs, p.getPairOp(), suniUnifyPair, p);
 		}
-		return new UnifyPair(newLhs, newRhs, p.getPairOp(), p.getSubstitution(), p.getBasePair());
+		return new UnifyPair(newLhs, newRhs, p.getPairOp(), p.getSubstitution(), p.getBasePair(), p.getfBounded());
 	}
 	
 	/**
diff --git a/src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java b/src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java
index 19dee99f..848e7fdd 100644
--- a/src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java
@@ -50,6 +50,13 @@ public class UnifyPair {
      * PL 2018-03-15
      */
     private UnifyPair basePair;
+    
+    /**
+     * For pairs a <. Theta generated in the rule reduceTphSup
+     * to store the f-Bouned Elements to avoid endless recursion 
+     * PL 2018-03-15
+     */
+    private Set<UnifyType> fBounded = new HashSet<>();
 	
 	private final int hashCode;
 	
@@ -82,6 +89,12 @@ public class UnifyPair {
 		hashCode = 17 + 31 * lhs.hashCode() + 31 * rhs.hashCode() + 31 * pairOp.hashCode();
 	}	
 	
+	public UnifyPair(UnifyType lhs, UnifyType rhs, PairOperator op, Set<UnifyPair> uni, UnifyPair base, Set<UnifyType> fBounded) {
+		this(lhs, rhs, op, uni, base);
+		
+		this.fBounded = fBounded;
+	}
+		
 	/**
 	 * Returns the type on the left hand side of the pair.
 	 */
@@ -138,6 +151,10 @@ public class UnifyPair {
 		return lhs.wrongWildcard() || rhs.wrongWildcard();
 	}
 	
+	public Set<UnifyType> getfBounded() {
+		return this.fBounded;
+	}
+	
 	@Override
 	public boolean equals(Object obj) {
 		if(!(obj instanceof UnifyPair))
@@ -177,7 +194,7 @@ public class UnifyPair {
 		if (rhs instanceof PlaceholderType) {
 			ret = ret + ", " + new Integer(((PlaceholderType)rhs).getVariance()).toString();
 		}
-		return "(" + lhs + " " + pairOp + " " + rhs + ", " + ret + ")";
+		return "(" + lhs + " " + pairOp + " " + rhs + ", " + ret + ", [" + getfBounded().toString()+ "])";
 	}
 
 	/*
diff --git a/test/javFiles/Matrix.jav b/test/javFiles/Matrix.jav
index 4c55c410..18120deb 100644
--- a/test/javFiles/Matrix.jav
+++ b/test/javFiles/Matrix.jav
@@ -15,9 +15,9 @@ class Matrix extends Vector<Vector<Integer>> {
                 var erg = 0;
                 var k = 0;
                 while(k < v1.size()) {
-                  erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
-                  //  erg = add1(erg, mul1(v1.elementAt(k),
-                  //           m.elementAt(k).elementAt(j)));
+                  //erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
+                    erg = add1(erg, mul1(v1.elementAt(k),
+                             m.elementAt(k).elementAt(j)));
                     k++; }
                 v2.addElement(new Integer(erg));
                 j++; }

From 69706ee1d22b043515bf81cff1dbd29577605daf Mon Sep 17 00:00:00 2001
From: Fayez Abu Alia <fayez@eduroam021.uni-tuebingen.de>
Date: Tue, 3 Jul 2018 11:15:58 +0200
Subject: [PATCH 10/13] Bug 82 gefixt und getestet. Descriptor von MethodCall
 von Interface korrigiert.

---
 src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java  |  4 ++--
 .../bytecode/descriptor/DescriptorToString.java       |  4 ++--
 .../bytecode/utilities/MethodFromMethodCall.java      | 11 +++++++++--
 test/bytecode/javFiles/Lambda.jav                     |  4 ++--
 4 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java b/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
index b5486df7..6b6cab17 100644
--- a/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
+++ b/src/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
@@ -658,13 +658,13 @@ public class BytecodeGenMethod implements StatementVisitor {
 		methodCall.arglist.accept(this);
 
 		MethodFromMethodCall method = new MethodFromMethodCall(methodCall.arglist, methodCall.getType(),
-				genericsAndBoundsMethod, genericsAndBounds);
+				receiverName, genericsAndBoundsMethod, genericsAndBounds);
 		String mDesc = method.accept(new DescriptorToString(resultSet));
 		System.out.println("Methodcall Desc : " + mDesc);
 		// is methodCall.receiver functional Interface)?
 		if (varsFunInterface.contains(methodCall.receiver.getType())) {
 			mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, getResolvedType(methodCall.receiver.getType()), methodCall.name,
-					mDesc, false);
+					mDesc, true);
 		} else {
 			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, getResolvedType(methodCall.receiver.getType()), methodCall.name,
 					mDesc, isInterface);
diff --git a/src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java b/src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java
index 2b9bb931..d92efe5a 100644
--- a/src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java
+++ b/src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java
@@ -172,7 +172,7 @@ public class DescriptorToString implements DescriptorVisitor{
 		for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
 			String d = resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor());
 			
-			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")) {
 				desc += "L"+Type.getInternalName(Object.class)+ ";";
 			}else {
 				if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
@@ -189,7 +189,7 @@ public class DescriptorToString implements DescriptorVisitor{
 		System.out.println("DescriptorToString retType = " + retType);
 		if(retType.equals("void")) {
 			desc += ")V";
-		}else if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
+		}else if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")){
 			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
 			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(retType)) {
diff --git a/src/de/dhbwstuttgart/bytecode/utilities/MethodFromMethodCall.java b/src/de/dhbwstuttgart/bytecode/utilities/MethodFromMethodCall.java
index cd8f5372..2028c772 100644
--- a/src/de/dhbwstuttgart/bytecode/utilities/MethodFromMethodCall.java
+++ b/src/de/dhbwstuttgart/bytecode/utilities/MethodFromMethodCall.java
@@ -9,13 +9,16 @@ import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 public class MethodFromMethodCall {
 	private ArgumentList argList;
 	private RefTypeOrTPHOrWildcardOrGeneric returnType;
+	private String receiverName;
 	private HashMap<String, String> genericsAndBoundsMethod;
 	private HashMap<String,String> genericsAndBounds;
 	
-	public MethodFromMethodCall(ArgumentList argList,RefTypeOrTPHOrWildcardOrGeneric returnType,
-			HashMap<String, String> genericsAndBoundsMethod,HashMap<String,String> genericsAndBounds) {
+	public MethodFromMethodCall(ArgumentList argList,RefTypeOrTPHOrWildcardOrGeneric returnType, 
+			String receiverName, HashMap<String, String> genericsAndBoundsMethod,
+			HashMap<String,String> genericsAndBounds) {
 		this.argList = argList;
 		this.returnType = returnType;
+		this.receiverName = receiverName;
 		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
 		this.genericsAndBounds = genericsAndBounds;
 	}
@@ -28,6 +31,10 @@ public class MethodFromMethodCall {
 		return returnType;
 	}
 	
+	public String getReceiverName() {
+		return receiverName;
+	}
+	
 	public HashMap<String, String> getGenericsAndBoundsMethod(){
 		return genericsAndBoundsMethod;
 	}
diff --git a/test/bytecode/javFiles/Lambda.jav b/test/bytecode/javFiles/Lambda.jav
index 620440cd..e23ffa45 100644
--- a/test/bytecode/javFiles/Lambda.jav
+++ b/test/bytecode/javFiles/Lambda.jav
@@ -7,8 +7,8 @@ public class Lambda {
    var lam1 = (x) -> {
         return x;
    };
-//   return lam1.apply(new Apply());
-   return lam1;
+   return lam1.apply(new Apply());
+//   return lam1;
 //   return new Vector();
   }
 }

From bc1a796e2891f7a0fc2559b4cdb8dcbdbc9bad53 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= <pl@dhbw.de>
Date: Tue, 3 Jul 2018 11:54:24 +0200
Subject: [PATCH 11/13] 	modified:  
 ../../src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java

---
 .../typeinference/unify/TypeUnifyTask.java    | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
index 1519faa5..69b1246b 100644
--- a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
@@ -145,12 +145,12 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	 * @return The set of all principal type unifiers
 	 */
 	protected Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc, boolean parallel)  {
-		Set<UnifyPair> aas = eq.stream().filter(x -> x.getLhsType().getName().equals("AA") //&& x.getPairOp().equals(PairOperator.SMALLERDOT)
-				).collect(Collectors.toCollection(HashSet::new));
-		writeLog(nOfUnify.toString() + " AA: " + aas.toString());
-		if (aas.isEmpty()) {
-			System.out.println("");
-		}
+		//Set<UnifyPair> aas = eq.stream().filter(x -> x.getLhsType().getName().equals("AA") //&& x.getPairOp().equals(PairOperator.SMALLERDOT)
+		//		).collect(Collectors.toCollection(HashSet::new));
+		//writeLog(nOfUnify.toString() + " AA: " + aas.toString());
+		//if (aas.isEmpty()) {
+		//	System.out.println("");
+		//}
 		/*
 		 * Step 1: Repeated application of reduce, adapt, erase, swap 
 		 */
@@ -490,7 +490,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			Set<Set<UnifyPair>> elems = new HashSet<Set<UnifyPair>>(fstElems);
 			elems.add(a);
 			//if (remainingSets.isEmpty()) {//muss immer gegeben sein, weil nur 1 Element der topLevelSets mehr als ein Elemet enthaelt
-				writeLog("Vor unify2 Aufruf: " + eq.toString());
+				//writeLog("Vor unify2 Aufruf: " + eq.toString());
 				Set<Set<UnifyPair>> res = unify2(elems, eq, fc, parallel);
 				if (!isUndefinedPairSetSet(res) && isUndefinedPairSetSet(result)) {
 					//wenn korrektes Ergebnis gefunden alle Fehlerfaelle loeschen
@@ -1144,7 +1144,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				BiFunction<Boolean,UnifyType,Boolean> f = (x,y) -> 
 				{
 					ArrayList<UnifyPair> termList = new ArrayList<UnifyPair>();
-				    termList.add(new UnifyPair(y,t.getTypeParams().get(i_ef), PairOperator.EQUALSDOT));
+				    termList.add(new UnifyPair(y,thetaS.getTypeParams().get(i_ef), PairOperator.EQUALSDOT));
 				    return ((match.match(termList).isPresent()) || x);
 				};
 				//if (parai.getName().equals("java.lang.Integer")) {
@@ -1155,7 +1155,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					resultPrime.add(new UnifyPair(thetaS.getTypeParams().get(i), freshTphs[i], PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
 				}
 				else {
-					fBounded.add(theta);
+					fBounded.add(thetaS.getTypeParams().get(i));
 					resultPrime.add(new UnifyPair(thetaS.getTypeParams().get(i), freshTphs[i], PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair, fBounded));
 				}	
 			}
@@ -1193,7 +1193,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		resultPrime.add(new UnifyPair(a, new ExtendsType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
 		resultPrime.add(new UnifyPair(theta, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair, pair.getfBounded()));
 		result.add(resultPrime);
-		writeLog("resultPrime: " + resultPrime.toString());
+		//writeLog("resultPrime: " + resultPrime.toString());
 
 		resultPrime = new HashSet<>();
 		resultPrime.add(new UnifyPair(a, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair));

From 1a2454e00bbde7790bd1e0796630bddcc886dec5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= <pl@dhbw.de>
Date: Wed, 4 Jul 2018 11:47:02 +0200
Subject: [PATCH 12/13] 	modified:  
 src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java Kommentare zur
 Max Min optimierung rasugenommen

---
 src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
index 69b1246b..e38e1443 100644
--- a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
@@ -516,7 +516,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				//result.addAll(computeCartesianRecursive(elems, remainingSets, eq, fc, parallel)); 
 			//}
 				
-			/* auskommentiert um alle Loesungen zu bekommen ANFANG
+			/* auskommentiert um alle Max und min Betrachtung auszuschalten ANFANG */
 			if (!result.isEmpty() && !isUndefinedPairSetSet(res)) {
 				if (nextSetasList.iterator().hasNext() && nextSetasList.iterator().next().stream().filter(x -> x.getLhsType().getName().equals("D")).findFirst().isPresent() && nextSetasList.size()>1) 
 					System.out.print("");
@@ -546,6 +546,8 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				}
 				}
 			}
+			 /* auskommentiert um alle Max und min Betrachtung auszuschalten ENDE */ 
+			 
 			if (isUndefinedPairSetSet(res)) {
 				Set<UnifyPair> abhSubst = res.stream()
 							   .map(b -> 
@@ -586,8 +588,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			//	result.removeIf(y -> isUndefinedPairSet(y));
 			//}
 			//else result.stream().filter(y -> !isUndefinedPairSet(y));
-			 * auskommentiert um alle Loesungen zu bekommen ENDE
-			 */
 		}
 		return result;
 	}

From f1f34a6733ea43f74d4f49d524f0273042339e05 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= <pl@dhbw.de>
Date: Wed, 4 Jul 2018 12:07:11 +0200
Subject: [PATCH 13/13] 	modified:   test/javFiles/Matrix.jav

---
 test/javFiles/Matrix.jav | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/javFiles/Matrix.jav b/test/javFiles/Matrix.jav
index 18120deb..5e1eac08 100644
--- a/test/javFiles/Matrix.jav
+++ b/test/javFiles/Matrix.jav
@@ -15,9 +15,9 @@ class Matrix extends Vector<Vector<Integer>> {
                 var erg = 0;
                 var k = 0;
                 while(k < v1.size()) {
-                  //erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
-                    erg = add1(erg, mul1(v1.elementAt(k),
-                             m.elementAt(k).elementAt(j)));
+                  erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
+                  //erg = add1(erg, mul1(v1.elementAt(k),
+                  //           m.elementAt(k).elementAt(j)));
                     k++; }
                 v2.addElement(new Integer(erg));
                 j++; }