Merge branch 'bcGenerics' of ssh://abualia@gohorb.ba-horb.de/bahome/projekt/git/JavaCompilerCore into bcGenerics

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

@@ -90,7 +90,8 @@ public class TPHExtractor extends AbstractASTWalker {
 //				}
 //			}
 
-			resultSet.resolveType(tph).additionalGenerics.forEach(ag -> {
+			//resultSet.resolveType(tph).getAdditionalGenerics().forEach(ag -> {
+			resultSet.genIns.forEach(ag -> {
 
 //				if (ag.contains(resolvedTPH) /* && ag.TA1.equals(resolvedTPH) */ && !contains(allPairs, ag)) {
 					if (inMethod)

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

@@ -235,7 +235,8 @@ public class Signature {
 			
 			RefTypeOrTPHOrWildcardOrGeneric resolved = resType.resolvedType;
 			if(resolved instanceof TypePlaceholder) {
-				resType.additionalGenerics.forEach(ag ->{
+				//resType.getAdditionalGenerics().forEach(ag ->{
+				resultSet.genIns.forEach(ag ->{
 					TPHConstraint constr = new ExtendsConstraint(ag.TA1.getName(), ag.TA2.getName(), Relation.EXTENDS);
 					if(!contains(res,constr)) {
 						res.add(constr);
@@ -246,7 +247,8 @@ public class Signature {
 				WildcardType resWC = (WildcardType) resolved;
 				ResolvedType resType2 = resultSet.resolveType(resWC.getInnerType());
 				if(resType2.resolvedType instanceof TypePlaceholder) {
-					resType2.additionalGenerics.forEach(ag ->{
+					//resType2.getAdditionalGenerics().forEach(ag ->{
+					resultSet.genIns.forEach(ag ->{
 						TPHConstraint constr = new ExtendsConstraint(ag.TA1.getName(), ag.TA2.getName(), Relation.EXTENDS);
 						if(!contains(res,constr)) {
 							res.add(constr);

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

@@ -52,11 +52,12 @@ import java.util.stream.Stream;
 
 import org.antlr.v4.parse.ANTLRParser.throwsSpec_return;
 import org.apache.commons.io.output.NullOutputStream;
+//import org.apache.commons.io.output.NullOutputStream;
 
 public class JavaTXCompiler {
 
     final CompilationEnvironment environment;
-    Boolean resultmodel = true;
+    Boolean resultmodel = false;
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
     Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"src/test/java/logFiles" geschrieben werden soll?
     
@@ -296,13 +297,14 @@ public class JavaTXCompiler {
 
         final ConstraintSet<Pair> cons = getConstraints();
         Set<Set<UnifyPair>> results = new HashSet<>();
-        UnifyResultModel urm = new UnifyResultModel();
+        UnifyResultModel urm = null;
-        urm.addUnifyResultListener(resultListener);
+        //urm.addUnifyResultListener(resultListener);
         try {
         	logFile = logFile == null ? new FileWriter(new File("log_"+sourceFiles.keySet().iterator().next().getName())) : logFile;
-
 			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile);
 			System.out.println(finiteClosure);
+			urm = new UnifyResultModel(cons, finiteClosure);
+			urm.addUnifyResultListener(resultListener);
 			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
 			
 			Function<UnifyPair, UnifyPair> distributeInnerVars = 
@@ -414,7 +416,7 @@ public class JavaTXCompiler {
 				}
 				return ret;
 			}).collect(Collectors.toCollection(ArrayList::new));
-			unify.unifyAsync(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons, urm);
+			unify.unifyAsync(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm);
         }
     	catch (IOException e) { 
         	System.err.println("kein LogFile");
@@ -434,9 +436,8 @@ public class JavaTXCompiler {
         final ConstraintSet<Pair> cons = getConstraints();
         Set<Set<UnifyPair>> results = new HashSet<>();
         try {
-			Writer logFile = new OutputStreamWriter(new NullOutputStream());
+			Writer logFile = //new OutputStreamWriter(new NullOutputStream());
-				//new FileWriter(new File("log_"+sourceFiles.keySet().iterator().next().getName()));	
+				new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName()));	
-			
 			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile);
 			System.out.println(finiteClosure);
 			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
@@ -552,10 +553,10 @@ public class JavaTXCompiler {
 			}).collect(Collectors.toCollection(ArrayList::new));
 			if (resultmodel) {
 				/* UnifyResultModel Anfang */
-				UnifyResultModel urm = new UnifyResultModel();
+				UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
 				UnifyResultListenerImpl li = new UnifyResultListenerImpl();
 				urm.addUnifyResultListener(li);
-				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons, urm);
+				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm);
 				System.out.println("RESULT Final: " + li.getResults());
 				logFile.write("RES_FINAL: " + li.getResults().toString()+"\n");
 				logFile.flush();
@@ -563,8 +564,8 @@ public class JavaTXCompiler {
 			}
 			/* UnifyResultModel End */
 			else {
-				Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons);
+				//Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons, finiteClosure));
-				//Set<Set<UnifyPair>> result = unify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons);
+				Set<Set<UnifyPair>> result = unify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons, finiteClosure));
 				System.out.println("RESULT: " + result);
 				logFile.write("RES: " + result.toString()+"\n");
 				logFile.flush();

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

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

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

@@ -68,9 +68,6 @@ public class UnifyTypeFactory {
     public static UnifyType convert(RefTypeOrTPHOrWildcardOrGeneric t, Boolean innerType){
         if(t instanceof GenericRefType){
             return UnifyTypeFactory.convert((GenericRefType)t, innerType);
-        }else
-        if(t instanceof FunN){
-            return UnifyTypeFactory.convert((FunN)t, innerType);
         }else if(t instanceof TypePlaceholder){
             return UnifyTypeFactory.convert((TypePlaceholder)t, innerType);
         }else if(t instanceof ExtendsWildcardType){
@@ -86,13 +83,13 @@ public class UnifyTypeFactory {
 
     public static UnifyType convert(RefType t, Boolean innerType){
         //Check if it is a FunN Type:
-        Pattern p = Pattern.compile("Fun(\\d+)");
+        Pattern p = Pattern.compile("Fun(\\d+)[$][$]");
         Matcher m = p.matcher(t.getName().toString());
         boolean b = m.matches();
         if(b){
             Integer N = Integer.valueOf(m.group(1));
             if((N + 1) == t.getParaList().size()){
-                return convert(new FunN(t.getParaList()), false);
+                return convertFunN(t.getParaList(), false);
             }
         }
         UnifyType ret;
@@ -108,11 +105,11 @@ public class UnifyTypeFactory {
         return ret;
     }
 
-    public static UnifyType convert(FunN t, Boolean innerType){
+    public static UnifyType convertFunN(List<RefTypeOrTPHOrWildcardOrGeneric> paraList, Boolean innerType){
         UnifyType ret;
         List<UnifyType> params = new ArrayList<>();
-        if(t.getParaList() != null && t.getParaList().size() > 0){
+        if(paraList != null && paraList.size() > 0){
-            for(RefTypeOrTPHOrWildcardOrGeneric pT : t.getParaList()){
+            for(RefTypeOrTPHOrWildcardOrGeneric pT : paraList){
                 params.add(UnifyTypeFactory.convert(pT, false));
             }
         }
@@ -239,7 +236,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;
     }
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -13,6 +13,7 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import com.google.common.collect.Ordering;
@@ -657,11 +658,16 @@ implements IFiniteClosure  {
 		if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
 			System.out.println("");
 		/*
+		pairop = PairOperator.SMALLERDOTWC;
 		List<UnifyType> al = new ArrayList<>();
 		PlaceholderType xx =new PlaceholderType("xx");
 		al.add(xx);
 		left = new ExtendsType(new ReferenceType("Vector", new TypeParams(al)));
-		right = new ReferenceType("Vector", new TypeParams(new ArrayList<>(al)));
+		
+		List<UnifyType> alr = new ArrayList<>();
+		UnifyType exx = new ExtendsType(xx);
+		alr.add(exx);
+		right = new ExtendsType(new ReferenceType("Vector", new TypeParams(alr)));
 		*/
 		/*
 		List<UnifyType> al = new ArrayList<>();
@@ -712,8 +718,13 @@ implements IFiniteClosure  {
 		}
 		catch (IOException e) {
 			System.err.println("no LogFile");}}
-		//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok. 
+		//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok.
-		long smallerLen = smallerRes.stream().filter(x -> !(x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType)).count();
+		Predicate<UnifyPair> delFun = x -> !((x.getLhsType() instanceof PlaceholderType || 
+											 x.getRhsType() instanceof PlaceholderType)
+								 			 && !((x.getLhsType() instanceof WildcardType) &&   //? extends/super a <.? a 
+													 ((WildcardType)x.getLhsType()).getWildcardedType().equals(x.getRhsType()))
+											 );
+		long smallerLen = smallerRes.stream().filter(delFun).count();
 		if (smallerLen == 0) return -1;
 		else {
 			up = new UnifyPair(right, left, pairop);
@@ -729,7 +740,7 @@ implements IFiniteClosure  {
 			catch (IOException e) {
 				System.err.println("no LogFile");}}
 			//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok. 
-			long greaterLen = greaterRes.stream().filter(x -> !(x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType)).count();
+			long greaterLen = greaterRes.stream().filter(delFun).count();
 			if (greaterLen == 0) return 1;
 			else return 0;
 		}	

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

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

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

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

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

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

src/test/java/logFiles/.gitignore

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

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

@@ -1,6 +1,7 @@
 public class Id {
 	
-	<A> id(A b){
+	id(b){
 		return b;
 	}
-}
+}
+

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

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

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

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

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

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

src/test/resources/javFiles/Faculty.jav

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

src/test/resources/javFiles/mathStruc.jav

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