feat: added Logger class, remove empty println start cleanup of computeCartesianRecursive

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

@@ -326,7 +326,7 @@ public class JavaTXCompiler {
 			for (SourceFile f : this.sourceFiles.values()) {
 				logFile.write(ASTTypePrinter.print(f));
 			}
-			logFile.flush();
+			// logFile.flush();
 			Set<PlaceholderType> varianceTPHold;
 			Set<PlaceholderType> varianceTPH = new HashSet<>();
 			varianceTPH = varianceInheritanceConstraintSet(unifyCons);
@@ -392,7 +392,7 @@ public class JavaTXCompiler {
 			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
 			logFile.write(ASTTypePrinter.print(sf));
 			System.out.println(ASTTypePrinter.print(sf));
-			logFile.flush();
+			// logFile.flush();
 			System.out.println("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
 			Set<PlaceholderType> varianceTPHold;
 			Set<PlaceholderType> varianceTPH = new HashSet<>();
@@ -419,7 +419,7 @@ public class JavaTXCompiler {
 				System.out.println("RESULT Final: " + li.getResults());
 				System.out.println("Constraints for Generated Generics: " + " ???");
 				logFile.write("RES_FINAL: " + li.getResults().toString() + "\n");
-				logFile.flush();
+				// logFile.flush();
 				return li.getResults();
 			}
 			/* UnifyResultModel End */
@@ -430,7 +430,7 @@ public class JavaTXCompiler {
 				Set<Set<UnifyPair>> result = unify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons, finiteClosure), usedTasks);
 				System.out.println("RESULT: " + result);
 				logFile.write("RES: " + result.toString() + "\n");
-				logFile.flush();
+				// logFile.flush();
 				results.addAll(result);
 
 				results = results.stream().map(x -> {
@@ -447,9 +447,9 @@ public class JavaTXCompiler {
 				System.out.println("RESULT Final: " + results);
 				System.out.println("Constraints for Generated Generics: " + " ???");
 				logFile.write("RES_FINAL: " + results.toString() + "\n");
-				logFile.flush();
+				// logFile.flush();
 				logFile.write("PLACEHOLDERS: " + PlaceholderType.EXISTING_PLACEHOLDERS);
-				logFile.flush();
+				// logFile.flush();
 			}
 		} catch (IOException e) {
 			System.err.println("kein LogFile");

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

@@ -194,7 +194,7 @@ public class UnifyTypeFactory {
         		&& ((PlaceholderType)lhs).isWildcardable() 
         		&&	(rhs = ret.getLhsType()) instanceof PlaceholderType) {
         	if (lhs.getName().equals("AQ")) {
-        		System.out.println("");
+        		// System.out.println("");
         	}
         	((PlaceholderType)rhs).enableWildcardtable();
         }
@@ -203,7 +203,7 @@ public class UnifyTypeFactory {
         		&& ((PlaceholderType)rhs).isWildcardable()
         		&&	(lhs = ret.getLhsType()) instanceof PlaceholderType) {
         	if (rhs.getName().equals("AQ")) {
-        		System.out.println("");
+        		// System.out.println("");
         	}
         	((PlaceholderType)lhs).enableWildcardtable();
         }

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

@@ -0,0 +1,64 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.RecursiveTask;
+
+public class ConcurrentSetMergeTask<T> extends RecursiveTask<Set<T>> {
+
+  public static <E> Set<E> merge(List<Set<E>> list) {
+    if (list.isEmpty()) {
+      return new HashSet<>();
+    }
+    var task = new ConcurrentSetMergeTask<>(list, 0, list.size());
+    return task.compute();
+  }
+
+  private static final int LIST_THRESHOLD = 3;
+  private static final int ELEMENT_THRESHOLD = 1000;
+
+  private final List<Set<T>> list;
+  private final int start;
+  private final int end;
+
+  private ConcurrentSetMergeTask(List<Set<T>> list, int start, int end) {
+    this.list = list;
+    this.start = start;
+    this.end = end;
+  }
+
+  @Override
+  protected Set<T> compute() {
+    int size = end - start;
+
+    int totalElements = 0;
+    for (int i = start+1; i < end; i++) {
+      totalElements += list.get(i).size();
+    }
+
+    System.out.println("ConcurrentSetMerge? -> " + (size <= LIST_THRESHOLD || totalElements < ELEMENT_THRESHOLD ? "true" : "false"));
+
+
+    // size will always be at least one
+    if (true || size <= LIST_THRESHOLD || totalElements < ELEMENT_THRESHOLD) {
+      Set<T> result = this.list.get(start);
+      for (int i = start+1; i < end; i++) {
+        result.addAll(list.get(i));
+      }
+      return result;
+    } else {
+      int mid = start + (size / 2);
+      ConcurrentSetMergeTask<T> leftTask = new ConcurrentSetMergeTask<>(list, start, mid);
+      ConcurrentSetMergeTask<T> rightTask = new ConcurrentSetMergeTask<>(list, mid, end);
+
+      leftTask.fork();
+      Set<T> rightResult = rightTask.compute();
+      Set<T> leftResult = leftTask.join();
+
+      // Merge results
+      leftResult.addAll(rightResult);
+      return leftResult;
+    }
+  }
+}

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

@@ -864,7 +864,7 @@ public class RuleSet implements IRuleSet{
 		try {
 			logFile.write("FUNgreater: " + pair + "\n");
 				logFile.write("FUNred: " + result + "\n");
-				logFile.flush();
+				// logFile.flush();
 			}
 		catch (IOException e) {
 			System.out.println("logFile-Error");
@@ -960,7 +960,7 @@ public class RuleSet implements IRuleSet{
 		try {
 			logFile.write("FUNgreater: " + pair + "\n");
 			logFile.write("FUNgreater: " + result + "\n");
-			logFile.flush();
+			// logFile.flush();
 		}
 	catch (IOException e) {
 		System.out.println("lofFile-Error");
@@ -1010,7 +1010,7 @@ public class RuleSet implements IRuleSet{
 		try {
 			logFile.write("FUNgreater: " + pair + "\n");
 			logFile.write("FUNsmaller: " + result + "\n");
-			logFile.flush();
+			// logFile.flush();
 		}
 	catch (IOException e) {
 		System.out.println("lofFile-Error");

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

@@ -1,41 +1,28 @@
 package de.dhbwstuttgart.typeinference.unify;
 
-import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ForkJoinPool;
 
-import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
-import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 public class TypeUnify {
-	
+
 	/**
 	 * unify parallel ohne result modell
-	 * @param undConstrains
-	 * @param oderConstraints
-	 * @param fc
-	 * @param logFile
-	 * @param log
-	 * @param cons
-	 * @return
 	 */
 	public Set<Set<UnifyPair>> unify(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret, UnifyTaskModel usedTasks) {
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, usedTasks);
-		ForkJoinPool pool = new ForkJoinPool();
+		ForkJoinPool pool = this.createThreadPool();
 		pool.invoke(unifyTask);
 		Set<Set<UnifyPair>> res =  unifyTask.join();
 		try {
 			logFile.write("\nnoShortendElements: " + unifyTask.noShortendElements + "\n");
-			logFile.flush();
+			// logFile.flush();
 		}
 		catch (IOException e) {
 			System.err.println("no log-File");
@@ -45,41 +32,25 @@ public class TypeUnify {
 	
 	/**
 	 * unify asynchron mit Rückgabe UnifyResultModel ohne dass alle results gesammelt sind
-	 * @param undConstrains
-	 * @param oderConstraints
-	 * @param fc
-	 * @param logFile
-	 * @param log
-	 * @param cons
-	 * @param ret
-	 * @return
 	 */
 	public UnifyResultModel unifyAsync(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret, UnifyTaskModel usedTasks) {
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, usedTasks);
-		ForkJoinPool pool = new ForkJoinPool();
+		ForkJoinPool pool = this.createThreadPool();
 		pool.invoke(unifyTask);
 		return ret;
 	}
 	
 	/**
 	 * unify parallel mit Rückgabe UnifyResultModel nachdem alle results gesammelt sind
-	 * @param undConstrains
-	 * @param oderConstraints
-	 * @param fc
-	 * @param logFile
-	 * @param log
-	 * @param cons
-	 * @param ret
-	 * @return
 	 */
 	public UnifyResultModel unifyParallel(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret, UnifyTaskModel usedTasks) {
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, usedTasks);
-		ForkJoinPool pool = new ForkJoinPool();
+		ForkJoinPool pool = this.createThreadPool();
 		pool.invoke(unifyTask);
 		Set<Set<UnifyPair>> res =  unifyTask.join();
 		try {
 			logFile.write("\nnoShortendElements: " + unifyTask.noShortendElements +"\n");
-			logFile.flush();
+			// logFile.flush();
 		}
 		catch (IOException e) {
 			System.err.println("no log-File");
@@ -97,20 +68,13 @@ public class TypeUnify {
 	
 	/**
 	 * unify sequentiell mit oderconstraints
-	 * @param undConstrains
-	 * @param oderConstraints
-	 * @param fc
-	 * @param logFile
-	 * @param log
-	 * @param cons
-	 * @return
 	 */
 	public Set<Set<UnifyPair>> unifyOderConstraints(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret, UnifyTaskModel usedTasks) {
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, false, logFile, log, 0, ret, usedTasks);
 		Set<Set<UnifyPair>> res = unifyTask.compute();
 		try {
 			logFile.write("\nnoShortendElements: " + unifyTask.noShortendElements +"\n");
-			logFile.flush();
+			// logFile.flush();
 		}
 		catch (IOException e) {
 			System.err.println("no log-File");
@@ -118,4 +82,13 @@ public class TypeUnify {
 		return res;
 	}
 
+	private ForkJoinPool createThreadPool() {
+		return new ForkJoinPool(
+			Runtime.getRuntime().availableProcessors(),
+			ForkJoinPool.defaultForkJoinWorkerThreadFactory,
+			null,
+			true // do not use asyncMode (FIFO), as we want smaller tasks to complete first -> Improves locality and cuts small branches first
+		);
+	}
+
 }

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

@@ -59,7 +59,7 @@ public class TypeUnify2Task extends TypeUnifyTask {
 				logFile.close();
 			}
 			catch (IOException ioE) {
-				System.err.println("no log-File" + thNo);
+				System.err.println("no log-File");
 			}
            
        }

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

@@ -0,0 +1,68 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * A collection of capsuled (and thus static) functions to split up large algorithms in TypeUnifyTask
+ */
+public class TypeUnifyTaskHelper {
+
+  /**
+   * Filter all topLevelSets for those with a single element that contain only one pair:
+   *   a <. theta,
+   *   theta <. a or
+   *   a =. theta
+   */
+  public static Set<Set<UnifyPair>> getSingleElementSets(ArrayList<Set<? extends Set<UnifyPair>>> topLevelSets) {
+    return topLevelSets.stream()
+      .filter(x -> x.size() == 1)
+      .map(y -> y.stream().findFirst().get()).collect(Collectors.toSet());
+  }
+
+  /**
+   * Varianzbestimmung Anfang
+   * Oderconstraint, wenn entweder kein Basepair oder unterschiedliche Basepairs => oderConstraint = true;
+   * Varianz =  1 => Argumentvariable
+   * Varianz = -1 => Rückgabevariable
+   * Varianz =  0 => unklar
+   * Varianz =  2 => Operatoren oderConstraints
+   */
+  public static int calculateVariance(List<Set<UnifyPair>> nextSetasList) {
+    Optional<Integer> xi = nextSetasList.stream().map(x -> x.stream().filter(y -> (y.getLhsType() instanceof PlaceholderType && !(y.getRhsType() instanceof PlaceholderType)))
+        .filter(z -> ((PlaceholderType) z.getLhsType()).getVariance() != 0)
+        .map(c -> ((PlaceholderType) c.getLhsType()).getVariance())
+        .reduce((a, b) -> {
+          if (a == b) return a;
+          else return 0;
+        })) //2 kommt insbesondere bei Oder-Constraints vor
+      .filter(d -> d.isPresent())
+      .map(e -> e.get())
+      .findAny();
+
+    return xi.orElse(0);
+  }
+
+  /**
+   * Find the first occurrence (if any) of a UnifyPair with operator EQUALSDOT while having
+   * one side equal to its base pair counterpart
+   */
+  public static Optional<UnifyPair> findEqualityConstrainedUnifyPair(Set<UnifyPair> nextSetElement) {
+    return nextSetElement.stream().filter(x ->
+        x.getPairOp()
+        .equals(PairOperator.EQUALSDOT))
+      .filter(x -> //Sicherstellen, dass bei a = ty a auch wirklich die gesuchte Typvariable ist
+        x.getLhsType()
+          .equals(x.getBasePair().getLhsType()) ||
+        x.getLhsType()
+          .equals(x.getBasePair().getRhsType())
+    ).findFirst();
+  }
+
+}

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

@@ -207,7 +207,7 @@ implements IFiniteClosure  {
 				result.add(new Pair<>(t, fBounded));
 			}
 			catch (StackOverflowError e) {
-				System.out.println("");
+				// System.out.println("");
 			}
 			
 			// if C<...> <* C<...> then ... (third case in definition of <*)
@@ -700,8 +700,8 @@ implements IFiniteClosure  {
 	
 	public int compare (UnifyType left, UnifyType right, PairOperator pairop) {
 		try {logFile.write("left: "+ left + " right: " + right + " pairop: " + pairop +"\n");} catch (IOException ie) {}
-		if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
-			System.out.println("");
+		// if (left.getName().equals("Matrix") || right.getName().equals("Matrix"))
+		// 	System.out.println("");
 		/*
 		pairop = PairOperator.SMALLERDOTWC;
 		List<UnifyType> al = new ArrayList<>();
@@ -760,7 +760,7 @@ implements IFiniteClosure  {
 		//if (left.getName().equals("Vector") || right.getName().equals("AbstractList")) 
 		{try { 
 			logFile.write("\nsmallerRes: " + smallerRes);//"smallerHash: " + greaterHash.toString());
-			logFile.flush();
+			// logFile.flush();
 		}
 		catch (IOException e) {
 			System.err.println("no LogFile");}}
@@ -774,7 +774,7 @@ implements IFiniteClosure  {
 		long smallerLen = smallerRes.stream().filter(delFun).count();
 		try { 
 			logFile.write("\nsmallerLen: " + smallerLen +"\n");
-			logFile.flush();
+			// logFile.flush();
 		}
 		catch (IOException e) {
 			System.err.println("no LogFile");}
@@ -789,7 +789,7 @@ implements IFiniteClosure  {
 			//if (left.getName().equals("Vector") || right.getName().equals("AbstractList")) 
 			{try { 
 				logFile.write("\ngreaterRes: " + greaterRes);//"smallerHash: " + greaterHash.toString());
-				logFile.flush();
+				// logFile.flush();
 			}
 			catch (IOException e) {
 				System.err.println("no LogFile");}}

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

@@ -47,7 +47,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		catch (ClassCastException e) {
 			try {
 			((FiniteClosure)fc).logFile.write("ClassCastException: " + left.toString() + " " + left.getGroundBasePair() + "\n\n");
-			((FiniteClosure)fc).logFile.flush();
+			 // ((FiniteClosure)fc).logFile.flush();
 			}
 			catch (IOException ie) {
 			}
@@ -79,12 +79,12 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 						&& (((ExtendsType)right).getExtendedType().getName().equals("java.util.Vector"))
 						&& (((ReferenceType)((ExtendsType)right).getExtendedType()).getTypeParams().iterator().next() instanceof ExtendsType)))
 				{
-					System.out.println("");
+					// System.out.println("");
 				}
 				if (((right instanceof SuperType) && (((SuperType)right).getSuperedType().getName().equals("java.lang.Object")))
 		||((left instanceof SuperType) && (((SuperType)left).getSuperedType().getName().equals("java.lang.Object"))))
 {
-						System.out.println("");
+						// System.out.println("");
 					}
 		}
 			else	 {
@@ -106,11 +106,11 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 						&& (((ExtendsType)right).getExtendedType().getName().equals("java.util.Vector"))
 						&& (((ReferenceType)((ExtendsType)right).getExtendedType()).getTypeParams().iterator().next() instanceof ExtendsType)))
 				{
-					System.out.println("");
+					// System.out.println("");
 				}
 				if (right instanceof SuperType) 
 					{
-						System.out.println("");
+						// System.out.println("");
 					}
 			}
 				else	 {

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

@@ -1,73 +1,60 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
-import java.io.File;
-import java.io.FileWriter;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Random;
-import java.util.Set;
-
-import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * An unbounded placeholder type.
  * @author Florian Steurer
  */
 public final class PlaceholderType extends UnifyType{
-	
+
 	/**
 	 * Static list containing the names of all existing placeholders.
 	 * Used for generating fresh placeholders.
 	 */
 	public static final ArrayList<String> EXISTING_PLACEHOLDERS = new ArrayList<String>();
-	
-	/**
-	 * Prefix of auto-generated placeholder names.
-	 */
-	protected static String nextName = "gen_";
-	
-	/**
-	 * Random number generator used to generate fresh placeholder name.
-	 */
-	protected static Random rnd = new Random(43558747548978L);
-	
+
+
+	private static final AtomicInteger placeholderCount = new AtomicInteger(0);
+
 	/**
 	 * True if this object was auto-generated, false if this object was user-generated.
 	 */
 	private final boolean IsGenerated;
-	
-	
+
+
 	/**
-	 * isWildcardable gibt an, ob ein Wildcardtyp dem PlaceholderType zugeordnet werden darf 
+	 * isWildcardable gibt an, ob ein Wildcardtyp dem PlaceholderType zugeordnet werden darf
 	 */
-	private boolean wildcardable = true;  
-	
+	private boolean wildcardable = true;
+
 	/**
 	 * is innerType gibt an, ob der Type des PlaceholderType innerhalb eines Typkonstruktorsverwendet wird
 	 */
-	private boolean innerType = false;  
-	
+	private boolean innerType = false;
+
 	/**
-     * variance shows the variance of the pair
-     * 1: contravariant
-     * -1 covariant
-     * 0 invariant
-     * PL 2018-03-21
-     */
-    private int variance = 0;
-    
-    /*
-     * Fuer Oder-Constraints:
-     * orCons = 1: Receiver
-     * orCons = 0: Argument oder kein Oder-Constraint 
-     * orCons = -1: RetType
-     */
-    private byte orCons = 0;
-	
+	 * variance shows the variance of the pair
+	 * 1: contravariant
+	 * -1 covariant
+	 * 0 invariant
+	 * PL 2018-03-21
+	 */
+	private int variance = 0;
+
+	/*
+	 * Fuer Oder-Constraints:
+	 * orCons = 1: Receiver
+	 * orCons = 0: Argument oder kein Oder-Constraint
+	 * orCons = -1: RetType
+	 */
+	private byte orCons = 0;
+
 	/**
 	 * Creates a new placeholder type with the specified name.
 	 */
@@ -76,17 +63,17 @@ public final class PlaceholderType extends UnifyType{
 		EXISTING_PLACEHOLDERS.add(name); // Add to list of existing placeholder names
 		IsGenerated = false; // This type is user generated
 	}
-	
-	
+
+
 	public PlaceholderType(String name, int variance) {
 		super(name, new TypeParams());
 		EXISTING_PLACEHOLDERS.add(name); // Add to list of existing placeholder names
 		IsGenerated = false; // This type is user generated
 		this.variance = variance;
 	}
-	
+
 	/**
-	 * Creates a new placeholdertype 
+	 * Creates a new placeholdertype
 	 * @param isGenerated true if this placeholder is auto-generated, false if it is user-generated.
 	 */
 	protected PlaceholderType(String name, boolean isGenerated) {
@@ -94,26 +81,42 @@ public final class PlaceholderType extends UnifyType{
 		EXISTING_PLACEHOLDERS.add(name); // Add to list of existing placeholder names
 		IsGenerated = isGenerated;
 	}
-	
+
 	public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht) {
 		return visitor.visit(this, ht);
 	}
-	
+
 	/**
-	 * Creates a fresh placeholder type with a name that does so far not exist.
+	 * Creates a fresh placeholder type with a name that does so far not exist from the chars A-Z.
 	 * A user could later instantiate a type using the same name that is equivalent to this type.
 	 * @return A fresh placeholder type.
 	 */
-	public synchronized static PlaceholderType freshPlaceholder() {
-		String name = nextName + (char) (rnd.nextInt(22) + 97); // Returns random char between 'a' and 'z'
-		// Add random chars while the name is in use.
-		while(EXISTING_PLACEHOLDERS.contains(name)) {
-			name += (char) (rnd.nextInt(22) + 97); // Returns random char between 'a' and 'z'
+	public static PlaceholderType freshPlaceholder() {
+		String name;
+
+		int attempts = 1000;
+		while (attempts-- > 0) {
+			int pc = PlaceholderType.placeholderCount.incrementAndGet();
+
+			StringBuilder sb = new StringBuilder();
+			while (pc >= 0) {
+				sb.append((char)(pc % 26 + 97));
+				pc = pc / 26 - 1;
+			}
+			name = sb.toString();
+
+
+			synchronized (EXISTING_PLACEHOLDERS) {
+				if (!EXISTING_PLACEHOLDERS.contains(name)) {
+					return new PlaceholderType(name, true);
+				}
+			}
 		}
-		return new PlaceholderType(name, true);
+
+		throw new RuntimeException("Failed to generate placeholder name in the allowed number of attempts");
 	}
-	
-	
+
+
 	/**
 	 * True if this placeholder is auto-generated, false if it is user-generated.
 	 */
@@ -124,51 +127,51 @@ public final class PlaceholderType extends UnifyType{
 	public void setVariance(int v) {
 		variance = v;
 	}
-	
+
 	public int getVariance() {
 		return variance;
 	}
-	
+
 	public void reversVariance() {
 		if (variance == 1) {
 			setVariance(-1);
 		} else {
-	    if (variance == -1) {
-			setVariance(1);
-		}}
+			if (variance == -1) {
+				setVariance(1);
+			}}
 	}
-	
+
 	public void setOrCons(byte i) {
 		orCons = i;
 	}
-	
+
 	public byte getOrCons() {
 		return orCons;
 	}
-	
+
 	public Boolean isWildcardable() {
 		return wildcardable;
 	}
 	public void disableWildcardtable() {
 		wildcardable = false;
 	}
-	
+
 	public void enableWildcardtable() {
 		wildcardable = true;
 	}
-	
+
 	public void setWildcardtable(Boolean wildcardable) {
 		this.wildcardable = wildcardable;
 	}
-	
+
 	public Boolean isInnerType() {
 		return innerType;
 	}
-	
+
 	public void setInnerType(Boolean innerType) {
 		this.innerType = innerType;
 	}
-	
+
 	@Override
 	Set<UnifyType> smArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
 		return fc.smArg(this, fBounded);
@@ -178,17 +181,17 @@ public final class PlaceholderType extends UnifyType{
 	Set<UnifyType> grArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
 		return fc.grArg(this, fBounded);
 	}
-	
+
 	@Override
 	public UnifyType setTypeParams(TypeParams newTp) {
 		return this; // Placeholders never have params.
 	}
-	
+
 	@Override
 	public int hashCode() {
 		return typeName.hashCode();
 	}
-	
+
 	@Override
 	UnifyType apply(Unifier unif) {
 		if(unif.hasSubstitute(this)) {
@@ -200,15 +203,15 @@ public final class PlaceholderType extends UnifyType{
 		}
 		return this;
 	}
-	
+
 	@Override
 	public boolean equals(Object obj) {
 		if(!(obj instanceof PlaceholderType))
 			return false;
-		
+
 		return ((PlaceholderType) obj).getName().equals(typeName);
 	}
-	
+
 
 	@Override
 	public Collection<PlaceholderType> getInvolvedPlaceholderTypes() {

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

@@ -0,0 +1,9 @@
+package de.dhbwstuttgart.util;
+
+public class Logger {
+
+  public static void print(String s) {
+    System.out.println(s);
+  }
+
+}