feat: remember inferred location in unifyPair

independentTest.sh

@@ -10,6 +10,7 @@ mkdir $TDIR
 cd $TDIR
 git clone $REPO .
 git checkout feat/unify-server
+# git checkout 93e1a8787cd94c73f4538f6a348f58613893a584
 # git checkout dad468368b86bdd5a3d3b2754b17617cee0a9107 # 1:55
 # git checkout a0c11b60e8c9d7addcbe0d3a09c9ce2924e9d5c0 # 2:25
 # git checkout 4cddf73e6d6c9116d3e1705c4b27a8e7f18d80c3 # 2:27
@@ -19,15 +20,14 @@ git checkout feat/unify-server
 # git checkout 1391206dfe59263cdb22f93371cfd1dd5465d97f # 1:29
 
 date "+%Y.%m.%d %H:%M:%S"
-
-# mvn clean compile -DskipTests package
-## prefix each stderr line with " | "
-# exec 2> >(trap "" INT TERM; sed 's/^/ | /' >&2)
-# echo -e "\nMatrix test:\n |"
-# time java -jar target/JavaTXcompiler-0.1-jar-with-dependencies.jar resources/bytecode/javFiles/Matrix.jav >/dev/null;
+# sed -i -e 's/source>21/source>23/g' pom.xml
+# sed -i -e 's/target>21/target>23/g' pom.xml
 
 
-mvn clean compile test
+mvn clean compile -DskipTests package
+time java -jar target/JavaTXcompiler-0.1-jar-with-dependencies.jar resources/bytecode/javFiles/Matrix.jav;
+
+# mvn clean compile test
 
 
 echo -e "\nCleanup... "

src/main/java/de/dhbwstuttgart/server/ServerTaskLogger.java

