[PLUGIN]: Filter type insert points after insertion.

src/main/java/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java

@@ -10,6 +10,7 @@ import java.util.stream.Collectors;
 public class TypeInsertPoint {
     public Token point;
     private String insertString;
+    private int extraOffset = 0;
 
     public TypeInsertPoint(Token point, String toInsert){
         this.point = point;
@@ -21,19 +22,15 @@ public class TypeInsertPoint {
                 //token.point.getLine() != point.getLine() && token.point.getCharPositionInLine() <= point.getCharPositionInLine()))
                 token.point.getStartIndex() <= point.getStartIndex()))
                 .mapToInt((typeInsertPoint -> typeInsertPoint.insertString.length())).sum();
-        return new StringBuilder(intoSource).insert(point.getStartIndex()+offset, insertString).toString();
+        return new StringBuilder(intoSource).insert(point.getStartIndex()+offset+extraOffset, insertString).toString();
     }
 
     public String getInsertString() {
         return insertString;
     }
        
-    public Token getToken() {
-    	return this.point;
-    }
-    
-    public void setToken(Token point) {
-    	this.point = point;
+    public void addExtraOffset(int toAdd) {
+    	this.extraOffset += toAdd;
     }
     
     /* PL 2018-06-19

src/main/java/de/dhbwstuttgart/typeinference/result/ResultPair.java

@@ -27,4 +27,36 @@ public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric,B ext
     public String toString() {
     	return "(" + left.toString() + ", " + right.toString() + ")";
     }
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((left == null) ? 0 : left.getOffset().hashCode());
+		result = prime * result + ((right == null) ? 0 : right.getOffset().hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		ResultPair<?,?> other = (ResultPair<?,?>) obj;
+		if (left == null) {
+			if (other.left != null)
+				return false;
+		} else if (!left.getOffset().equals(other.left.getOffset()))
+			return false;
+		if (right == null) {
+			if (other.right != null)
+				return false;
+		} else if (!right.getOffset().equals(other.right.getOffset()))
+			return false;
+		return true;
+	}
+   
 }

src/main/java/de/dhbwstuttgart/typeinference/result/ResultPairMap.java

@@ -0,0 +1,25 @@
+package de.dhbwstuttgart.typeinference.result;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.antlr.v4.runtime.Token;
+
+public class ResultPairMap {
+
+	private Map<Token, ResultPair<?,?>> indexMap = new HashMap<>();
+	
+	public static final ResultPairMap RESULT_PAIRS = new ResultPairMap();
+	
+	private ResultPairMap() {
+		// Nothing to do here.
+	}
+	
+	public void put(Token tkn, ResultPair<?, ?> resultPair) {
+		indexMap.put(tkn, resultPair);
+	}
+	
+	public ResultPair<?,?> get(Token tkn) {
+		return indexMap.get(tkn);
+	}
+}

src/main/java/de/dhbwstuttgart/typeinference/result/ResultSet.java

@@ -1,16 +1,31 @@
 package de.dhbwstuttgart.typeinference.result;
 
-import de.dhbwstuttgart.exceptions.NotImplementedException;
-import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.type.*;
-
 import java.util.HashSet;
 import java.util.Set;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
+import static de.dhbwstuttgart.typeinference.result.ResultPairMap.RESULT_PAIRS;
+
+@SuppressWarnings("rawtypes")
 public class ResultSet {
     public final Set<ResultPair> results;
-    public ResultSet(Set<ResultPair> results){
-        this.results = results;
+	public ResultSet(Set<ResultPair> set){
+        this.results = set;
+    }
+    
+    public boolean contains(ResultPair toCheck) {
+    	return this.results.contains(toCheck);
+    }
+    
+    public void remove(ResultPair toCheck) {
+    	results.remove(toCheck);
     }
 
     public ResolvedType resolveType(RefTypeOrTPHOrWildcardOrGeneric type) {
@@ -49,12 +64,14 @@ class Resolver implements ResultSetVisitor {
         toResolve = tph;
         resolved = null;
         System.out.println(tph.toString());
-        for(ResultPair resultPair : result.results){
+        for(ResultPair<?,?> resultPair : result.results) {
+        	RESULT_PAIRS.put(resultPair.getRight().getOffset(), resultPair);
+        	RESULT_PAIRS.put(resultPair.getLeft().getOffset(), resultPair);
             if(resultPair instanceof PairTPHEqualTPH && ((PairTPHEqualTPH) resultPair).getLeft().equals(toResolve)){
                 return resolve(((PairTPHEqualTPH) resultPair).getRight());
             }
         }
-        for(ResultPair resultPair : result.results){
+        for(ResultPair<?,?> resultPair : result.results){
             resultPair.accept(this);
         }
         if(resolved==null){//TPH kommt nicht im Result vor:
@@ -121,6 +138,7 @@ class Resolver implements ResultSetVisitor {
 /**
  * Sucht aus dem Result Set den Sub/supertyp für einen TPH
  */
+@SuppressWarnings("rawtypes")
 class TPHResolver implements ResultSetVisitor {
 
     private final TypePlaceholder tph;
@@ -189,6 +207,7 @@ class TPHResolver implements ResultSetVisitor {
     }
 }
 
+@SuppressWarnings("rawtypes")
 class RelatedTypeWalker implements ResultSetVisitor {
 
     final Set<GenericInsertPair> relatedTPHs = new HashSet<>();