Generics werden eingesetzt. Unvollständiger Zustand

src/mycompiler/SyntaxTreeNode.java

@@ -86,15 +86,17 @@ public abstract class SyntaxTreeNode{
 					tip = that.createTypeInsertPoint((TypePlaceholder) t, result);
 					insertSet.add(tip);//ret.addAll(((TypePlaceholder)t).getTypeInsertPoints(result));
 				}
-			/*
+			
 			//Für den Fall, dass dieser Knoten Generische Variablen halten kann.
 			if(that instanceof Generic && that.getOffset()>=0){
 				//Alle unresolvedTPHs ermitteln und GenericTypeVarInsertPoints bilden:
 				Vector<TypePlaceholder> uTPHs = insertSet.getUnresolvedTPHs();
+				/*
 				for(TypePlaceholder tph : uTPHs){//GenericInsertPoints für diese TPHs bilden:
 					GenericTypeInsertPoint genericTIP = new GenericTypeInsertPoint(that,tph,result);
 					insertSet.add(genericTIP);
 				}
+				*/
 				if(uTPHs.size()>0){//Nur wenn es auch unresolvedTPHs gibt:
 					Vector<Pair> gPairs = result.getConstraintsFor(uTPHs);
 					if(gPairs.size()>0){
@@ -103,7 +105,7 @@ public abstract class SyntaxTreeNode{
 					}
 				}
 			}
-			*/
+			
 		}
 	
 		

src/typinferenz/GenericTypeInsertPoint.java

@@ -127,14 +127,21 @@ public class GenericTypeInsertPoint extends TypeInsertPoint {
     @Override
 	public JavaCodeResult insertType(String fileContent, int additionalOffset) {
     	//TODO: Es kann sein, dass eine Methode bereits Generische Variablen hat, diese müssen dann an diese Liste angefügt werden.
+		
     	return super.insertType(fileContent, additionalOffset);
 	}
 
 	public boolean associatedWith(TypeInsertPoint tip, ResultSet resultSet) {
-		if(!(tip.point instanceof TypePlaceholder))return false;
+		if((tip.type instanceof TypePlaceholder)){
 			Vector<TypePlaceholder> tphs = new Vector<>();
-		tphs.add((TypePlaceholder)tip.point);
+			tphs.add((TypePlaceholder)tip.type);
-		resultSet.getConstraintsFor(tphs);
+			for(Pair p : resultSet.getConstraintsFor(tphs)){
+				if(p.TA1.equals(this.type))return true;
+				if(p.TA2.equals(this.type))return true;
+				if(this.genericPairs.contains(p))return true;
+			}
+		}
+		
 		return false;
 	}
 }

src/typinferenz/typedeployment/TypeInsertSet.java

@@ -16,6 +16,14 @@ import mycompiler.mytype.Pair;
 import mycompiler.mytype.RefType;
 import mycompiler.mytype.TypePlaceholder;
 
+/*
+ * Der Plan:
+ * SyntaxTreeNode generiert die TypeInsertPoints.
+ * Beim Einsetzen eines TIP werden die ebenfalls von den SyntaxTreeNodes berechneten GenericInsertPoints durchsucht nach den Punkten
+ * die mit dem einzusetzenden TIP zusammenhängen.
+ * Das funktioniert mithilfe des ResultSets. Denn es müssen alle Constraints mit einbezogen werden, da der Unify
+ * Algorithmus als Ergebnis nur die zu einem RefType aufgelösten TPHs ausgibt.
+ */
 /**
  * Bündelt ein Set von TypeInsertPoints, die alle zu einem TypePlaceholder gehören.
  * Diese müssen gemeinsam eingesetzt werden.
@@ -86,15 +94,7 @@ public class TypeInsertSet {
 		tpj.add(tip);
 	}
 	
-	/*
+	
-	 * Der Plan:
-	 * SyntaxTreeNode generiert die TypeInsertPoints.
-	 * Beim Einsetzen eines TIP werden die ebenfalls von den SyntaxTreeNodes berechneten GenericInsertPoints durchsucht nach den Punkten
-	 * die mit dem einzusetzenden TIP zusammenhängen.
-	 * Das funktioniert mithilfe des ResultSets. Denn es müssen alle Constraints mit einbezogen werden, da der Unify
-	 * Algorithmus als Ergebnis nur die zu einem RefType aufgelösten TPHs ausgibt.
-	 * 
-	 */
 	
 	/**
 	 * Fügt alle Typen dieses TypeInsertSets in den übergebenen Quellcode ein

test/plugindevelopment/TRMEqualTest.java

@@ -48,8 +48,8 @@ public class TRMEqualTest {
 		addTestNode("Typ1");
 		assertTrue("Nach  dem Anfügen des selben Typs wie zuvor muss das Set immer noch 2 Element enthalten. Und nicht "+replaceSet.size(),replaceSet.size()==2);
 	}
-	private void addTestNode(String type){
 	
+	private void addTestNode(String type){
 		Vector<Pair> resultContent = new Vector<Pair>();
 		Pair pair = new Pair(tph,new RefType(type,0));
 		pair.SetOperator(PairOperator.Equal);