@@ -1,6 +1,8 @@
 package de.dhbwstuttgart.server;
 
 import de.dhbwstuttgart.util.Logger;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import org.java_websocket.WebSocket;
 
 public class ServerTaskLogger extends Logger {

src/main/java/de/dhbwstuttgart/server/SocketServer.java

@@ -29,6 +29,7 @@ public class SocketServer extends WebSocketServer {
 
   public static Logger logger = new Logger("SocketServer");
   public static final int maxTasksPerSession = 100;
+  private static boolean serverRunning = false;
 
   /**
    * Increase this every time a breaking change to the server communication is done.
@@ -45,12 +46,17 @@ public class SocketServer extends WebSocketServer {
     super(new InetSocketAddress(port));
     this.setConnectionLostTimeout(30);
 
-
+    serverRunning = true;
     // add a shutdown hook to close all connections when the process ends or is stopped by a SIGINT signal
     Runtime.getRuntime().addShutdownHook(new Thread(this::onShutdown));
   }
 
+  public static boolean isServerRunning() {
+    return serverRunning;
+  }
+
   private void onShutdown() {
+    serverRunning = false;
     try {
       for (var webSocket : this.getConnections()) {
         this.sendError(webSocket, "Sorry, i am shutting down. You are now on your own, good Luck!", true);
@@ -85,7 +91,7 @@ public class SocketServer extends WebSocketServer {
       // wait 10 seconds for the client to send a task and close the connection if nothing has been received until then
       final int secondsUntilTimeout = 10;
       timeoutExecutor.schedule(() -> {
-          if (webSocket.<SocketData>getAttachment().unhandledTasks.get() == 0 || !webSocket.isOpen()) {
+          if (webSocket.<SocketData>getAttachment().totalTasks.get() > 0 || !webSocket.isOpen()) {
             return;
           }
           sendMessage(webSocket, "No task received after " + secondsUntilTimeout + " seconds. Closing connection...");

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

@@ -37,6 +37,10 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
     super();
   }
 
+  public Constraint(int initialCapacity) {
+    super(initialCapacity);
+  }
+
   public Constraint(boolean isInherited, boolean isImplemented) {
     this.isInherited = isInherited;
     this.isImplemented = isImplemented;
@@ -77,6 +81,14 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
     methodSignatureConstraint = c;
   }
 
+  public <B extends IConstraintElement> Constraint<B> createdMapped(Function<A,B> mapper) {
+    Constraint<B> result = new Constraint<>(this.size());
+    for (A element : this) {
+      result.add(mapper.apply(element));
+    }
+    return result;
+  }
+
   public String toString() {
     return super.toString() + "\nisInherited = " + isInherited
       + " isOveridden = " + isImplemented

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

@@ -285,8 +285,13 @@ public class TYPEStmt implements StatementVisitor {
             // see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
             // Expression muss zu Numeric Convertierbar sein. also von Numeric erben
             Constraint<Pair> numeric;
+            HashSet<JavaClassName> classNames = TypeUnifyTaskHelper.getPresizedHashSet(info.getAvailableClasses().size());
+            for (var classEl : info.getAvailableClasses()) {
+                classNames.add(classEl.getClassName());
+            }
+
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(bytee.getName())) {
+            if (classNames.contains(bytee.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -294,7 +299,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(shortt.getName())) {
+            if (classNames.contains(shortt.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -302,7 +307,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(integer.getName())) {
+            if (classNames.contains(integer.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -310,7 +315,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(longg.getName())) {
+            if (classNames.contains(longg.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -318,7 +323,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(floatt.getName())) {
+            if (classNames.contains(floatt.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -326,7 +331,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(doublee.getName())) {
+            if (classNames.contains(doublee.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -341,7 +346,7 @@ public class TYPEStmt implements StatementVisitor {
 
             if (binary.operation.equals(BinaryExpr.Operator.ADD)) {
                 // Dann kann der Ausdruck auch das aneinanderfügen zweier Strings sein: ("a" + "b") oder (1 + 2)
-                if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(string.getName())) {
+                if (classNames.contains(string.getName())) {
                     Constraint<Pair> stringConcat = new Constraint<>();
                     stringConcat.add(new Pair(binary.lexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
                     stringConcat.add(new Pair(binary.rexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));

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

@@ -94,8 +94,8 @@ public class MartelliMontanariUnify implements IUnify {
 			// SUBST - Rule
 			if(lhsType instanceof PlaceholderType) {
 				mgu.add((PlaceholderType) lhsType, rhsType);
-				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen. 
-				termsList = termsList.stream().map(x -> mgu.apply(x)).collect(Collectors.toCollection(ArrayList::new));
+				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen.
+				termsList.replaceAll(mgu::apply);
 				idx = idx+1 == termsList.size() ? 0 : idx+1;
 				continue;
 			}

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

@@ -6,6 +6,7 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.Optional;
 import java.util.Queue;
 import java.util.Set;
@@ -652,12 +653,13 @@ public class RuleSet implements IRuleSet{
 		HashMap<UnifyType, Integer> typeMap = new HashMap<>(200);
 		
 		Stack<UnifyType> occuringTypes = new Stack<>();
-		
+		occuringTypes.ensureCapacity(pairs.size() * 3);
+
 		for(UnifyPair pair : pairs) {
 			occuringTypes.push(pair.getLhsType());
 			occuringTypes.push(pair.getRhsType());
 		}
-		
+
 		while(!occuringTypes.isEmpty()) {
 			UnifyType t1 = occuringTypes.pop();
 			if(!typeMap.containsKey(t1))
@@ -669,9 +671,9 @@ public class RuleSet implements IRuleSet{
 			if(t1 instanceof SuperType)
 				occuringTypes.push(((SuperType) t1).getSuperedType());
 			else
-				t1.getTypeParams().forEach(x -> occuringTypes.push(x));	
+				t1.getTypeParams().forEach(occuringTypes::push);
 		}
-		Queue<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
+		LinkedList<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
 		ArrayList<UnifyPair> result = new ArrayList<UnifyPair>();
 		boolean applied = false;
 
@@ -692,19 +694,30 @@ public class RuleSet implements IRuleSet{
 					&& !((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));
-				
+				// apply unifier to result and result1 in place
+				result.replaceAll(p -> uni.apply(pair, p));
+				ListIterator<UnifyPair> result1Iterator = result1.listIterator();
+				while (result1Iterator.hasNext()) {
+					UnifyPair x = result1Iterator.next();
+					result1Iterator.set(uni.apply(pair, x));
+				}
+
 				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.isImplemented(),
-										  b.getExtendConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(Constraint::new)),
+										  b.getExtendConstraint().createdMapped(x -> uni.apply(pair,x)),
 										  b.getmethodSignatureConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(HashSet::new)))
 								: () -> new Constraint<UnifyPair>(b.isInherited(), b.isImplemented())
 									));
-				oderConstraints.replaceAll(oc -> oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new)));
+				oderConstraints.replaceAll(oc -> {
+						HashSet<Constraint<UnifyPair>> mapped = new HashSet<>(oc.size());
+						for (var element : oc) {
+							mapped.add(applyUni.apply(element));
+						}
+						return mapped;
+				});
 				/*
 						oderConstraints = oderConstraints.stream().map(
 						a -> a.stream().map(applyUni

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

@@ -47,6 +47,8 @@ import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.RecursiveTask;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.stream.Collectors;
@@ -316,14 +318,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     /*
      * Occurs-Check durchfuehren
      */
-    Set<UnifyPair> ocurrPairs = eq.stream().filter(x -> {
-        UnifyType lhs, rhs;
-        return (lhs = x.getLhsType()) instanceof PlaceholderType
-          && !((rhs = x.getRhsType()) instanceof PlaceholderType)
-          && rhs.getTypeParams().occurs((PlaceholderType) lhs);
-      })
-      .peek(UnifyPair::setUndefinedPair)
-      .collect(Collectors.toCollection(HashSet::new));
+    Set<UnifyPair> ocurrPairs = TypeUnifyTaskHelper.occursCheck(eq);
 
     Set<UnifyPair> finalOcurrPairs = ocurrPairs;
     context.logger().debug(() -> "ocurrPairs: " + finalOcurrPairs);
@@ -347,14 +342,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       /* In commit dfd91b5f8b7fca1cb5f302eec4b0ba3330271c9b eingefuegt ANFANG */
       Set<UnifyPair> occurcheck = new HashSet<>(eq0);
       occurcheck.removeAll(eq0Prime);
-      ocurrPairs = occurcheck.stream().filter(x -> {
-          UnifyType lhs, rhs;
-          return (lhs = x.getLhsType()) instanceof PlaceholderType
-            && !((rhs = x.getRhsType()) instanceof PlaceholderType)
-            && rhs.getTypeParams().occurs((PlaceholderType) lhs);
-        })
-        .peek(UnifyPair::setUndefinedPair)
-        .collect(Collectors.toCollection(HashSet::new));
+      ocurrPairs = TypeUnifyTaskHelper.occursCheck(occurcheck);
       Set<UnifyPair> finalOcurrPairs1 = ocurrPairs;
       context.logger().debug(() -> "ocurrPairs: " + finalOcurrPairs1);
       if (!ocurrPairs.isEmpty()) {
@@ -770,6 +758,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     // - fork results : forkResults (frueher "add_res")
     CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> parallelResultDataFuture;
 
+
     if (parallel) {
       parallelResultDataFuture = varianceCase.computeParallel(
         elems, eq, oderConstraints, fc, rekTiefe, methodSignatureConstraint,

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

@@ -186,6 +186,24 @@ public class TypeUnifyTaskHelper {
       .collect(Collectors.toCollection(ArrayList::new));
   }
 
+
+  public static Set<UnifyPair> occursCheck(final Set<UnifyPair> eq) {
+    Set<UnifyPair> ocurrPairs = new HashSet<>(eq.size());
+    for (UnifyPair x : eq) {
+      UnifyType lhs = x.getLhsType();
+      UnifyType rhs = x.getRhsType();
+      if (lhs instanceof PlaceholderType lhsPlaceholder &&
+        !(rhs instanceof PlaceholderType) &&
+        rhs.getTypeParams().occurs(lhsPlaceholder))
+      {
+        x.setUndefinedPair();
+        ocurrPairs.add(x);
+      }
+    }
+    return ocurrPairs;
+  }
+
+
   public static <T> HashSet<T> getPresizedHashSet(int minElements) {
     if (minElements < 16) return new HashSet<>();
     // HashSet and HashMap will resize at 75% load, so we account for that by multiplying with 1.5

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

@@ -170,30 +170,66 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		left.add(p2);
 		left.add(p4);
 		*/
-		
 
-		Set<UnifyPair> lefteq = left.stream()
-				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> righteq = right.stream()
-				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> leftle = left.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightle = right.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> leftlewc = left.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightlewc = right.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
-				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> lefteq = new HashSet<>();
+		Set<UnifyPair> leftle = new HashSet<>();
+		Set<UnifyPair> leftlewc = new HashSet<>();
+		Set<UnifyPair> lefteqOder = new HashSet<>();
+		Set<UnifyPair> lefteqRet = new HashSet<>();
+		Set<UnifyPair> leftleOder = new HashSet<>();
+		for (var x : left) {
+			boolean isLeftPlaceholder = x.getLhsType() instanceof PlaceholderType;
+			boolean isRightPlaceholder = x.getRhsType() instanceof PlaceholderType;
+			boolean hasPlaceholder = isLeftPlaceholder || isRightPlaceholder;
+
+			if (isLeftPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) lefteq.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOT) leftle.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOTWC) leftlewc.add(x);
+
+			UnifyPair y = x.getGroundBasePair();
+			boolean isBasePairLeftPlaceholder = y.getLhsType() instanceof PlaceholderType;
+			boolean isBasePairRightPlaceholder = y.getRhsType() instanceof PlaceholderType;
+			if (isBasePairLeftPlaceholder && !isBasePairRightPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) {
+				lefteqOder.add(x);
+			}
+			else if (isBasePairRightPlaceholder && ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1) {
+				lefteqRet.add(x);
+			}
+			else if (x.getPairOp() == PairOperator.SMALLERDOT) {
+				leftleOder.add(x);
+			}
+		}
+
+
+		Set<UnifyPair> righteq = new HashSet<>();
+		Set<UnifyPair> rightle = new HashSet<>();
+		Set<UnifyPair> rightlewc = new HashSet<>();
+		Set<UnifyPair> righteqOder = new HashSet<>();
+		Set<UnifyPair> righteqRet = new HashSet<>();
+		Set<UnifyPair> rightleOder = new HashSet<>();
+		for (var x : right) {
+			boolean isLeftPlaceholder = x.getLhsType() instanceof PlaceholderType;
+			boolean isRightPlaceholder = x.getRhsType() instanceof PlaceholderType;
+			boolean hasPlaceholder = isLeftPlaceholder || isRightPlaceholder;
+
+			if (isLeftPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) righteq.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOT) 	rightle.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOTWC) rightlewc.add(x);
+
+			UnifyPair y = x.getGroundBasePair();
+			boolean isBasePairLeftPlaceholder = y.getLhsType() instanceof PlaceholderType;
+			boolean isBasePairRightPlaceholder = y.getRhsType() instanceof PlaceholderType;
+			if (isBasePairLeftPlaceholder && !isBasePairRightPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) {
+				righteqOder.add(x);
+			}
+			else if (isBasePairRightPlaceholder && ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1) {
+				righteqRet.add(x);
+			}
+			else if (x.getPairOp() == PairOperator.SMALLERDOT) {
+				rightleOder.add(x);
+			}
+		}
+
 		//context.logger().info(left.toString());
 		//Fall 2
 		//if (lefteq.iterator().next().getLhsType().getName().equals("AJO")) {
@@ -201,54 +237,14 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		//}
 		
 		//ODER-CONSTRAINT
-		Set<UnifyPair> leftBase = left.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightBase = right.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
+		// Set<UnifyPair> leftBase = left.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
+		// Set<UnifyPair> rightBase = right.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
 
-		Set<UnifyPair> lefteqOder = left.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair();
-				/*try {
-					((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("y: " + y.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("y.getLhsType() : " + y.getLhsType() .toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("y.getRhsType(): " + y.getRhsType().toString() +"\n");
-					((FiniteClosure)fc).logFile.write("x.getPairOp(): " + x.getPairOp().toString() +"\n\n");
-					}
-					catch (IOException ie) {
-					}	*/
-	               return (y.getLhsType() instanceof PlaceholderType && 
-	            		   !(y.getRhsType() instanceof PlaceholderType) && 
-	            		   x.getPairOp() == PairOperator.EQUALSDOT);})
-				.collect(Collectors.toCollection(HashSet::new));
 		left.removeAll(lefteqOder);
