Remove not used isInherited

modified:   src/test/java/insertGenerics/FamilyOfGeneratedGenericsTest.java

pom.xml

@@ -118,7 +118,15 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 					</descriptorRefs>
 				</configuration>
 			</plugin>
-		</plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>9</source>
+                    <target>9</target>
+                </configuration>
+            </plugin>
+        </plugins>
 	</build>
 	<repositories>
 		<repository>

src/main/java/de/dhbwstuttgart/bytecode/insertGenerics/FamilyOfGeneratedGenerics.java

@@ -1,9 +1,9 @@
 package de.dhbwstuttgart.bytecode.insertGenerics;
 
+import com.ibm.icu.text.CurrencyMetaInfo;
 import de.dhbwstuttgart.bytecode.TPHExtractor;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
-import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericsGeneratorResult;
 import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 
 import java.util.ArrayList;
@@ -17,6 +17,7 @@ public class FamilyOfGeneratedGenerics {
     public List<ClassConstraint> classConstraints = new ArrayList<>();
     public List<MethodConstraint> methodConstraints = new ArrayList<>();
 
+
     public FamilyOfGeneratedGenerics(TPHExtractor tphExtractor) {
         this.allConstraints = tphExtractor.allCons;
         this.posOfTPHs = positionConverter(tphExtractor.allTPHS, tphExtractor.ListOfMethodsAndTph);
@@ -47,21 +48,35 @@ public class FamilyOfGeneratedGenerics {
         return cs_cl;
     }
 
-    public static List<MethodConstraint> getMethodConstraintsAlternative() {
+    public static List<MethodConstraint> getMethodConstraints(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
-        List<GenericsGeneratorResult> ggRes = GenericsGeneratorResult.
-        return null;
-    }
-
-    public static List<MethodConstraint> getMethodConstraints(List<TPHConstraint> cs, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
         //TODO: Regeln
         List<MethodConstraint> cs_m = new ArrayList<>();
-        List<MethodConstraint> methodConstraints1 = typeOfTheMethodInClSigma(cs, cs_m, posOfTphs);
+        List<MethodConstraint> methodConstraints1 = typeOfTheMethodInClSigma(cs, posOfTphs);
         for (MethodConstraint cons: methodConstraints1) {
             if (!checkForDuplicates(cons, cs_m)) {
                 cs_m.add(cons);
             }
         }
-        List<MethodConstraint> methodConstraints2 = firstTransitiveSubtypeForMethodTypes();
+        List<MethodConstraint> methodConstraints2 = firstTransitiveSubtypeForMethodTypes(cs, cs_m);
+        for (MethodConstraint cons: methodConstraints2) {
+            if (!checkForDuplicates(cons, cs_m)) {
+                cs_m.add(cons);
+            }
+        }
+        List<MethodConstraint> methodConstraints3 = secondTransitiveSubtypeForMethodTypes(cs, cs_cl, cs_m);
+        for (MethodConstraint cons: methodConstraints3) {
+            if (!checkForDuplicates(cons, cs_m)) {
+                cs_m.add(cons);
+            }
+        }
+        List<MethodConstraint> methodConstraints4 = hasNoSupertypeForMethodTypes(cs, posOfTphs);
+        for (MethodConstraint cons: methodConstraints4) {
+            if (!checkForDuplicates(cons, cs_m)) {
+                cs_m.add(cons);
+            }
+        }
+        List<MethodConstraint> methodConstraints5 = methodTypesWithoutClassTypes(cs_cl, cs_m);
+        cs_m = methodConstraints5;
         return cs_m;
     }
 
@@ -136,83 +151,79 @@ public class FamilyOfGeneratedGenerics {
         return tempCC;
     }
 
-    public static boolean checkUpperBound(List<TPHConstraint> cs, String tph) {
+    /**
-        for(int i=0; i<cs.size(); i++) {
-            if(cs.get(i).getLeft() == tph) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-/**
      * Def. FGG: erste Zeile von cs_m
      * {T < .T' | T is a type variable in a type of the method/constructor m in cl_\sigma, (T <. T') \in cs}
      */
-
+    public static List<MethodConstraint> typeOfTheMethodInClSigma(List<TPHConstraint> allConstraints, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) { // cl_\sigma??
-    public static List<MethodConstraint> typeOfTheMethodInClSigma(List<TPHConstraint> allConstraints, List<MethodConstraint> cs_m, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) { // cl_\sigma??
         //TODO:
-        List<MethodConstraint> tempCC= new ArrayList<>();
+        List<MethodConstraint> tempMC= new ArrayList<>();
         for(TPHConstraint allCons: allConstraints){
             if(posOfTphs.containsKey(allCons.getLeft()) && allCons.getRight()!=null && allCons.getRel()==Relation.EXTENDS) {
                 for(String tph: posOfTphs.keySet()) {
                     if(tph == allCons.getLeft() && (posOfTphs.get(tph).fst == PositionFinder.Position.METHOD || posOfTphs.get(tph).fst == PositionFinder.Position.CONSTRUCTOR)) {
                         MethodConstraint consToAdd = new MethodConstraint(allCons.getLeft(), allCons.getRight(), allCons.getRel());
-                        if (!checkForDuplicates(consToAdd, tempCC)) {
+                        if (!checkForDuplicates(consToAdd, tempMC)) {
-                            tempCC.add(consToAdd);
+                            tempMC.add(consToAdd);
                         }
                     }
                 }
             }
         }
-        return tempCC;
+        return tempMC;
     }
 
 
-/**
+    /**
      * Def. FGG: zweite Zeile von cs_m
      * {R' <. S | (R <. R'), (S <. S') \in cs_m and (R',S) is in the transitive closure of cs}
      */
-
+    public static List<MethodConstraint> firstTransitiveSubtypeForMethodTypes(List<TPHConstraint> allConstraints, List<MethodConstraint> cs_m) { //transitive closure of cs
-    public static List<MethodConstraint> firstTransitiveSubtypeForMethodTypes(List<TPHConstraint> allConstraints, List<MethodConstraint> cs_m, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) { //transitive closure of cs
         //TODO:
-        List<MethodConstraint> tempCC= new ArrayList<>();
+        List<MethodConstraint> tempMC= new ArrayList<>();
         List<TPHConstraint> tcOfCs =  buildTransitiveClosure(allConstraints);
-        for(MethodConstraint mC1 : cs_m) {
+        for(MethodConstraint mC1 : cs_m) {          //(R <. R')
-            for(MethodConstraint mC2 : cs_m) {
+            for(MethodConstraint mC2 : cs_m) {      //(S <. S')
-                String rightSide = mC1.getRight();
+                String lSide = mC1.getRight();      //R'
-                String leftSide = mC2.getLeft();
+                String rSide = mC2.getLeft();       //S
                 for(TPHConstraint tphC : tcOfCs) {
-                    if(tphC.getLeft().equals(leftSide)&&tphC.getRight().equals(rightSide)) {
+                    if(tphC.getLeft().equals(lSide)&&tphC.getRight().equals(rSide)) { //is it (R',S)
-                        tempCC.add((MethodConstraint) tphC);
+                        MethodConstraint consToAdd = new MethodConstraint(lSide, rSide, tphC.getRel()); //create (R'<.S)
+                        if (!checkForDuplicates(consToAdd, tempMC)) {
+                            tempMC.add(consToAdd);
+                        }
                     }
                 }
             }
         }
-        return tempCC;
+        return tempMC;
     }
 
-/**
+    /**
      * Def. FGG: dritte Zeile von cs_m
      * {R' <. S | (R <. R') \in cs_m, (S <. S') \in cs_cl and (R',S) is in the transitive closure of cs}
      */
-
+    public static List<MethodConstraint> secondTransitiveSubtypeForMethodTypes(List<TPHConstraint> allConstraints, List<ClassConstraint> cs_cl, List<MethodConstraint> cs_m) {
-    public static List<MethodConstraint> secondTransitiveSubtypeForMethodTypes(List<TPHConstraint> allConstraints, List<ClassConstraint> cs_cl, List<MethodConstraint> cs_m, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
         //TODO:
-        List<MethodConstraint> tempCC= new ArrayList<>();
+        List<MethodConstraint> tempMC= new ArrayList<>();
         List<TPHConstraint> tcOfCs =  buildTransitiveClosure(allConstraints);
         for(ClassConstraint cC : cs_cl) {
             for(MethodConstraint mC : cs_m) {
-                String rightSide = mC.getRight();
+                String leftSide = mC.getRight();
-                String leftSide = cC.getLeft();
+                String rightSide = cC.getLeft();
                 for(TPHConstraint tphC : tcOfCs) {
                     if(tphC.getLeft().equals(leftSide)&&tphC.getRight().equals(rightSide)) {
-                        tempCC.add((MethodConstraint) tphC);
+                        MethodConstraint consToAdd = new MethodConstraint(tphC.getLeft(), tphC.getRight(), tphC.getRel());
+                        if (!checkForDuplicates(consToAdd, tempMC)) {
+                            tempMC.add(consToAdd);
+                            System.out.println(consToAdd);
+                        }
+
                     }
                 }
             }
         }
-        return tempCC;
+        return tempMC;
     }
 
 /**
@@ -220,18 +231,54 @@ public class FamilyOfGeneratedGenerics {
      * {T <. Object | (T is a type variable in a type of a node of the method/constructor m in cl_\sigma),
      *                  (\existsnot T': T <. T') \in cs)}
      */
-
+    public static List<MethodConstraint> hasNoSupertypeForMethodTypes(List<TPHConstraint> allConstraints, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
-    public static List<MethodConstraint> hasNoSupertypeForMethodTypes() {
         //TODO:
-        return null;
+        List<MethodConstraint> tempMC= new ArrayList<>();
+        for(String tph: posOfTphs.keySet()) {
+            for(TPHConstraint allCons: allConstraints) {
+                if((posOfTphs.get(tph).fst.equals(PositionFinder.Position.METHOD) || posOfTphs.get(tph).fst.equals(PositionFinder.Position.CONSTRUCTOR)) && checkUpperBound(allConstraints,tph)) {
+                    MethodConstraint consToAdd = new MethodConstraint(tph, "Object", Relation.EXTENDS);
+                    if (!checkForDuplicates(consToAdd, tempMC)) {
+                        tempMC.add(consToAdd);
+                        System.out.println(consToAdd);
+                    }
+                }
+            }
+        }
+        return tempMC;
     }
 
 /**
      * nimm die Menge cs_cl aus cs_m raus
      */
-    public static List<MethodConstraint> methodTypesWithoutClassTypes() {
+    public static List<MethodConstraint> methodTypesWithoutClassTypes(List<ClassConstraint> cs_cl, List<MethodConstraint> cs_m) {
         //TODO:
-        return null;
+        List<TPHConstraint> tempCC = new ArrayList<>();
+        for(ClassConstraint cc: cs_cl) {
+            TPHConstraint tphC = new TPHConstraint(cc.getLeft(), cc.getRight(), cc.getRel());
+            tempCC.add(tphC);
+        }
+        List<TPHConstraint> tempMC = new ArrayList<>();
+        for(MethodConstraint mc: cs_m) {
+            TPHConstraint tphC = new TPHConstraint(mc.getLeft(), mc.getRight(), mc.getRel());
+            tempMC.add(tphC);
+        }
+        List<TPHConstraint> tempMC2 = new ArrayList<>();
+        tempMC2.addAll(tempMC);
+        List<MethodConstraint> tempMCToReturn = new ArrayList<>();
+
+        for(TPHConstraint cc: tempCC) {
+            for(TPHConstraint mc: tempMC) {
+                if(cc.getLeft().equals(mc.getLeft()) && cc.getRight().equals(mc.getRight())) {
+                    tempMC2.remove(mc);
+                }
+            }
+        }
+        for(TPHConstraint tphC: tempMC2) {
+            MethodConstraint mCons = new MethodConstraint(tphC.getLeft(), tphC.getRight(), tphC.getRel());
+            tempMCToReturn.add(mCons);
+        }
+        return tempMCToReturn;
     }
 
     public static boolean checkForDuplicates(TPHConstraint constraint, List list) {
@@ -269,6 +316,15 @@ public class FamilyOfGeneratedGenerics {
         return tcList;
     }
 
+    public static boolean checkUpperBound(List<TPHConstraint> cs, String tph) {
+        for(int i=0; i<cs.size(); i++) {
+            if(cs.get(i).getLeft() == tph) {
+                return false;
+            }
+        }
+        return true;
+    }
+
 
     public static HashMap<String, PairTphMethod<PositionFinder.Position, String>> positionConverter(HashMap<String, Boolean> allTphs, List<MethodAndTPH> listOfMethodsAndTphs) {
         HashMap<String, PairTphMethod<PositionFinder.Position, String>> convertedPositions = new HashMap<>();

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

@@ -154,7 +154,7 @@ public class UnifyTypeFactory {
     public static Constraint<UnifyPair> convert(Constraint<Pair> constraint){
     	Constraint<UnifyPair> unifyPairConstraint = constraint.stream()
     			.map(UnifyTypeFactory::convert)
-    			.collect(Collectors.toCollection( () -> new Constraint<UnifyPair> (constraint.isInherited(), convert(constraint.getExtendConstraint()))));
+    			.collect(Collectors.toCollection( () -> new Constraint<UnifyPair>(convert(constraint.getExtendConstraint()))));
     	return unifyPairConstraint;
     }
 

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

@@ -17,15 +17,13 @@ public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;
     private RefTypeOrTPHOrWildcardOrGeneric retType;
     List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
-    private final Boolean isInherited;
 
     public MethodAssumption(ClassOrInterface receiver, RefTypeOrTPHOrWildcardOrGeneric retType,
-                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope, Boolean isInherited){
+                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
         super(scope);
         this.receiver = receiver;
         this.retType = retType;
         this.params = params;
-        this.isInherited = isInherited;
     }
 
     /*
@@ -72,8 +70,4 @@ public class MethodAssumption extends Assumption{
 
         return receiverType;
     }
-    
-    public Boolean isInherited() {
-    	return isInherited;
-    }
 }

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

@@ -6,32 +6,17 @@ import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 
+//TODO: Remove this class
 public class Constraint<A> extends HashSet<A> {
 	private static final long serialVersionUID = 1L;
-	private Boolean isInherited = false;//wird nur für die Method-Constraints benoetigt
 	private Constraint<A> extendConstraint = null;
+
+	public Constraint(){}
 	
-	public Constraint() {
+	public Constraint(Constraint<A> extendConstraint) {
-		super();
-	}
-	
-	public Constraint(Boolean isInherited) {
-		this.isInherited = isInherited;
-	}
-	
-	public Constraint(Boolean isInherited, Constraint<A> extendConstraint) {
-		this.isInherited = isInherited;
 		this.extendConstraint = extendConstraint;
 	}
 	
-	public void setIsInherited(Boolean isInherited) {
-		this.isInherited = isInherited;
-	}
-	
-	public Boolean isInherited() {
-		return isInherited;
-	}
-	
 	public Constraint<A> getExtendConstraint() {
 		return extendConstraint;
 	}
@@ -41,7 +26,7 @@ public class Constraint<A> extends HashSet<A> {
 	}
 
 	public String toString() {
-		return super.toString() + " isInherited = " + isInherited 
+		return super.toString()
 				//" + extendsContraint: "  + (extendConstraint != null ? extendConstraint.toStringBase() : "null" ) 
 				+ "\n" ;
 	}

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

@@ -68,9 +68,8 @@ public class ConstraintSet<A> {
                     	Constraint<B> newConst = as.stream()
                     			.map(o)
                     			.collect(Collectors.toCollection((as.getExtendConstraint() != null)
-                    					? () -> new Constraint<B> (as.isInherited(),
+                    					? () -> new Constraint<B> (as.getExtendConstraint().stream().map(o).collect(Collectors.toCollection(Constraint::new)))
-                    							                   as.getExtendConstraint().stream().map(o).collect(Collectors.toCollection(Constraint::new))) 
+                    					: () -> new Constraint<B> ()
-                    					: () -> new Constraint<B> (as.isInherited())
                     			));                    							
                     	
                     	//CSA2CSB.put(as, newConst);

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

@@ -0,0 +1,107 @@
+package de.dhbwstuttgart.typeinference.constraints;
+
+
+import java.util.*;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+public class ConstraintSet2 {
+    Set<OderConstraint> oderConstraints = new HashSet<>();
+
+    public ConstraintSet2(Set<OderConstraint> constraints){
+        if(constraints.isEmpty())throw new RuntimeException("Empty constraint set");
+        this.oderConstraints = constraints;
+    }
+
+    @Override
+    public String toString(){
+    	BinaryOperator<String> b = (x,y) -> x+y;
+        return "ODER:" + this.oderConstraints.stream().reduce("", (x,y) -> x.toString()+ "\n"  +y, b);
+    }
+
+    private class ConstraintSpliterator implements Spliterator<Set<Pair>> {
+        private List<OderConstraint> constraints;
+        private long i = 0;
+        private long max = 0;
+        private List<Integer> sizes;
+        private List<Long> bases = new ArrayList<>();
+
+        ConstraintSpliterator(List<OderConstraint> constraints){
+            this.constraints = constraints;
+            sizes = constraints.stream().map(OderConstraint::getSize).collect(Collectors.toList());
+            long base = 1;
+            for(int size : sizes){
+                bases.add(base);
+                base *= size;
+            }
+            i = 0;
+            max = estimateSize() - 1;
+        }
+
+        ConstraintSpliterator(List<OderConstraint> constraints, long start, long end){
+            this(constraints);
+            i = start;
+            max = end;
+        }
+
+        @Override
+        public boolean tryAdvance(Consumer<? super Set<Pair>> consumer) {
+            if(i > max) return false;
+            consumer.accept(get(i));
+            i++;
+            return true;
+        }
+
+        private Set<Pair> get(long num){
+            Set<Pair> ret = new HashSet<>();
+            Iterator<Long> baseIt = bases.iterator();
+            for(OderConstraint constraint : constraints){
+                ret.addAll(constraint.get((int) ((num/baseIt.next())%constraint.getSize())));
+            }
+            return ret;
+        }
+
+        @Override
+        public Spliterator<Set<Pair>> trySplit() {
+            if(max - i < 2) return null;
+            long middle = i + ((max- i) / 2);
+            long maxOld = max;
+            max = middle - 1;
+            return new ConstraintSpliterator(constraints, middle, maxOld);
+        }
+
+        @Override
+        public long estimateSize() {
+            long ret = 1;
+            for (int size : sizes)ret*=size;
+            return ret;
+        }
+
+        @Override
+        public int characteristics() {
+            return ORDERED | SIZED | IMMUTABLE | NONNULL;
+        }
+    }
+
+    public Stream<Set<Pair>> cartesianProductParallel(){
+        return StreamSupport.stream(new ConstraintSpliterator(oderConstraints.stream().collect(Collectors.toList())), true);
+    }
+/*
+    public Map<String, TypePlaceholder> generateTPHMap() {
+        HashMap<String, TypePlaceholder> ret = new HashMap<>();
+        constraints.map((Pair p) -> {
+            if (p.TA1 instanceof TypePlaceholder) {
+                ret.put(((TypePlaceholder) p.TA1).getName(), (TypePlaceholder) p.TA1);
+            }
+            if (p.TA2 instanceof TypePlaceholder) {
+                ret.put(((TypePlaceholder) p.TA2).getName(), (TypePlaceholder) p.TA2);
+            }
+            return null;
+        });
+        return ret;
+    }
+*/
+}

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

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.typeinference.constraints;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class ConstraintSetBuilder {
+    private Set<Pair> undConstraints = new HashSet<>();
+    private Set<OderConstraint> oderConstraints = new HashSet<>();
+    private boolean done = false;
+
+    public void addUndConstraint(Pair p){
+        undConstraints.add(p);
+    }
+
+    public void addOderConstraint(OderConstraint orConstraint) {
+        oderConstraints.add(orConstraint);
+    }
+
+    public ConstraintSet2 build(){
+        if(done)throw new RuntimeException("Trying to build cartesian product twice");
+        this.done = true;
+        if(!undConstraints.isEmpty())
+            oderConstraints.add(new OderConstraint(Set.of(undConstraints)));
+        return new ConstraintSet2(oderConstraints);
+    }
+}

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

@@ -0,0 +1,24 @@
+package de.dhbwstuttgart.typeinference.constraints;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class OderConstraint {
+    private final List<Set<Pair>> cons;
+    public OderConstraint(Set<Set<Pair>> orCons){
+        if(orCons.isEmpty())throw new RuntimeException("Empty constraint set");
+        for(Set<Pair> c : orCons){
+            if(c.isEmpty())throw new RuntimeException("Empty constraint set");
+        }
+        this.cons = orCons.stream().collect(Collectors.toList());
+    }
+
+    public int getSize(){
+        return cons.size();
+    }
+
+    public Set<Pair> get(int l) {
+        return cons.get(l);
+    }
+}

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

@@ -179,7 +179,7 @@ public class TYPEStmt implements StatementVisitor{
 					           !(x.TA2 instanceof TypePlaceholder))
 					        		   ? new Pair(x.TA1, new ExtendsWildcardType(x.TA2, x.TA2.getOffset()), PairOperator.EQUALSDOT)
 					        		   : x)
-            		.collect(Collectors.toCollection(() -> new Constraint<Pair>(oneMethodConstraint.isInherited())));
+            		.collect(Collectors.toCollection(() -> new Constraint<Pair>()));
             oneMethodConstraint.setExtendConstraint(extendsOneMethodConstraint);
             extendsOneMethodConstraint.setExtendConstraint(oneMethodConstraint);
             methodConstraints.add(extendsOneMethodConstraint);
@@ -574,7 +574,7 @@ public class TYPEStmt implements StatementVisitor{
 
     protected Constraint<Pair> generateConstraint(MethodCall forMethod, MethodAssumption assumption,
                                                   TypeInferenceBlockInformation info, GenericsResolver resolver){
-        Constraint<Pair> methodConstraint = new Constraint<>(assumption.isInherited());
+        Constraint<Pair> methodConstraint = new Constraint<>();
         ClassOrInterface receiverCl = assumption.getReceiver();
         /*
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
@@ -636,7 +636,7 @@ public class TYPEStmt implements StatementVisitor{
                         public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
                             throw new NotImplementedException();
                         }
-                    }, false));
+                    }));
         }
         for(ClassOrInterface cl : info.getAvailableClasses()){
             for(Method m : cl.getMethods()){
@@ -645,7 +645,7 @@ public class TYPEStmt implements StatementVisitor{
                     RefTypeOrTPHOrWildcardOrGeneric retType = m.getReturnType();//info.checkGTV(m.getReturnType());
 
                     ret.add(new MethodAssumption(cl, retType, convertParams(m.getParameterList(),info),
-                           createTypeScope(cl, m), m.isInherited));
+                           createTypeScope(cl, m)));
                 }
             }
         }
@@ -680,7 +680,7 @@ public class TYPEStmt implements StatementVisitor{
                 for(Method m : cl.getConstructors()){
                     if(m.getParameterList().getFormalparalist().size() == argList.getArguments().size()){
                         ret.add(new MethodAssumption(cl, ofType, convertParams(m.getParameterList(),
-                                info), createTypeScope(cl, m), m.isInherited));
+                                info), createTypeScope(cl, m)));
                     }
                 }
             }

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

@@ -682,9 +682,8 @@ public class RuleSet implements IRuleSet{
 				Function<? super Constraint<UnifyPair>,? extends Constraint<UnifyPair>> applyUni = b -> b.stream().map(
 						x -> uni.apply(pair,x)).collect(Collectors.toCollection((b.getExtendConstraint() != null)
 								? () -> new Constraint<UnifyPair>(
-										  b.isInherited(),
 										  b.getExtendConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(Constraint::new)))
-								: () -> new Constraint<UnifyPair>(b.isInherited())
+								: () -> new Constraint<UnifyPair>()
 									));
 				oderConstraints.replaceAll(oc -> oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new)));
 				/*

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

@@ -1304,7 +1304,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 							Set<UnifyPair> a_new = aParDefIt.next();
 							List<Set<UnifyPair>> smallerSetasList = oup.smallerThan(a_new, nextSetasList);
 							List<Set<UnifyPair>> notInherited = smallerSetasList.stream()
-								.filter(x -> !((Constraint<UnifyPair>)x).isInherited())
 								.collect(Collectors.toCollection(ArrayList::new));
 							List<Set<UnifyPair>> notErased = new ArrayList<>();
 							notInherited.stream().forEach(x -> { notErased.addAll(oup.smallerEqThan(x, smallerSetasList)); });
@@ -1346,11 +1345,10 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 							List<Set<UnifyPair>> greaterSetasList = oup.greaterThan(a_new, nextSetasList); 
 							
 							//a_new muss hingefuegt werden, wenn es nicht vererbt ist, dann wird es spaeter wieder geloescht
-							if (!((Constraint<UnifyPair>)a_new).isInherited()) {
+
-								greaterSetasList.add(a_new); 
+							greaterSetasList.add(a_new);
-							}
+
 							List<Set<UnifyPair>> notInherited = greaterSetasList.stream()
-								.filter(x -> !((Constraint<UnifyPair>)x).isInherited())
 								.collect(Collectors.toCollection(ArrayList::new));
 							List<Set<UnifyPair>> notErased = new ArrayList<>();
 							
@@ -1401,7 +1399,6 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 						writeLog("Removed: " + nextSetasListOderConstraints);
 					    List<Set<UnifyPair>> smallerSetasList = oup.smallerThan(a, nextSetasList);
 						List<Set<UnifyPair>> notInherited = smallerSetasList.stream()
-							.filter(x -> !((Constraint<UnifyPair>)x).isInherited())
 							.collect(Collectors.toCollection(ArrayList::new));
 						List<Set<UnifyPair>> notErased = new ArrayList<>();
 						notInherited.stream().forEach(x -> { notErased.addAll(oup.smallerEqThan(x, smallerSetasList)); });

src/test/java/insertGenerics/FamilyOfGeneratedGenericsTest.java

@@ -15,7 +15,7 @@ public class FamilyOfGeneratedGenericsTest extends TestCase {
         /*
         Example method:
         A id(B i) return i;
-        gives constraint: B <. A, which is a method constraint
+        gives constraint: B <. A and A <. Object, which are method constraints
          */
 
         List<TPHConstraint> inputConstraints = new ArrayList<>();
@@ -32,8 +32,8 @@ public class FamilyOfGeneratedGenericsTest extends TestCase {
         /*
         MethodConstraints should be the same as the input constraint
          */
-        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(inputConstraints, tphPositions);
+        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(inputConstraints, new ArrayList<ClassConstraint>(), tphPositions);
-        assertTrue(methodConstraints.size() == 1);
+        assertTrue(methodConstraints.size() == 2);
         assertTrue(methodConstraints.get(0).getLeft().equals("B"));
         assertTrue(methodConstraints.get(0).getRight().equals("A"));
     }
@@ -46,7 +46,7 @@ public class FamilyOfGeneratedGenericsTest extends TestCase {
                 return f;
             }
         }
-        gives constraint: A <. B, which is a class constraint
+        gives constraint: A <. B and B <. Object which are class constraints
          */
 
         List<TPHConstraint> inputConstraints = new ArrayList<>();
@@ -109,8 +109,12 @@ public class FamilyOfGeneratedGenericsTest extends TestCase {
 
         List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(inputConstraints, tphPositions);
         System.out.println(classConstraints);
+        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(inputConstraints, classConstraints, tphPositions);
+        System.out.println(methodConstraints);
         assertFalse(classConstraints.isEmpty());
         assertTrue(classConstraints.size() == 6);
+        assertFalse(methodConstraints.isEmpty());
+        assertTrue(methodConstraints.size() == 5);
 
     }
 
@@ -165,9 +169,13 @@ public class FamilyOfGeneratedGenericsTest extends TestCase {
 
         List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(inputConstraints, tphPositions);
         System.out.println(classConstraints);
+        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(inputConstraints, classConstraints, tphPositions);
+        System.out.println(methodConstraints);
 
         assertFalse(classConstraints.isEmpty());
         assertTrue(classConstraints.size() == 3);
+        assertFalse(methodConstraints.isEmpty());
+        assertTrue(methodConstraints.size()==9);
     }
 
 

src/test/java/insertGenerics/TestExample42.java

@@ -1,12 +1,8 @@
-/*
 package insertGenerics;
 
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
-import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.*;
-import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
-import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
-import de.dhbwstuttgart.bytecode.insertGenerics.PositionFinder;
 import org.junit.Test;
 import static org.junit.Assert.assertEquals;
 
@@ -26,18 +22,31 @@ public class TestExample42 {
         return cs;
     }
 
-    public HashMap<String, PositionFinder.Position> fillPosOfTphs() {
+    public HashMap<String, PairTphMethod<PositionFinder.Position, String>> fillPosOfTphs() {
-        HashMap<String, PositionFinder.Position> posOfTphs = new HashMap<>();
+        HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs = new HashMap<>();
-        posOfTphs.put("K", PositionFinder.Position.FIELD);
+
-        posOfTphs.put("L", PositionFinder.Position.METHOD);
+        // TPHs "U" und "L" auskommentiert, da nach Vorgaben L zu Z umbenannt und U als void interpretiert wird
-        posOfTphs.put("M", PositionFinder.Position.METHOD);
+        PairTphMethod<PositionFinder.Position, String> posOfK = new PairTphMethod<>(PositionFinder.Position.FIELD, null);
-        posOfTphs.put("N", PositionFinder.Position.METHOD);
+//        PairTphMethod<PositionFinder.Position, String> posOfL = new PairTphMethod<>(PositionFinder.Position.METHOD, "id");
-        posOfTphs.put("P", PositionFinder.Position.METHOD);
+        PairTphMethod<PositionFinder.Position, String> posOfM = new PairTphMethod<>(PositionFinder.Position.METHOD, "id");
-        posOfTphs.put("Q", PositionFinder.Position.METHOD);
+        PairTphMethod<PositionFinder.Position, String> posOfN = new PairTphMethod<>(PositionFinder.Position.METHOD, "id");
-        posOfTphs.put("U", PositionFinder.Position.METHOD);
+        PairTphMethod<PositionFinder.Position, String> posOfP = new PairTphMethod<>(PositionFinder.Position.METHOD, "setA");
-        posOfTphs.put("V", PositionFinder.Position.METHOD);
+        PairTphMethod<PositionFinder.Position, String> posOfQ = new PairTphMethod<>(PositionFinder.Position.METHOD, "setA");
-        posOfTphs.put("W", PositionFinder.Position.METHOD);
+//        PairTphMethod<PositionFinder.Position, String> posOfU = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
-        posOfTphs.put("Z", PositionFinder.Position.METHOD);
+        PairTphMethod<PositionFinder.Position, String> posOfV = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
+        PairTphMethod<PositionFinder.Position, String> posOfW = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
+        PairTphMethod<PositionFinder.Position, String> posOfZ = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
+
+        posOfTphs.put("K", posOfK);
+//        posOfTphs.put("L", posOfL);
+        posOfTphs.put("M", posOfM);
+        posOfTphs.put("N", posOfN);
+        posOfTphs.put("P", posOfP);
+        posOfTphs.put("Q", posOfQ);
+//        posOfTphs.put("U", posOfU);
+        posOfTphs.put("V", posOfV);
+        posOfTphs.put("W", posOfW);
+        posOfTphs.put("Z", posOfZ);
         return posOfTphs;
     }
 
@@ -45,10 +54,9 @@ public class TestExample42 {
     public void genericTest() {
         List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(fillConstraintsList(),fillPosOfTphs());
         System.out.println("ClassConstraints: " + classConstraints);
-        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(fillConstraintsList(),fillPosOfTphs());
+        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(fillConstraintsList(),classConstraints,fillPosOfTphs());
         System.out.println("MethodConstraints: " + methodConstraints);
 
         List<TPHConstraint> testCons;
     }
 }
-*/

src/test/java/insertGenerics/TestExample42_allInOneMethod.java

@@ -0,0 +1,61 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.insertGenerics.*;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class TestExample42_allInOneMethod {
+    public List<TPHConstraint> fillConstraintsList() {
+        List<TPHConstraint> cs = new ArrayList<>();
+        cs.add(new TPHConstraint("M", "N", Relation.EXTENDS));
+        cs.add(new TPHConstraint("N", "Z", Relation.EXTENDS));
+        cs.add(new TPHConstraint("Q", "K", Relation.EXTENDS));
+        cs.add(new TPHConstraint("K", "P", Relation.EXTENDS));
+        cs.add(new TPHConstraint("W", "M", Relation.EXTENDS));
+        cs.add(new TPHConstraint("Z", "V", Relation.EXTENDS));
+        return cs;
+    }
+
+    public HashMap<String, PairTphMethod<PositionFinder.Position, String>> fillPosOfTphs() {
+        HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs = new HashMap<>();
+
+        // TPHs "U" und "L" auskommentiert, da nach Vorgaben L zu Z umbenannt und U als void interpretiert wird
+        PairTphMethod<PositionFinder.Position, String> posOfK = new PairTphMethod<>(PositionFinder.Position.FIELD, null);
+//        PairTphMethod<PositionFinder.Position, String> posOfL = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfM = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfN = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfP = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfQ = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+//        PairTphMethod<PositionFinder.Position, String> posOfU = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfV = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfW = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfZ = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+
+        posOfTphs.put("K", posOfK);
+//        posOfTphs.put("L", posOfL);
+        posOfTphs.put("M", posOfM);
+        posOfTphs.put("N", posOfN);
+        posOfTphs.put("P", posOfP);
+        posOfTphs.put("Q", posOfQ);
+//        posOfTphs.put("U", posOfU);
+        posOfTphs.put("V", posOfV);
+        posOfTphs.put("W", posOfW);
+        posOfTphs.put("Z", posOfZ);
+        return posOfTphs;
+    }
+
+    @Test
+    public void genericTest() {
+        List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(fillConstraintsList(),fillPosOfTphs());
+        System.out.println("ClassConstraints: " + classConstraints);
+        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(fillConstraintsList(),classConstraints,fillPosOfTphs());
+        System.out.println("MethodConstraints: " + methodConstraints);
+
+        List<TPHConstraint> testCons;
+    }
+}

src/test/java/typeinference/ConstraintSetTests.java

@@ -0,0 +1,62 @@
+package typeinference;
+
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSetBuilder;
+import de.dhbwstuttgart.typeinference.constraints.OderConstraint;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class ConstraintSetTests {
+    @Test
+    public void cartesianProductTestSingleConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 1;
+    }
+
+    @Test
+    public void cartesianProductTestSingleOderConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 2;
+    }
+
+    @Test
+    public void cartesianProductTestTwoOderConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 4;
+    }
+
+    @Test
+    public void cartesianProductTestThreeOderConstraint(){
+        ConstraintSetBuilder builder = new ConstraintSetBuilder();
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()))));
+        List<Set<Pair>> result = builder.build().cartesianProductParallel().collect(Collectors.toList());
+        assert result.size() == 4;
+
+        ConstraintSetBuilder builder2 = new ConstraintSetBuilder();
+        builder2.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder2.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        builder2.addOderConstraint(new OderConstraint(Set.of(Set.of(generatePair()), Set.of(generatePair()))));
+        List<Set<Pair>> result2 = builder2.build().cartesianProductParallel().collect(Collectors.toList());
+        
+        assert result2.stream().map( a -> a.stream().map(p -> p.TA1.toString()).reduce("", (x, y)-> x+" "+y)).collect(Collectors.toSet()).size() == 8;
+        assert result2.size() == 8;
+    }
+
+    public Pair generatePair(){
+        return new Pair(TypePlaceholder.fresh(new NullToken()), TypePlaceholder.fresh(new NullToken()));
+    }
+}