Remove not used isInherited

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/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() {
-		super();
-	}
-	
-	public Constraint(Boolean isInherited) {
-		this.isInherited = isInherited;
-	}
-	
-	public Constraint(Boolean isInherited, Constraint<A> extendConstraint) {
-		this.isInherited = isInherited;
+	public Constraint(Constraint<A> extendConstraint) {
 		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(),
-                    							                   as.getExtendConstraint().stream().map(o).collect(Collectors.toCollection(Constraint::new))) 
-                    					: () -> new Constraint<B> (as.isInherited())
+                    					? () -> new Constraint<B> (as.getExtendConstraint().stream().map(o).collect(Collectors.toCollection(Constraint::new)))
+                    					: () -> new Constraint<B> ()
                     			));                    							
                     	
                     	//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/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()));
+    }
+}