-		Set<UnifyPair> righteqOder = right.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
-	               return (y.getLhsType() instanceof PlaceholderType && 
-	            		   !(y.getRhsType() instanceof PlaceholderType) && 
-	            		   x.getPairOp() == PairOperator.EQUALSDOT);})
-				.collect(Collectors.toCollection(HashSet::new));
-		right.removeAll(righteqOder);
-		Set<UnifyPair> lefteqRet = left.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
-	               return (y.getRhsType() instanceof PlaceholderType && 
-	            		   ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1);})
-				.collect(Collectors.toCollection(HashSet::new));
 		left.removeAll(lefteqRet);
-		Set<UnifyPair> righteqRet = right.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
-	               return (y.getRhsType() instanceof PlaceholderType && 
-	            		   ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1);})
-				.collect(Collectors.toCollection(HashSet::new));
+		right.removeAll(righteqOder);
 		right.removeAll(righteqRet);
-		Set<UnifyPair> leftleOder = left.stream()
-				.filter(x -> (x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightleOder = right.stream()
-				.filter(x -> (x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		
+
 		/*
 		synchronized(this) {
 					try {
@@ -273,59 +269,43 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		int compareEq;
 		if (lefteqOder.size() == 1 && righteqOder.size() == 1 && lefteqRet.size() == 1 && righteqRet.size() == 1) {
 			Match m = new Match();
-			if ((compareEq = compareEq(lefteqOder.iterator().next().getGroundBasePair(), righteqOder.iterator().next().getGroundBasePair())) == -1) {
-				ArrayList<UnifyPair> matchList = 
-						rightleOder.stream().map(x -> { 
-							UnifyPair leftElem = leftleOder.stream()
+			compareEq = compareEq(lefteqOder.iterator().next().getGroundBasePair(), righteqOder.iterator().next().getGroundBasePair());
+
+			if (compareEq == -1) {
+				ArrayList<UnifyPair> matchList =
+						rightleOder.stream().map(x -> {
+								UnifyPair leftElem = leftleOder.stream()
 														     .filter(y -> y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
-														     .findAny().get(); 
-							return new UnifyPair(x.getRhsType(), leftElem.getRhsType(), PairOperator.EQUALSDOT);})
-											.collect(Collectors.toCollection(ArrayList::new));
-				if (m.match(matchList).isPresent()) {
-					//try { ((FiniteClosure)fc).logFile.write("result1: -1 \n\n"); } catch (IOException ie) {}
-					return -1;
-				}
-				else {
-					//try { ((FiniteClosure)fc).logFile.write("result1: 0 \n\n"); } catch (IOException ie) {}
-					return 0;
-				}
+														     .findAny().orElseThrow();
+								return new UnifyPair(x.getRhsType(), leftElem.getRhsType(), PairOperator.EQUALSDOT);}
+							)
+							.collect(Collectors.toCollection(ArrayList::new));
+
+				return (m.match(matchList).isPresent()) ? -1 : 0;
 			} else if (compareEq == 1) {
-				ArrayList<UnifyPair> matchList = 
-						leftleOder.stream().map(x -> { 
+				ArrayList<UnifyPair> matchList =
+						leftleOder.stream().map(x -> {
 							UnifyPair rightElem = rightleOder.stream()
-									                        .filter(y -> 
-									                        	y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
-									                        .findAny().get(); 
-														return new UnifyPair(x.getRhsType(), rightElem.getRhsType(), PairOperator.EQUALSDOT);})
-											.collect(Collectors.toCollection(ArrayList::new));
-				if (m.match(matchList).isPresent()) {
-					//try { ((FiniteClosure)fc).logFile.write("result2: 1 \n\n"); } catch (IOException ie) {}
-					return 1;
-				}
-				else {
-					//try { ((FiniteClosure)fc).logFile.write("result2: 0 \n\n"); } catch (IOException ie) {}
-					return 0;
-				}
+								.filter(y -> y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
+								.findAny().orElseThrow();
+							return new UnifyPair(x.getRhsType(), rightElem.getRhsType(), PairOperator.EQUALSDOT);}
+						)
+						.collect(Collectors.toCollection(ArrayList::new));
+				return (m.match(matchList).isPresent()) ? 1 : 0;
 			} else {
 				/*
-				synchronized(this) {
-					try {
-						((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("lefteqOder: " + lefteqOder.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("righteqOder: " + righteqOder.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("lefteqRet: " + lefteqRet.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("righteqRet: " + righteqRet.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("leftleOder: " + leftleOder.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("rightleOder: " + rightleOder.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("result3: 0 \n\n");
-						((FiniteClosure)fc).logFile.flush();
-					}
-					catch (IOException ie) {
-					}
-				}
+					((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("lefteqOder: " + lefteqOder.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("righteqOder: " + righteqOder.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("lefteqRet: " + lefteqRet.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("righteqRet: " + righteqRet.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("leftleOder: " + leftleOder.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("rightleOder: " + rightleOder.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("result3: 0 \n\n");
+					((FiniteClosure)fc).logFile.flush();
 				*/
 				return 0;
 			}
@@ -392,12 +372,12 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 				//TODO: Hier wird bei Wildcards nicht das richtige compare aufgerufen PL 18-04-20
 				Pair<Integer, Set<UnifyPair>> int_Unifier = compare(lseq.getRhsType(), rseq.getRhsType());
 				Unifier uni = new Unifier();
-				int_Unifier.getValue().get().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
-				if (!lseq.getRhsType().getName().equals(rseq.getRhsType().getName()) 
+				int_Unifier.getValue().orElseThrow().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
+				if (!lseq.getRhsType().getName().equals(rseq.getRhsType().getName())
 					|| leftlewc.isEmpty() || rightlewc.isEmpty()) return int_Unifier.getKey();
 				else {
-					Set <UnifyPair> lsleuni = leftlewc.stream().map(x -> uni.apply(x)).collect(Collectors.toCollection(HashSet::new));
-					Set <UnifyPair> rsleuni = rightlewc.stream().map(x -> uni.apply(x)).collect(Collectors.toCollection(HashSet::new));
+					Set <UnifyPair> lsleuni = leftlewc.stream().map(uni::apply).collect(Collectors.toCollection(HashSet::new));
+					Set <UnifyPair> rsleuni = rightlewc.stream().map(uni::apply).collect(Collectors.toCollection(HashSet::new));
 					BinaryOperator<HashMap<UnifyType,UnifyPair>> combiner = (x,y) -> { x.putAll(y); return x;};
 				
 					HashMap<UnifyType,UnifyPair> hm;
@@ -418,6 +398,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 				}
 			} else {
 				if (!leftlewc.isEmpty()) {
+					/*
 					Set<UnifyPair> subst;
 					subst = leftlewc.stream().map(x -> { 
 						if (x.getLhsType() instanceof PlaceholderType) {
@@ -426,6 +407,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 						else {
 							return new UnifyPair(x.getRhsType(), x.getLhsType(), PairOperator.EQUALSDOT);
 						}}).collect(Collectors.toCollection(HashSet::new));
+					 */
 					Unifier uni = new Unifier();
 					lseq = uni.apply(lseq);
 				}

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

@@ -106,7 +106,11 @@ public class UnifyPair implements IConstraintElement, ISerializableData {
 
 	public SourceLoc getLocation() {
 		if (location != null) return location;
-		else if (basePair != null) return basePair.getLocation();
+		else if (basePair != null) {
+			SourceLoc baseLocation = basePair.getLocation();
+			location = baseLocation;
+			return baseLocation;
+		}
 		return null;
 	}
 		

src/main/java/de/dhbwstuttgart/util/Logger.java

@@ -2,11 +2,14 @@ package de.dhbwstuttgart.util;
 
 import com.diogonunes.jcolor.Attribute;
 import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.server.SocketServer;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
 import java.nio.file.Path;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.Arrays;
 import java.util.Objects;
 import java.util.function.Supplier;
@@ -20,6 +23,7 @@ public class Logger {
   protected final String prefix;
 
   public static Logger NULL_LOGGER = new NullLogger();
+  private static DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
 
   public Logger() {
     this(null, "");
@@ -84,6 +88,14 @@ public class Logger {
    */
   protected void print(String s, LogLevel logLevel) {
     String coloredPrefix = this.getPrefix(logLevel);
+
+    // if we are running the server, prepend the timestamp
+    if(SocketServer.isServerRunning()) {
+      String timestamp = LocalDateTime.now().format(timeFormatter);
+      coloredPrefix = "[" + timestamp + "] " + coloredPrefix;
+    }
+
+    // output to the correct output-stream
     if (logLevel.isHigherOrEqualTo(LogLevel.ERROR)) {
       System.out.println(coloredPrefix + s);
     }