Merge branch 'bigRefactoring' of ssh://gohorb.ba-horb.de/bahome/projekt/git/JavaCompilerCore into bytecode2

src/de/dhbwstuttgart/bytecode/signature/Signature.java

@@ -10,12 +10,10 @@ import org.objectweb.asm.signature.SignatureWriter;
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Constructor;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
@@ -165,7 +163,7 @@ public class Signature {
 	 * @param genAndBounds 
 	 */
 	private void getBoundsOfTypeVar(GenericTypeVar g, HashMap<String, String> genAndBounds) {
-		sw.visitFormalTypeParameter(g.getParsedName());
+		sw.visitFormalTypeParameter(g.getName());
 		
 		Iterator<? extends RefTypeOrTPHOrWildcardOrGeneric> bItr = g.getBounds().iterator(); 
 		while(bItr.hasNext()) {
@@ -174,7 +172,7 @@ public class Signature {
 //			System.out.println("GetBounds: " + boundDesc);
 			// Ensure that <...> extends java.lang.Object OR ...
 			sw.visitClassBound().visitClassType(boundDesc);
-			genAndBounds.put(g.getParsedName(), boundDesc);
+			genAndBounds.put(g.getName(), boundDesc);
 		}
 		sw.visitClassBound().visitEnd();
 	}

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

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
 import de.dhbwstuttgart.exceptions.DebugException;
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
@@ -51,11 +50,11 @@ public class FCGenerator {
         HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> newGTVs = new HashMap<>();
         //Generics mit gleichem Namen müssen den selben TPH bekommen
         for(GenericTypeVar gtv : forType.getGenerics()){
-            if(!gtvs.containsKey(gtv.getParsedName())){
+            if(!gtvs.containsKey(gtv.getName())){
-                gtvs.put(gtv.getParsedName(), TypePlaceholder.fresh(new NullToken()));
+                gtvs.put(gtv.getName(), TypePlaceholder.fresh(new NullToken()));
-                newGTVs.put(gtv.getParsedName(), TypePlaceholder.fresh(new NullToken()));
+                newGTVs.put(gtv.getName(), TypePlaceholder.fresh(new NullToken()));
             }
-            params.add(gtvs.get(gtv.getParsedName()));
+            params.add(gtvs.get(gtv.getName()));
         }
 
         Optional<ClassOrInterface> hasSuperclass = availableClasses.stream().filter(cl -> forType.getSuperClass().getName().equals(cl.getClassName())).findAny();
@@ -79,7 +78,7 @@ public class FCGenerator {
             RefTypeOrTPHOrWildcardOrGeneric setType = itSetParams.next();
             //In diesem Typ die GTVs durch TPHs und Einsetzungen austauschen:
             RefTypeOrTPHOrWildcardOrGeneric setSetType = setType.acceptTV(new TypeExchanger(gtvs));
-            newGTVs.put(itGenParams.next().getParsedName(), setSetType);
+            newGTVs.put(itGenParams.next().getName(), setSetType);
         }
 
         RefTypeOrTPHOrWildcardOrGeneric superType = forType.getSuperClass().acceptTV(new TypeExchanger(newGTVs));

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

@@ -3,8 +3,8 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 
 public class GenericContext {
-    public final String parentMethod;
+    private final String parentMethod;
-    public final JavaClassName parentClass;
+    private final JavaClassName parentClass;
 
     public GenericContext(JavaClassName parentClass, String parentMethod) {
         if(parentMethod == null)parentMethod = "";

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

@@ -3,7 +3,6 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
@@ -75,7 +74,7 @@ public class TypeGenerator {
         //Problem <A extends B, B> ist erlaubt, würde aber bei den Bounds von A den Generic B nicht als solchen erkennen
         List<RefTypeOrTPHOrWildcardOrGeneric> bounds = TypeGenerator.convert(typeParameter.typeBound(),reg, generics);
 
-        GenericTypeVar ret = new GenericTypeVar(new GenericTypeName(new GenericContext(parentClass, parentMethod), name), bounds, typeParameter.getStart(), typeParameter.getStop());
+        GenericTypeVar ret = new GenericTypeVar(name, bounds, typeParameter.getStart(), typeParameter.getStop());
         generics.put(name, new GenericContext(parentClass, parentMethod));
         return ret;
     }
@@ -133,7 +132,7 @@ public class TypeGenerator {
             String name, Java8Parser.TypeArgumentsContext typeArguments, Token offset, JavaClassRegistry reg, GenericsRegistry generics){
         if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein
             if(generics.contains(name)){
-                return new GenericRefType(new GenericTypeName(generics.get(name),name), offset);
+                return new GenericRefType(name, offset);
             }else{
                 throw new TypeinferenceException("Der Typ "+ name + " ist nicht vorhanden",offset);
             }

src/de/dhbwstuttgart/parser/scope/GenericTypeName.java

@@ -1,26 +0,0 @@
-package de.dhbwstuttgart.parser.scope;
-
-import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
-
-public class GenericTypeName extends JavaClassName {
-    private final static String DELIMITER = "%";
-
-    private final JavaClassName parentClass;
-    private final String methodName;
-
-    public GenericTypeName(GenericContext genericContext, String name) {
-        super(name);
-        this.parentClass = genericContext.parentClass;
-        this.methodName = genericContext.parentMethod;
-    }
-
-    public String getUniqueIdentifier() {
-        return parentClass.toString()
-                + DELIMITER + methodName
-                + DELIMITER + super.toString();
-    }
-
-    public JavaClassName getParentClass() {
-        return parentClass;
-    }
-}

src/de/dhbwstuttgart/sat/asp/writer/ASPGenerator.java

@@ -2,12 +2,10 @@ package de.dhbwstuttgart.sat.asp.writer;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.sat.asp.ASPStringConverter;
 import de.dhbwstuttgart.sat.asp.writer.model.*;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
@@ -100,7 +98,7 @@ public class ASPGenerator {
 
         @Override
         public ASPType visit(GenericRefType genericRefType) {
-            return new ASPRefType(ASPStringConverter.toConstant(genericRefType.getName()),
+            return new ASPRefType(ASPStringConverter.toConstant(genericRefType.getParsedName()),
                     new ASPParameterList(new ArrayList<>(), writer));
         }
     }

src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java

@@ -1,7 +1,5 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 
 import org.antlr.v4.runtime.Token;
@@ -26,9 +24,9 @@ public class GenericTypeVar extends SyntaxTreeNode
      */
     List<? extends RefTypeOrTPHOrWildcardOrGeneric> bounds=new ArrayList<RefTypeOrTPHOrWildcardOrGeneric>();
 	private Token endOffset;
-    private GenericTypeName name;
+    private String name;
 
-    public GenericTypeVar(GenericTypeName s, List<? extends RefTypeOrTPHOrWildcardOrGeneric> bounds, Token offset, Token endOffset)
+    public GenericTypeVar(String s, List<? extends RefTypeOrTPHOrWildcardOrGeneric> bounds, Token offset, Token endOffset)
     {
         super(offset);
         name = s;
@@ -50,18 +48,15 @@ public class GenericTypeVar extends SyntaxTreeNode
         return "BoGTV " + this.name;
     }
 
-    public GenericTypeName getName() {
+    public String getName(){
-        return name;
-    }
-
-    public String getParsedName(){
         return name.toString();
     }
 
+    /*
     public JavaClassName definingClass(){
         return name.getParentClass();
     }
-
+*/
     @Override
     public void accept(ASTVisitor visitor) {
         visitor.visit(this);

src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java

@@ -8,7 +8,6 @@ import java.util.List;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.Field;
@@ -43,12 +42,17 @@ public class ASTFactory {
 		}
 		int modifier = jreClass.getModifiers();
 		boolean isInterface = jreClass.isInterface();
+		//see: https://stackoverflow.com/questions/9934774/getting-generic-parameter-from-supertype-class
+		ParameterizedType parameterSuperClass = null;
+		Type tempSuperClass = jreClass.getGenericSuperclass();
+		if(tempSuperClass != null && tempSuperClass instanceof ParameterizedType)
+			parameterSuperClass = (ParameterizedType) tempSuperClass;
 		java.lang.Class superjreClass = jreClass.getSuperclass();
 		RefType superClass;
 		if(superjreClass != null){
 			List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
 			for(TypeVariable tv : superjreClass.getTypeParameters()){
-				params.add(new GenericRefType(new GenericTypeName(new GenericContext( name, null),tv.getName()), new NullToken()));
+				params.add(new GenericRefType(tv.getName(), new NullToken()));
 			}
 			superClass = new RefType(new JavaClassName(superjreClass.getName()), params, new NullToken());
 		}else{//Jede Klasse und jedes Interface erbt von Object: (auch Object selbst!)
@@ -65,6 +69,22 @@ public class ASTFactory {
 		return new ClassOrInterface(modifier, name, felder, methoden, konstruktoren, genericDeclarationList, superClass,isInterface, implementedInterfaces, offset);
 	}
 
+	private static RefTypeOrTPHOrWildcardOrGeneric convertType(Type type){
+		JavaClassName name = null;
+		List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+		if(type instanceof ParameterizedType){
+			for(Type paramType : ((ParameterizedType)type).getActualTypeArguments()){
+				params.add(convertType(paramType));
+			}
+		}else if(type instanceof TypeVariable){
+
+		}else if(type instanceof Class){
+			Class paramClass = (Class) type;
+			//params.add(new RefType(paramClass.getName())
+		}else throw new NotImplementedException();
+		return new RefType(name, params, new NullToken());
+	}
+
 	private static Field createField(java.lang.reflect.Field field, JavaClassName jreClass) {
 		return new Field(field.getName(), createType(field.getType(), jreClass, null), field.getModifiers(), new NullToken());
 	}
@@ -153,9 +173,7 @@ public class ASTFactory {
 		}else{
 			if(type instanceof TypeVariable){
 				//GTVDeclarationContext via "(TypeVariable) type).getGenericDeclaration()"
-				return new GenericRefType(
+				return new GenericRefType(type.getTypeName(), new NullToken());
-						new GenericTypeName(new GenericContext(parentClass, parentMethod),type.getTypeName()),
-						new NullToken());
 			}
 			List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
 			if(type instanceof ParameterizedType){
@@ -177,9 +195,7 @@ public class ASTFactory {
 				genericBounds.add((RefType) createType(bound, parentClass, parentMethod));
 			}
 		}
-		return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(
+		return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(jreTVName, genericBounds, new NullToken(), new NullToken());
-				new GenericTypeName(new GenericContext(parentClass, parentMethod), jreTVName)
-				, genericBounds, new NullToken(), new NullToken());
 	}
 
 	public static ClassOrInterface createObjectClass() {

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

@@ -1,12 +1,17 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
 import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
+import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.sat.asp.model.ASPRule;
+import de.dhbwstuttgart.sat.asp.parser.ASPParser;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.syntaxtree.type.Void;
@@ -72,6 +77,16 @@ public class UnifyTypeFactory {
     }
 
     public static UnifyType convert(RefType t){
+        //Check if it is a FunN Type:
+        Pattern p = Pattern.compile("Fun(\\d+)");
+        Matcher m = p.matcher(t.getName().toString());
+        boolean b = m.matches();
+        if(b){
+            Integer N = Integer.valueOf(m.group(1));
+            if((N + 1) == t.getParaList().size()){
+                return convert(new FunN(t.getParaList()));
+            }
+        }
         UnifyType ret;
         if(t.getParaList() != null && t.getParaList().size() > 0){
             List<UnifyType> params = new ArrayList<>();

src/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java

@@ -1,25 +1,19 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
 import org.antlr.v4.runtime.Token;
 
 public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
 {
-    private GenericTypeName name;
+    private String name;
 
-    public GenericRefType(GenericTypeName name, Token offset)
+    public GenericRefType(String name, Token offset)
     {
         super(offset);
         this.name = name;
     }
 
-    public GenericTypeName getName(){
-        return name;
-    }
-
     public String getParsedName(){
         return name.toString();
     }

src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java

@@ -30,7 +30,7 @@ public class SuperWildcardType extends WildcardType{
 	* Beispiel: ? super Integer.
 	* Integer wird zurückgegeben.
 	*/
-	public RefTypeOrTPHOrWildcardOrGeneric get_SuperType()
+	public RefTypeOrTPHOrWildcardOrGeneric getInnerType()
 	{
 		return this.innerType;
 	}

src/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.syntaxtree.visual;
 
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@@ -171,7 +170,7 @@ public class OutputGenerator implements ASTVisitor{
 
     @Override
     public void visit(GenericRefType genericRefType) {
-        out.append(genericRefType.getName().toString());
+        out.append(genericRefType.getParsedName().toString());
     }
 
     @Override

src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java

@@ -126,7 +126,7 @@ class TypeToInsertString implements ResultSetVisitor{
 
     @Override
     public void visit(GenericRefType genericRefType) {
-        insert += genericRefType.getName();
+        insert += genericRefType.getParsedName();
     }
 
     @Override

src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java

@@ -1,8 +1,6 @@
 package de.dhbwstuttgart.typeinference.assumptions;
 
 import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
@@ -29,8 +27,7 @@ public class FunNClass extends ClassOrInterface {
     private static GenericDeclarationList createGenerics(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
         List<GenericTypeVar> generics = new ArrayList<>();
         for(RefTypeOrTPHOrWildcardOrGeneric param : funNParams){
-            generics.add(new GenericTypeVar(new GenericTypeName(new GenericContext(
+            generics.add(new GenericTypeVar(NameGenerator.makeNewName(),
-                    new JavaClassName("Fun"+(funNParams.size()-1)), null), NameGenerator.makeNewName()),
                     new ArrayList<>(), new NullToken(), new NullToken()));
         }
         return new GenericDeclarationList(generics, new NullToken());

src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java

@@ -3,9 +3,7 @@ package de.dhbwstuttgart.typeinference.assumptions;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.TypeScope;
-import de.dhbwstuttgart.syntaxtree.statement.Assign;
 import de.dhbwstuttgart.syntaxtree.type.FunN;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
@@ -14,7 +12,6 @@ import de.dhbwstuttgart.typeinference.constraints.GenericsResolver;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
 
 public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;

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

@@ -4,7 +4,6 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
-import de.dhbwstuttgart.parser.antlr.Java8Parser;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@@ -187,6 +186,7 @@ public class TYPEStmt implements StatementVisitor{
 
     private final RefType number = new RefType(ASTFactory.createClass(Number.class).getClassName(), new NullToken());
     private final RefType string = new RefType(ASTFactory.createClass(String.class).getClassName(), new NullToken());
+    private final RefType bool =  new RefType(ASTFactory.createClass(Boolean.class).getClassName(), new NullToken());
     @Override
     public void visit(UnaryExpr unaryExpr) {
         if(unaryExpr.operation == UnaryExpr.Operation.POSTDECREMENT ||
@@ -205,6 +205,7 @@ public class TYPEStmt implements StatementVisitor{
 
     @Override
     public void visit(BinaryExpr binary) {
+
         if(binary.operation.equals(BinaryExpr.Operator.DIV) ||
                 binary.operation.equals(BinaryExpr.Operator.MUL)||
                 binary.operation.equals(BinaryExpr.Operator.MOD)||
@@ -216,9 +217,12 @@ public class TYPEStmt implements StatementVisitor{
             //Expression muss zu Numeric Convertierbar sein. also von Numeric erben
             numeric.add(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
             numeric.add(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
-            //The type of a multiplicative expression is the promoted type of its operands.
+            /*
-            numeric.add(new Pair(binary.rexpr.getType(), binary.getType(), PairOperator.SMALLERDOT));
+            In Java passiert bei den binären Operatoren eine sogenannte Type Promotion:
-            numeric.add(new Pair(binary.lexpr.getType(), binary.getType(), PairOperator.SMALLERDOT));
+            https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.6.2
+            Das bedeutet, dass Java die Typen je nach belieben castet, so lange sie nur von Number erben
+             */
+            numeric.add(new Pair(binary.getType(), number, PairOperator.SMALLERDOT));
             numericAdditionOrStringConcatenation.add(numeric);
             if(binary.operation.equals(BinaryExpr.Operator.ADD)) {
                 //Dann kann der Ausdruck auch das aneinanderfügen zweier Strings sein: ("a" + "b") oder (1 + 2)
@@ -229,7 +233,15 @@ public class TYPEStmt implements StatementVisitor{
                 numericAdditionOrStringConcatenation.add(stringConcat);
             }
             constraintsSet.addOderConstraint(numericAdditionOrStringConcatenation);
-        }else {
+        }else if(binary.operation.equals(BinaryExpr.Operator.LESSEQUAL) ||
+                binary.operation.equals(BinaryExpr.Operator.BIGGEREQUAL) ||
+                binary.operation.equals(BinaryExpr.Operator.BIGGERTHAN) ||
+                binary.operation.equals(BinaryExpr.Operator.LESSTHAN)){
+            constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
+            constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
+            //Rückgabetyp ist Boolean
+            constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.EQUALSDOT));
+        }else{
                 throw new NotImplementedException();
         }
     }
@@ -330,7 +342,7 @@ public class TYPEStmt implements StatementVisitor{
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
         for(GenericTypeVar gtv : receiverCl.getGenerics()){
             //Die Generics werden alle zu TPHs umgewandelt.
-            params.add(resolver.resolve(gtv.getParsedName()));
+            params.add(resolver.resolve(gtv.getName()));
         }
 
         RefTypeOrTPHOrWildcardOrGeneric receiverType = new RefType(assumption.getReceiver().getClassName(), params, forMethod.getOffset());

test/asp/ClingoTest.java

@@ -20,7 +20,6 @@ import java.io.*;
 import java.util.*;
 
 public class ClingoTest {
-    public static final String rootDirectory = "~/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards";
     public static final String tempDirectory = "/tmp/";
     private final TypePlaceholder testType = TypePlaceholder.fresh(new NullToken());
     @Test

test/asp/UnifyWithoutWildcards.java

@@ -1,29 +1,98 @@
 package asp;
 
 import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.sat.asp.Clingo;
+import de.dhbwstuttgart.sat.asp.parser.ASPParser;
+import de.dhbwstuttgart.sat.asp.writer.ASPGenerator;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import org.junit.Test;
 
-import java.util.Collection;
+import java.io.File;
-import java.util.HashSet;
+import java.io.IOException;
-import java.util.Set;
+import java.io.PrintWriter;
+import java.sql.Ref;
+import java.util.*;
 
 public class UnifyWithoutWildcards {
 
-    public Collection<ClassOrInterface> getFC() {
+    public static final String tempDirectory = "/tmp/";
-        Set<ClassOrInterface> ret = new HashSet<>();
+
-        ret.add(ASTFactory.createObjectClass());
+    @Test
-        ret.add(ASTFactory.createClass(java.util.List.class));
+    public void adapt() throws InterruptedException, IOException, ClassNotFoundException {
+        ConstraintSet<Pair> testSet = new ConstraintSet<>();
+        List<RefTypeOrTPHOrWildcardOrGeneric> list = Arrays.asList(TypePlaceholder.fresh(new NullToken()));
+        RefType t1 = new RefType(new JavaClassName("Matrix"), new NullToken());
+        RefType t2 = new RefType(new JavaClassName("Vector"), list, new NullToken());
+        testSet.addUndConstraint(new Pair(t1, t2, PairOperator.SMALLERDOT));
+        run(testSet);
+    }
+
+    public ResultSet run(ConstraintSet<Pair> toTest) throws IOException, InterruptedException, ClassNotFoundException {
+        String content = "";
+        content = new ASPGenerator(toTest, this.getFC()).getASP();
+
+        PrintWriter writer = new PrintWriter(tempDirectory + "test.lp", "UTF-8");
+        writer.println(content);
+        writer.close();
+        Clingo clingo = new Clingo(Arrays.asList(new File(tempDirectory + "test.lp")));
+        String result = clingo.runClingo();
+        ResultSet resultSet = ASPParser.parse(result, getInvolvedTPHS(toTest));
+        return resultSet;
+    }
+
+    private static class TPHExtractor implements TypeVisitor<List<TypePlaceholder>>{
+        @Override
+        public List<TypePlaceholder> visit(RefType refType) {
+            ArrayList<TypePlaceholder> ret = new ArrayList<>();
+            for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
+                ret.addAll(param.acceptTV(this));
+            }
+            return ret;
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(SuperWildcardType superWildcardType) {
+            return superWildcardType.getInnerType().acceptTV(this);
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(TypePlaceholder typePlaceholder) {
+            return Arrays.asList(typePlaceholder);
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(ExtendsWildcardType extendsWildcardType) {
+            return extendsWildcardType.getInnerType().acceptTV(this);
+        }
+
+        @Override
+        public List<TypePlaceholder> visit(GenericRefType genericRefType) {
+            return new ArrayList<>();
+        }
+    }
+    private Collection<TypePlaceholder> getInvolvedTPHS(ConstraintSet<Pair> toTest) {
+        List<TypePlaceholder> ret = new ArrayList<>();
+        toTest.map((Pair p)-> {
+            ret.addAll(p.TA1.acceptTV(new TPHExtractor()));
+            ret.addAll(p.TA2.acceptTV(new TPHExtractor()));
+            return p;
+        });
         return ret;
     }
 
-    public ConstraintSet<Pair> getPairs() {
+    private Collection<ClassOrInterface> getFC() {
-        ConstraintSet<Pair> ret = new ConstraintSet<>();
+        Set<ClassOrInterface> ret = new HashSet<>();
-        ret.addUndConstraint(new Pair(TypePlaceholder.fresh(new NullToken()), ASTFactory.createObjectType(), PairOperator.SMALLERDOT));
+        ret.add(ASTFactory.createClass(Matrix.class));
+        //ret.add(ASTFactory.createObjectClass());
+        //ret.add(ASTFactory.createClass(java.util.List.class));
         return ret;
     }
+    private class Matrix<A> extends HashMap<A,Map<Integer, A>>{}
 }

test/javFiles/AddLong.jav

@@ -0,0 +1,9 @@
+import java.lang.Integer;
+import java.lang.Long;
+
+public class AddLong{
+		add(Integer a, Long b) {
+    		Long c = a+b;
+    		return c;
+    	}
+}

test/javFiles/Faculty.jav

@@ -6,14 +6,10 @@ class Faculty {
   	return x;
    }
 
-  Fun1<java.lang.Integer,java.lang.Integer> m () {
+  m () {
    var fact = (Integer x) -> {
         return mul(x, fact.apply(x));
    };
    return fact;
   }
-}
-
-interface Fun1<A,B>{
-    B apply(A a);
 }

test/javFiles/FacultyTyped.jav

@@ -0,0 +1,19 @@
+import java.lang.Integer;
+
+class Faculty {
+
+  Integer mul(Integer x, Integer y) {
+  	return x;
+   }
+
+  Fun1<java.lang.Integer,java.lang.Integer> m () {
+   var fact = (Integer x) -> {
+        return mul(x, fact.apply(x));
+   };
+   return fact;
+  }
+}
+
+interface Fun1<A,B>{
+    B apply(A a);
+}

test/typeinference/JavaTXCompilerTest.java

@@ -53,6 +53,10 @@ public class JavaTXCompilerTest {
         execute(new File(rootDirectory+"Faculty.jav"));
     }
     @Test
+    public void facultyTyped() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"FacultyTyped.jav"));
+    }
+    @Test
     public void matrix() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"Matrix.jav"));
     }
@@ -68,6 +72,10 @@ public class JavaTXCompilerTest {
     public void expressions() throws IOException, ClassNotFoundException {
         execute(new File(rootDirectory+"Expressions.jav"));
     }
+    @Test
+    public void addLong() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"AddLong.jav"));
+    }
 
     private static class TestResultSet{