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

@@ -327,6 +327,74 @@ public class JavaTXCompiler {
 				logFile.write(ASTTypePrinter.print(f));
 			}
 			logFile.flush();
+
+			Set<String> methodParaTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().map(y -> y.getParameterList().getFormalparalist().stream().filter(z -> z.getType() instanceof TypePlaceholder).map(z -> ((TypePlaceholder) z.getType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce(new HashSet<String>(), (a, b) -> {
+				a.addAll(b);
+				return a;
+			}, (a, b) -> {
+				a.addAll(b);
+				return a;
+			})).reduce(new HashSet<String>(), (a, b) -> {
+				a.addAll(b);
+				return a;
+			});
+
+			Set<String> constructorParaTypeVarNames = allClasses.stream().map(x -> x.getConstructors().stream().map(y -> y.getParameterList().getFormalparalist().stream().filter(z -> z.getType() instanceof TypePlaceholder).map(z -> ((TypePlaceholder) z.getType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce(new HashSet<String>(), (a, b) -> {
+				a.addAll(b);
+				return a;
+			}, (a, b) -> {
+				a.addAll(b);
+				return a;
+			})).reduce(new HashSet<String>(), (a, b) -> {
+				a.addAll(b);
+				return a;
+			});
+
+			Set<String> paraTypeVarNames = methodParaTypeVarNames;
+			paraTypeVarNames.addAll(constructorParaTypeVarNames);
+
+			Set<String> returnTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder).map(z -> ((TypePlaceholder) z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a, b) -> {
+				a.addAll(b);
+				return a;
+			}).get();
+
+			Set<String> fieldTypeVarNames = allClasses.stream().map(x -> x.getFieldDecl().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder).map(z -> ((TypePlaceholder) z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a, b) -> {
+				a.addAll(b);
+				return a;
+			}).get();
+
+			returnTypeVarNames.addAll(fieldTypeVarNames);
+
+			unifyCons = unifyCons.map(x -> {
+				// Hier muss ueberlegt werden, ob
+				// 1. alle Argument- und Retuntyp-Variablen in allen UnifyPairs
+				// mit disableWildcardtable() werden.
+				// 2. alle Typvariablen mit Argument- oder Retuntyp-Variablen
+				// in Beziehung auch auf disableWildcardtable() gesetzt werden muessen
+				// PL 2018-04-23
+				if ((x.getLhsType() instanceof PlaceholderType)) {
+					if (paraTypeVarNames.contains(x.getLhsType().getName())) {
+						((PlaceholderType) x.getLhsType()).setVariance((byte) 1);
+						((PlaceholderType) x.getLhsType()).disableWildcardtable();
+					}
+					if (returnTypeVarNames.contains(x.getLhsType().getName())) {
+						((PlaceholderType) x.getLhsType()).setVariance((byte) -1);
+						((PlaceholderType) x.getLhsType()).disableWildcardtable();
+					}
+				}
+				if ((x.getRhsType() instanceof PlaceholderType)) {
+					if (paraTypeVarNames.contains(x.getRhsType().getName())) {
+						((PlaceholderType) x.getRhsType()).setVariance((byte) 1);
+						((PlaceholderType) x.getRhsType()).disableWildcardtable();
+					}
+					if (returnTypeVarNames.contains(x.getRhsType().getName())) {
+						((PlaceholderType) x.getRhsType()).setVariance((byte) -1);
+						((PlaceholderType) x.getRhsType()).disableWildcardtable();
+					}
+				}
+				return x;// HIER DIE JEWEILS RECHT BZW. LINKE SEITE AUF GLEICHE VARIANZ SETZEN WIE DIE
+				// JEWEILS ANDERE SEITE
+			});
 			Set<PlaceholderType> varianceTPHold;
 			Set<PlaceholderType> varianceTPH = new HashSet<>();
 			varianceTPH = varianceInheritanceConstraintSet(unifyCons);
@@ -393,6 +461,85 @@ public class JavaTXCompiler {
 			logFile.write(ASTTypePrinter.print(sf));
 			System.out.println(ASTTypePrinter.print(sf));
 			logFile.flush();
+
+			Set<String> methodParaTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().map(y -> y.getParameterList().getFormalparalist().stream().filter(z -> z.getType() instanceof TypePlaceholder).map(z -> ((TypePlaceholder) z.getType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce(new HashSet<String>(), (a, b) -> {
+				a.addAll(b);
+				return a;
+			}, (a, b) -> {
+				a.addAll(b);
+				return a;
+			})).reduce(new HashSet<String>(), (a, b) -> {
+				a.addAll(b);
+				return a;
+			});
+
+			Set<String> constructorParaTypeVarNames = allClasses.stream().map(x -> x.getConstructors().stream().map(y -> y.getParameterList().getFormalparalist().stream().filter(z -> z.getType() instanceof TypePlaceholder).map(z -> ((TypePlaceholder) z.getType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce(new HashSet<String>(), (a, b) -> {
+				a.addAll(b);
+				return a;
+			}, (a, b) -> {
+				a.addAll(b);
+				return a;
+			})).reduce(new HashSet<String>(), (a, b) -> {
+				a.addAll(b);
+				return a;
+			});
+
+			Set<String> paraTypeVarNames = methodParaTypeVarNames;
+			paraTypeVarNames.addAll(constructorParaTypeVarNames);
+
+			Set<String> returnTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder).map(z -> ((TypePlaceholder) z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a, b) -> {
+				a.addAll(b);
+				return a;
+			}).get();
+
+			Set<String> fieldTypeVarNames = allClasses.stream().map(x -> x.getFieldDecl().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder).map(z -> ((TypePlaceholder) z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a, b) -> {
+				a.addAll(b);
+				return a;
+			}).get();
+
+			returnTypeVarNames.addAll(fieldTypeVarNames);
+
+			unifyCons = unifyCons.map(x -> {
+				// Hier muss ueberlegt werden, ob
+				// 1. alle Argument- und Retuntyp-Variablen in allen UnifyPairs
+				// mit disableWildcardtable() werden.
+				// 2. alle Typvariablen mit Argument- oder Retuntyp-Variablen
+				// in Beziehung auch auf disableWildcardtable() gesetzt werden muessen
+				// PL 2018-04-23
+				if ((x.getLhsType() instanceof PlaceholderType)) {
+					if (paraTypeVarNames.contains(x.getLhsType().getName())) {
+						((PlaceholderType) x.getLhsType()).setVariance((byte) 1);
+						((PlaceholderType) x.getLhsType()).disableWildcardtable();
+					}
+					if (returnTypeVarNames.contains(x.getLhsType().getName())) {
+						((PlaceholderType) x.getLhsType()).setVariance((byte) -1);
+						((PlaceholderType) x.getLhsType()).disableWildcardtable();
+					}
+				}
+				if ((x.getRhsType() instanceof PlaceholderType)) {
+					if (paraTypeVarNames.contains(x.getRhsType().getName())) {
+						((PlaceholderType) x.getRhsType()).setVariance((byte) 1);
+						((PlaceholderType) x.getRhsType()).disableWildcardtable();
+					}
+					if (returnTypeVarNames.contains(x.getRhsType().getName())) {
+						((PlaceholderType) x.getRhsType()).setVariance((byte) -1);
+						((PlaceholderType) x.getRhsType()).disableWildcardtable();
+					}
+				}
+				return x;// HIER DIE JEWEILS RECHT BZW. LINKE SEITE AUF GLEICHE VARIANZ SETZEN WIE DIE
+				// JEWEILS ANDERE SEITE
+			});
+
+			// PL 2020-02-05 alle Oder-Constraints Receiver und Parameter werden auf
+			// variance 1 gesetzt
+			// Es wird davon ausgegangen, dass in OderConstraints in Bedingungen für
+			// Parameter die Typen der Argumente links stehen
+			// und die Typen der Rückgabewerte immer rechts stehen
+
+			/*
+			 * unifyCons.getOderConstraints().forEach(z -> z.forEach(y -> y.forEach(x -> { if ((x.getLhsType() instanceof PlaceholderType) && x.getPairOp().compareTo(PairOperator.SMALLERDOT) == 0) { ((PlaceholderType) x.getLhsType()).setVariance((byte)1); } else if ((x.getRhsType() instanceof PlaceholderType) && x.getPairOp().compareTo(PairOperator.EQUALSDOT) == 0) { ((PlaceholderType) x.getRhsType()).setVariance((byte)-1); } })));
+			 */
+
 			System.out.println("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
 			Set<PlaceholderType> varianceTPHold;
 			Set<PlaceholderType> varianceTPH = new HashSet<>();

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

@@ -125,7 +125,7 @@ public class StatementGenerator {
         this.superClass = superType;
     }
 
-    public ParameterList convert(Java17Parser.FormalParameterListContext formalParameterListContext, boolean methodparameters) {
+    public ParameterList convert(Java17Parser.FormalParameterListContext formalParameterListContext) {
         List<Pattern> ret = new ArrayList<>();
         List<Java17Parser.FormalParameterContext> fps = new ArrayList<>();
         if (Objects.isNull(formalParameterListContext))
@@ -147,9 +147,7 @@ public class StatementGenerator {
                 if (fp.typeType() != null) {
                     type = TypeGenerator.convert(fp.typeType(), reg, generics);
                 } else {
-                	type = methodparameters?
-                			TypePlaceholder.fresh(fp.getStart(), 1, false) 
-                			: TypePlaceholder.fresh(fp.getStart());
+                    type = TypePlaceholder.fresh(fp.getStart());
                 }
                 ret.add(new FormalParameter(paramName, type, fp.getStart()));
                 localVars.put(paramName, type);
@@ -1104,7 +1102,7 @@ public class StatementGenerator {
             }
             params = new ParameterList(parameterList, lambdaParams.getStart());
         } else if (lambdaParams.formalParameterList() != null) {
-            params = convert(lambdaParams.formalParameterList(), false);
+            params = convert(lambdaParams.formalParameterList());
             // }else if( lambdaParams.inferredFormalParameterList != null){
         } else if (!Objects.isNull(lambdaParams.lambdaLVTIList())) {
             List<Pattern> parameterList = new ArrayList<>();

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

@@ -435,7 +435,7 @@ public class SyntaxTreeGenerator {
       }
     }
     StatementGenerator stmtgen = new StatementGenerator(superClass, compiler, reg, generics, fields, new HashMap<>());
-    ParameterList paramlist = stmtgen.convert(bodydeclaration.formalParameters().formalParameterList(), true);
+    ParameterList paramlist = stmtgen.convert(bodydeclaration.formalParameters().formalParameterList());
     MethodBodyContext body = bodydeclaration.methodBody();
     Block block = null;
     if (!(body instanceof EmptymethodContext)) {
@@ -532,7 +532,7 @@ public class SyntaxTreeGenerator {
 
     RefTypeOrTPHOrWildcardOrGeneric retType;
     if (Objects.isNull(header.refType())) {
-      retType = TypePlaceholder.fresh(header.getStart(), -1, false);
+      retType = TypePlaceholder.fresh(header.getStart());
     } else {
       if (header.refType() instanceof RefType2Context reftype) {
         retType = TypeGenerator.convert(reftype.typeType(), reg, generics);
@@ -541,7 +541,7 @@ public class SyntaxTreeGenerator {
       }
     }
     StatementGenerator stmtgen = new StatementGenerator(superClass, compiler, reg, localgenerics, fields, new HashMap<>());
-    ParameterList paramlist = stmtgen.convert(header.formalParameters().formalParameterList(), true);
+    ParameterList paramlist = stmtgen.convert(header.formalParameters().formalParameterList());
     MethodBodyContext body = methoddeclaration.methodBody();
     Block block = null;
     if (body instanceof EmptymethodContext emptymethod) {
@@ -581,7 +581,7 @@ public class SyntaxTreeGenerator {
     }
     RefTypeOrTPHOrWildcardOrGeneric retType = TypeGenerator.convertTypeName(name, constructordeclaration.getStart(), reg, localgenerics);
     StatementGenerator stmtgen = new StatementGenerator(superClass, compiler, reg, localgenerics, fields, new HashMap<>());
-    ParameterList paramlist = stmtgen.convert(constructordeclaration.formalParameters().formalParameterList(), true);
+    ParameterList paramlist = stmtgen.convert(constructordeclaration.formalParameters().formalParameterList());
     Block block = prepareBlock(stmtgen.convert(constructordeclaration.constructorBody, true), superClass);
     return new Constructor(modifiers, name, retType, paramlist, block, gtvDeclarations, constructordeclaration.getStart());
   }
@@ -594,7 +594,7 @@ public class SyntaxTreeGenerator {
     } else {
       // PL 2019-12-06: variableDeclaratorList() eingefuegt, um als Token nicht die
       // Modifier zu bekommen
-      fieldType = TypePlaceholder.fresh(fieldDeclContext.variableDeclarators().getStart(), -1, false);
+      fieldType = TypePlaceholder.fresh(fieldDeclContext.variableDeclarators().getStart());
     }
     for (Java17Parser.VariableDeclaratorContext varDecl : fieldDeclContext.variableDeclarators().variableDeclarator()) {
       String fieldName = varDecl.variableDeclaratorId().getText();

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

@@ -129,10 +129,9 @@ public class UnifyTypeFactory {
     	if (tph.getName().equals("AFR")) {
     		System.out.println("XXX"+innerType);
     	}
-    	PlaceholderType ntph = new PlaceholderType(tph.getName(), tph.getVariance());
+    	PlaceholderType ntph = new PlaceholderType(tph.getName());
     	ntph.setVariance(tph.getVariance());
     	ntph.setOrCons(tph.getOrCons());
-    	ntph.setWildcardtable(tph.getWildcardtable());
     	int in = PLACEHOLDERS.indexOf(ntph);
 		if (in == -1) {
 			PLACEHOLDERS.add(ntph);

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

@@ -21,17 +21,9 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
 	private final String name;
 	
 	/**
-     * variance shows the variance of the pair
-     * 1: contravariant
-     * -1 covariant
-     * 0 invariant
-     */
-	private int variance = 0;
-	
-	/**
-	 * isWildcardable gibt an, ob ein Wildcardtyp dem PlaceholderType zugeordnet werden darf 
+	 * wird im Generate Generics Teil nach der Rueckumwandlung nach dem Unify genutzt
 	 */
-	private boolean wildcardable = true;
+	private int variance = 0;
 	
 	/*
      * Fuer Oder-Constraints:
@@ -47,12 +39,10 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
      * Factory-Methode <code>fresh()</code> erzeugt.
      * <br>Author: J�rg B�uerle
      */
-    private TypePlaceholder(String name, Token offset, int variance, boolean wildcardable)
+    private TypePlaceholder(String name, Token offset)
     {
         super(offset);
         this.name = name;
-        this.variance = variance;
-        this.wildcardable = wildcardable;
     }
     
     
@@ -63,15 +53,11 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
      * @return
      */
     public static TypePlaceholder fresh(Token position){
-		return new TypePlaceholder(NameGenerator.makeNewName(), position, 0, true);
-    }
-    
-    public static TypePlaceholder fresh(Token position, int variance, boolean wildcardable){
-		return new TypePlaceholder(NameGenerator.makeNewName(), position, variance, wildcardable);
+		return new TypePlaceholder(NameGenerator.makeNewName(), position);
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric of(String name) {
-        return new TypePlaceholder(name, new NullToken(),0, true);
+        return new TypePlaceholder(name, new NullToken());
     }
 
 
@@ -134,9 +120,4 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
 	public byte getOrCons() {
 		return orCons;
 	}
-
-
-	public Boolean getWildcardtable() {
-		return wildcardable;
-	}
 }

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

@@ -822,9 +822,9 @@ public class TYPEStmt implements StatementVisitor {
     public void visit(Switch switchStmt) {
         switchStack.push(switchStmt);
 
-        if(switchStmt.getSwitch().getType() instanceof TypePlaceholder){
-            ((TypePlaceholder) switchStmt.getSwitch().getType()).setVariance(-1);
-        }
+        //if(switchStmt.getSwitch().getType() instanceof TypePlaceholder){
+        //    ((TypePlaceholder) switchStmt.getSwitch().getType()).setVariance(1);
+        //}
 
         RefTypeOrTPHOrWildcardOrGeneric caseExpressionType = null;
         for (var child : switchStmt.getBlocks()) {

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

@@ -53,8 +53,8 @@ public final class PlaceholderType extends UnifyType{
 	
 	/**
      * variance shows the variance of the pair
-     * 1: contravariant
-     * -1 covariant
+     * -1: contravariant
+     * 1 covariant
      * 0 invariant
      * PL 2018-03-21
      */
@@ -77,14 +77,6 @@ public final class PlaceholderType extends UnifyType{
 		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 
 	 * @param isGenerated true if this placeholder is auto-generated, false if it is user-generated.

src/test/java/TestComplete.java

@@ -721,7 +721,7 @@ public class TestComplete {
         var list2 = listCtor.newInstance("D", listCtor.newInstance("E", elemCtor.newInstance("F")));
 
         var instance = clazz.getDeclaredConstructor().newInstance();
-        var appendMethod = clazz.getDeclaredMethod("append", linkedElemClass, listClass);
+        var appendMethod = clazz.getDeclaredMethod("append", Object.class, listClass);
 
         var res = appendMethod.invoke(instance, list2, list1);
         var expected = listCtor.newInstance("D", listCtor.newInstance("E", listCtor.newInstance("F", listCtor.newInstance("A", listCtor.newInstance("B", elemCtor.newInstance("C"))))));