Merge branch 'bigRefactoring' into antlr

.classpath

@@ -7,16 +7,5 @@
 	<classpathentry kind="lib" path="lib/guava-10.0.1.jar"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
 	<classpathentry kind="lib" path="lib/antlr-complete.jar"/>
-	<classpathentry kind="lib" path="lib/annotations-2.0.1.jar"/>
-	<classpathentry kind="lib" path="lib/bcel-6.1-SNAPSHOT-sources.jar"/>
-	<classpathentry kind="lib" path="lib/cloning.jar"/>
-	<classpathentry kind="lib" path="lib/commons-bcel6-6.0-SNAPSHOT.jar"/>
-	<classpathentry kind="lib" path="lib/guava-15.0.jar"/>
-	<classpathentry kind="lib" path="lib/javassist-3.19.0-GA.jar"/>
-	<classpathentry kind="lib" path="lib/junit-4.0.jar"/>
-	<classpathentry kind="lib" path="lib/log4j-1.2.12.jar"/>
-	<classpathentry kind="lib" path="lib/reflections-0.9.10-javadoc.jar"/>
-	<classpathentry kind="lib" path="lib/reflections-0.9.10-sources.jar"/>
-	<classpathentry kind="lib" path="lib/reflections-0.9.10.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

src/de/dhbwstuttgart/core/ConsoleInterface.java

@@ -1,21 +1,8 @@
 package de.dhbwstuttgart.core;
 
 
-import de.dhbwstuttgart.parser.ClassNotFoundException;
-
-import java.io.File;
-import java.io.IOException;
 import java.util.*;
 
 public class ConsoleInterface {
 	private static final String directory = System.getProperty("user.dir");
-
-	public static void main(String[] args) throws IOException, ClassNotFoundException {
-
-		JavaTXCompiler compiler = new JavaTXCompiler();
-		for(String arg : Arrays.asList(args)){
-			compiler.parse(new File(arg));
-		}
-		compiler.typeInference();
-	}
 }

src/de/dhbwstuttgart/core/JavaTXCompiler.java

@@ -8,7 +8,6 @@ import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typedeployment.TypeInsertPoint;
 import de.dhbwstuttgart.typeinference.ResultSet;
@@ -27,9 +26,9 @@ import java.util.*;
 
 public class JavaTXCompiler {
 
-    protected List<SourceFile> sourceFiles = new ArrayList<>();
+    private List<SourceFile> sourceFiles = new ArrayList<>();
 
-    public List<TypeInsert> getTypeInserts(File forFile){
+    public List<TypeInsertPoint> getTypeInserts(File forFile){
         ResultSet result = typeInference();
         for(SourceFile sf : sourceFiles){
             if(sf.getFile().equals(forFile)){
@@ -65,7 +64,6 @@ public class JavaTXCompiler {
             results.addAll(result);
         }
         return new ResultSet(UnifyTypeFactory.convert(results, generateTPHMap(cons)));
-        //return new ResultSet(new HashSet<>(Arrays.asList(UnifyTypeFactory.convert(results, generateTPHMap(cons)).iterator().next())));
     }
 
     private Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints){

src/de/dhbwstuttgart/parser/JavaTXParser.java

@@ -33,11 +33,7 @@ public class JavaTXParser {
         }
         //TODO: Wieso muss man das händisch anhängen?
         ret.add("java.lang.Object");
-        ret.add("java.lang.Long");
+
-        ret.add("java.lang.Integer");
-        ret.add("java.lang.Boolean");
-        ret.add("java.lang.String");
-        ret.add("java.lang.Class");
         return ret;
     }
 }

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

@@ -4,6 +4,8 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
 import de.dhbwstuttgart.syntaxtree.*;
+import de.dhbwstuttgart.syntaxtree.operator.AndOp;
+import de.dhbwstuttgart.syntaxtree.operator.OrOp;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.statement.literal.*;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
@@ -20,13 +22,12 @@ import java.util.*;
 public class StatementGenerator {
 
     private JavaClassRegistry reg;
-    private Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars;
+    private Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars = new HashMap<>();
     private GenericsRegistry generics;
 
-    public StatementGenerator(JavaClassRegistry reg, GenericsRegistry generics, Map<String, RefTypeOrTPHOrWildcardOrGeneric> localVars){
+    public StatementGenerator(JavaClassRegistry reg, GenericsRegistry generics){
         this.reg = reg;
         this.generics = generics;
-        this.localVars = localVars;
     }
 
     public ParameterList convert(Java8Parser.FormalParameterListContext formalParameterListContext) {
@@ -503,7 +504,7 @@ public class StatementGenerator {
             return convert(expression.conditionalAndExpression());
         }else{
             return new Binary(convert(expression.conditionalOrExpression()),
-                    convert(expression.conditionalAndExpression()), Binary.Operator.OR);
+                    convert(expression.conditionalAndExpression()), new OrOp(null));
         }
     }
 
@@ -512,7 +513,7 @@ public class StatementGenerator {
             return convert(expression.inclusiveOrExpression());
         }else{
             return new Binary(convert(expression.conditionalAndExpression()),
-                    convert(expression.inclusiveOrExpression()), Binary.Operator.AND);
+                    convert(expression.inclusiveOrExpression()), new AndOp(null));
         }
     }
 
@@ -797,21 +798,14 @@ public class StatementGenerator {
             params = new ParameterList(new ArrayList<>(), expression.getStart());
         }
 
-        HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> lambdaLocals = new HashMap<>();
-        lambdaLocals.putAll(localVars);
-        for(FormalParameter param : params.getFormalparalist()){
-            lambdaLocals.put(param.getName(), param.getType());
-        }
-        StatementGenerator lambdaGenerator = new StatementGenerator(reg, generics, lambdaLocals);
-
         Block block;
         if(expression.lambdaBody().expression() != null){
             List<Statement> statements = new ArrayList<>();
-            statements.add(new Return(lambdaGenerator.convert(expression.lambdaBody().expression()),
+            statements.add(new Return(convert(expression.lambdaBody().expression()),
                     expression.lambdaBody().expression().getStart()));
             block = new Block(statements, expression.lambdaBody().getStart());
         }else{
-            block = lambdaGenerator.convert(expression.lambdaBody().block());
+            block = convert(expression.lambdaBody().block());
         }
         List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
         funNParams.add(TypePlaceholder.fresh(expression.getStart()));//ret-Type
@@ -819,7 +813,7 @@ public class StatementGenerator {
                 funNParams.add(TypePlaceholder.fresh(expression.getStart())));
         RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart());
         //RefType lambdaType = new RefType(reg.getName("Fun"+params.getFormalparalist().size()),
-                //funNParams, name.getStart());
+                //funNParams, expression.getStart());
         return new LambdaExpression(lambdaType, params, block, expression.getStart());
     }
 }

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

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.ClassNotFoundException;
-import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.PackageCrawler;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
 import de.dhbwstuttgart.syntaxtree.*;
@@ -19,8 +18,7 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 
-//import jdk.internal.dynalink.support.TypeConverterFactory;
+import jdk.internal.dynalink.support.TypeConverterFactory;
-import org.antlr.v4.runtime.CommonToken;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.tree.TerminalNode;
 
@@ -209,14 +207,12 @@ public class SyntaxTreeGenerator{
   private Method convert(int modifiers, Java8Parser.MethodHeaderContext header, Java8Parser.MethodBodyContext body,
                          JavaClassName parentClass, GenericsRegistry localGenerics) {
 
-    StatementGenerator stmtGen = new StatementGenerator(reg, localGenerics, new HashMap<>());
+    StatementGenerator stmtGen = new StatementGenerator(reg, localGenerics);
 
     String name = header.methodDeclarator().Identifier().getText();
     GenericDeclarationList gtvDeclarations = new GenericDeclarationList(new ArrayList<>(), header.getStart());
     if(header.typeParameters() != null){
       gtvDeclarations = TypeGenerator.convert(header.typeParameters(), parentClass, name,reg, localGenerics);
-    }else{
-      gtvDeclarations = new GenericDeclarationList(new ArrayList<>(), header.getStart());
     }
     RefTypeOrTPHOrWildcardOrGeneric retType;
     if(header.result() != null){
@@ -237,8 +233,6 @@ public class SyntaxTreeGenerator{
       block = stmtGen.convert(body.block());
     }
     if(parentClass.equals(new JavaClassName(name))){
-      //TODO: Constructor darf nicht Rückgabetyp void bekommen: Hier als Rückgabetyp die Klasse inklusive generische Variablen
-      //retType = TypeGenerator.convertTypeName(name, gtvDeclarations, header.getStart(), reg, localGenerics);
       return new Constructor(name, retType, modifiers, parameterList, block, gtvDeclarations, header.getStart());
     }else{
       return new Method(name, retType, modifiers, parameterList,block, gtvDeclarations, header.getStart());
@@ -267,12 +261,7 @@ public class SyntaxTreeGenerator{
     JavaClassName name = reg.getName(ctx.Identifier().getText());
     GenericsRegistry generics = createGenerics(ctx.typeParameters(), name, "");
     Token offset = ctx.getStart();
-    GenericDeclarationList genericClassParameters;
+    GenericDeclarationList genericClassParameters = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
-    if(ctx.typeParameters() == null){
-      genericClassParameters = createEmptyGenericDeclarationList(ctx.Identifier());
-    }else{
-      genericClassParameters = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
-    }
     List<Field> fielddecl = convertFields(ctx.classBody(), generics);
     List<Method> methods = convertMethods(ctx.classBody(), name, generics);
     List<Constructor> konstruktoren = new ArrayList<>();
@@ -291,12 +280,13 @@ public class SyntaxTreeGenerator{
           );
     }
 
-    RefType superClass ;
+    RefType superClass = null ;
+    /*
     if(ctx.superclass() != null){
       superClass = convert(ctx.superclass());
     }else{
       superClass = new ASTFactory(reg).createObjectClass().getType();
-    }
+    }*/
     Boolean isInterface = false;
     List<RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces = convert(ctx.superinterfaces(), generics);
     return new ClassOrInterface(modifiers, name, fielddecl, methods, konstruktoren, genericClassParameters, superClass,
@@ -473,12 +463,8 @@ public class SyntaxTreeGenerator{
 
     List<Field> fields = convertFields(ctx.interfaceBody());
     List<Method> methods = convertMethods(ctx.interfaceBody(), name, generics);
-    GenericDeclarationList genericParams;
+
-    if(ctx.typeParameters() != null){
+    GenericDeclarationList genericParams = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
-      genericParams = TypeGenerator.convert(ctx.typeParameters(), name, "",reg, generics);
-    }else{
-      genericParams = createEmptyGenericDeclarationList(ctx.Identifier());
-    }
     RefType superClass = new ASTFactory(reg).createObjectClass().getType();
 
     List<RefTypeOrTPHOrWildcardOrGeneric> extendedInterfaces = convert(ctx.extendsInterfaces(), generics);
@@ -487,13 +473,6 @@ public class SyntaxTreeGenerator{
             genericParams, superClass, true, extendedInterfaces, ctx.getStart());
   }
 
-  private GenericDeclarationList createEmptyGenericDeclarationList(TerminalNode classNameIdentifier) {
-    CommonToken gtvOffset = new CommonToken(classNameIdentifier.getSymbol());
-    gtvOffset.setCharPositionInLine(gtvOffset.getCharPositionInLine()+classNameIdentifier.getText().length());
-    gtvOffset.setStartIndex(gtvOffset.getStopIndex()+1);
-    return new GenericDeclarationList(new ArrayList<>(), gtvOffset);
-  }
-
   private GenericsRegistry createGenerics(Java8Parser.TypeParametersContext ctx, JavaClassName parentClass, String parentMethod) {
     GenericsRegistry ret = new GenericsRegistry();
     if(ctx == null || ctx.typeParameterList() == null)return ret;

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

@@ -4,6 +4,7 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
+import de.dhbwstuttgart.syntaxtree.GTVDeclarationContext;
 import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
@@ -54,6 +55,9 @@ public class TypeGenerator {
     }
 
     public static GenericDeclarationList convert(Java8Parser.TypeParametersContext typeParametersContext, JavaClassName parentClass, String parentMethod, JavaClassRegistry reg, GenericsRegistry generics) {
+        if(typeParametersContext == null){
+            return new GenericDeclarationList(new ArrayList<>(), new NullToken());
+        }
         Token endOffset = typeParametersContext.getStop();
         List<GenericTypeVar> typeVars = new ArrayList<>();
         for(Java8Parser.TypeParameterContext typeParameter : typeParametersContext.typeParameterList().typeParameter()){

src/de/dhbwstuttgart/parser/antlr/Java8Parser.java

@@ -180,7 +180,7 @@ public class Java8Parser extends Parser {
 		"methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList", 
 		"methodReference", "methodReference_lf_primary", "methodReference_lfno_primary", 
 		"arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression", 
-		"name", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList",
+		"expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList", 
 		"lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator", 
 		"conditionalExpression", "conditionalOrExpression", "conditionalAndExpression", 
 		"inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression", 

src/de/dhbwstuttgart/syntaxtree/ASTVisitor.java

@@ -1,37 +0,0 @@
-package de.dhbwstuttgart.syntaxtree;
-
-import de.dhbwstuttgart.syntaxtree.statement.*;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
-import de.dhbwstuttgart.syntaxtree.type.*;
-
-public interface ASTVisitor extends StatementVisitor{
-
-    void visit(SourceFile sourceFile);
-
-    void visit(ArgumentList argumentList);
-
-    void visit(GenericTypeVar genericTypeVar);
-
-    void visit(FormalParameter formalParameter);
-
-    void visit(GenericDeclarationList genericTypeVars);
-
-    void visit(Field field);
-
-    void visit(Method field);
-
-    void visit(ParameterList formalParameters);
-
-    void visit(ClassOrInterface classOrInterface);
-
-    void visit(RefType refType);
-
-    void visit(SuperWildcardType superWildcardType);
-
-    void visit(TypePlaceholder typePlaceholder);
-
-    void visit(ExtendsWildcardType extendsWildcardType);
-
-    void visit(GenericRefType genericRefType);
-}

src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java

@@ -1,145 +0,0 @@
-package de.dhbwstuttgart.syntaxtree;
-
-import de.dhbwstuttgart.syntaxtree.statement.*;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
-import de.dhbwstuttgart.syntaxtree.type.*;
-
-import java.lang.reflect.Modifier;
-import java.util.Iterator;
-
-public abstract class AbstractASTWalker implements ASTVisitor{
-
-    @Override
-    public void visit(SourceFile sourceFile) {
-        for(ClassOrInterface cl : sourceFile.getClasses()){
-            cl.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(ArgumentList argumentList) {
-        for(Expression expr : argumentList.getArguments()){
-            expr.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(FormalParameter formalParameter) {
-        formalParameter.getType().accept(this);
-    }
-
-    @Override
-    public void visit(GenericDeclarationList genericTypeVars) {
-        Iterator<GenericTypeVar> genericIterator = genericTypeVars.iterator();
-        if(genericIterator.hasNext()){
-            while(genericIterator.hasNext()){
-                genericIterator.next().accept(this);
-            }
-        }
-    }
-
-    @Override
-    public void visit(Field field) {
-        field.getType().accept(this);
-    }
-
-    @Override
-    public void visit(Method method) {
-        method.getType().accept(this);
-        method.getParameterList().accept(this);
-        method.block.accept(this);
-    }
-
-    @Override
-    public void visit(ParameterList formalParameters) {
-        Iterator<FormalParameter> genericIterator = formalParameters.getFormalparalist().iterator();
-        if(genericIterator.hasNext()){
-            while(genericIterator.hasNext()){
-                genericIterator.next().accept(this);
-            }
-        }
-    }
-
-    @Override
-    public void visit(ClassOrInterface classOrInterface) {
-        classOrInterface.getGenerics().accept(this);
-        for(Field f : classOrInterface.getFieldDecl()){
-            f.accept(this);
-        }
-        for(Method m : classOrInterface.getMethods()){
-            m.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(RefType refType) {
-        Iterator<RefTypeOrTPHOrWildcardOrGeneric> genericIterator = refType.getParaList().iterator();
-        if(genericIterator.hasNext()){
-            while(genericIterator.hasNext()){
-                genericIterator.next().accept(this);
-            }
-        }
-    }
-
-    @Override
-    public void visit(SuperWildcardType superWildcardType) {
-        superWildcardType.getInnerType().accept(this);
-    }
-
-    @Override
-    public void visit(ExtendsWildcardType extendsWildcardType) {
-        extendsWildcardType.getInnerType().accept(this);
-    }
-
-    @Override
-    public void visit(LambdaExpression lambdaExpression) {
-        lambdaExpression.params.accept(this);
-        lambdaExpression.methodBody.accept(this);
-    }
-
-    @Override
-    public void visit(Assign assign) {
-        assign.lefSide.accept(this);
-        assign.rightSide.accept(this);
-    }
-
-    @Override
-    public void visit(Block block) {
-        for(Statement stmt : block.getStatements()){
-            stmt.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(FieldVar fieldVar) {
-        fieldVar.receiver.accept(this);
-    }
-
-
-    @Override
-    public void visit(LocalVarDecl localVarDecl) {
-        localVarDecl.getType().accept(this);
-    }
-
-    @Override
-    public void visit(MethodCall methodCall) {
-        methodCall.receiver.accept(this);
-        methodCall.getArgumentList().accept(this);
-    }
-
-    @Override
-    public void visit(NewClass methodCall) {
-        visit((MethodCall) methodCall);
-    }
-
-    @Override
-    public void visit(Receiver receiver) {
-        receiver.expr.accept(this);
-    }
-
-    @Override
-    public void visit(Return aReturn) {
-        aReturn.retexpr.accept(this);
-    }
-}

src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.syntaxtree;
 
 import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
 import de.dhbwstuttgart.typecheck.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
@@ -16,12 +15,13 @@ import java.util.List;
 /**
  * Stellt jede Art von Klasse dar. Auch abstrakte Klassen und Interfaces
  */
-public class ClassOrInterface extends SyntaxTreeNode {
+public class ClassOrInterface extends GTVDeclarationContext implements IItemWithOffset, Generic{
   protected int modifiers;
   protected JavaClassName name;
   private List<Field> fields = new ArrayList<>();
   private List<Method> methods = new ArrayList<>();
   private GenericDeclarationList genericClassParameters;
+  private Token offset;
   private RefTypeOrTPHOrWildcardOrGeneric superClass;
   protected boolean isInterface;
   private List<? extends RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces;
@@ -31,12 +31,23 @@ public class ClassOrInterface extends SyntaxTreeNode {
                           RefTypeOrTPHOrWildcardOrGeneric superClass, Boolean isInterface, List<? extends RefTypeOrTPHOrWildcardOrGeneric> implementedInterfaces, Token offset){
     super(offset);
       this.modifiers = modifiers;
+    if(name != null){
       this.name = name;
+    }
+    if(fielddecl != null){
       this.fields = fielddecl;
-    this.genericClassParameters = genericClassParameters;
+    }
+    if(genericClassParameters != null){
+      this.genericClassParameters = genericClassParameters;
+    }
+    this.offset = offset;
+    if(superClass != null){
       this.superClass = superClass;
+    }
     this.isInterface = isInterface;
+    if(implementedInterfaces != null){
       this.implementedInterfaces = implementedInterfaces;
+    }
     this.methods = methods;
     this.constructors = constructors;
   }
@@ -85,9 +96,4 @@ public class ClassOrInterface extends SyntaxTreeNode {
   public List<? extends Method> getConstructors() {
     return constructors;
   }
-
-  @Override
-  public void accept(ASTVisitor visitor) {
-    visitor.visit(this);
-  }
 }

src/de/dhbwstuttgart/syntaxtree/Field.java

@@ -3,7 +3,7 @@ package de.dhbwstuttgart.syntaxtree;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import org.antlr.v4.runtime.Token;
 
-public class Field extends SyntaxTreeNode{
+public class Field extends GTVDeclarationContext implements Generic {
 	
 	private String name;
 	private RefTypeOrTPHOrWildcardOrGeneric type;
@@ -24,10 +24,5 @@ public class Field extends SyntaxTreeNode{
 	public RefTypeOrTPHOrWildcardOrGeneric getType() {
 		return type;
 	}
-
-	@Override
-	public void accept(ASTVisitor visitor) {
-		visitor.visit(this);
-	}
 }
 

src/de/dhbwstuttgart/syntaxtree/FormalParameter.java

@@ -17,13 +17,4 @@ public class FormalParameter extends SyntaxTreeNode
     public RefTypeOrTPHOrWildcardOrGeneric getType() {
         return type;
     }
-
-    public String getName() {
-        return name;
-    }
-
-    @Override
-    public void accept(ASTVisitor visitor) {
-        visitor.visit(this);
-    }
 }

src/de/dhbwstuttgart/syntaxtree/GTVDeclarationContext.java

@@ -0,0 +1,13 @@
+package de.dhbwstuttgart.syntaxtree;
+
+import org.antlr.v4.runtime.Token;
+
+/**
+ * Beischreibt eine SyntaxTreeNode, welcher die Eigenschaft besitzt,
+ * dass bei seiner Deklaration auch Generische Typvariablen deklariert wurden.
+ */
+public abstract class GTVDeclarationContext extends SyntaxTreeNode {
+    public GTVDeclarationContext(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/Generic.java

@@ -0,0 +1,9 @@
+package de.dhbwstuttgart.syntaxtree;
+
+/**
+ * Wird von allen Klassen implementiert, welche generische Parameter halten können. (Class, Method und Field)
+ * @author janulrich
+ *
+ */
+public interface Generic {
+}

src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java

@@ -26,9 +26,4 @@ public class GenericDeclarationList extends SyntaxTreeNode implements Iterable<G
 	public Iterator<GenericTypeVar> iterator() {
 		return gtvs.iterator();
 	}
-
-	@Override
-	public void accept(ASTVisitor visitor) {
-		visitor.visit(this);
-	}
 }

src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java

@@ -51,9 +51,4 @@ public class GenericTypeVar extends SyntaxTreeNode
     public GenericTypeName getName() {
         return name;
     }
-
-    @Override
-    public void accept(ASTVisitor visitor) {
-        visitor.visit(this);
-    }
 }

src/de/dhbwstuttgart/syntaxtree/Method.java

@@ -23,7 +23,7 @@ import de.dhbwstuttgart.syntaxtree.statement.Block;
  */
 public class Method extends Field implements IItemWithOffset, TypeScope
 {
-	public final Block block;
+	private Block block;
 	private ParameterList parameterlist = new ParameterList(new ArrayList<>(), new NullToken());
 	private ExceptionList exceptionlist;
 	private GenericDeclarationList generics;
@@ -56,9 +56,4 @@ public class Method extends Field implements IItemWithOffset, TypeScope
 	public RefTypeOrTPHOrWildcardOrGeneric getReturnType() {
 		return this.getType();
 	}
-
-	@Override
-	public void accept(ASTVisitor visitor) {
-		visitor.visit(this);
-	}
 }

src/de/dhbwstuttgart/syntaxtree/ParameterList.java

@@ -32,11 +32,6 @@ public class ParameterList extends SyntaxTreeNode implements Iterable<FormalPara
 
 	@Override
 	public Iterator<FormalParameter> iterator() {
-		return formalparameter.iterator();
+		return null;
 	}
-
-    @Override
-    public void accept(ASTVisitor visitor) {
-        visitor.visit(this);
-    }
 }

src/de/dhbwstuttgart/syntaxtree/SourceFile.java

@@ -7,7 +7,7 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.typecheck.JavaClassName;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
-//import sun.security.x509.X509CertInfo;
+import sun.security.x509.X509CertInfo;
 
 
 public class SourceFile extends SyntaxTreeNode{
@@ -62,9 +62,4 @@ public class SourceFile extends SyntaxTreeNode{
   public File getFile() {
     return file;
   }
-
-  @Override
-  public void accept(ASTVisitor visitor) {
-    visitor.visit(this);
-  }
 }

src/de/dhbwstuttgart/syntaxtree/StatementVisitor.java

@@ -27,6 +27,8 @@ public interface StatementVisitor {
 
     void visit(InstanceOf instanceOf);
 
+    void visit(InstVar instVar);
+
     void visit(LocalVar localVar);
 
     void visit(LocalVarDecl localVarDecl);

src/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java

@@ -19,5 +19,4 @@ public abstract class SyntaxTreeNode implements IItemWithOffset{
         return offset;
     }
 
-    public abstract void accept(ASTVisitor visitor);
 }

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

@@ -118,15 +118,16 @@ public class UnifyTypeFactory {
     }
 
     public static UnifyPair convert(Pair p) {
-        if(p.GetOperator().equals(PairOperator.SMALLERDOT)) {
+        if(p.OperatorSmaller()) {
             UnifyPair ret = generateSmallerDotPair(UnifyTypeFactory.convert(p.TA1)
                     , UnifyTypeFactory.convert(p.TA2));
             return ret;
-        }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)){
+        }else if(p.OperatorEqual()){
             UnifyPair ret = generateEqualDotPair(UnifyTypeFactory.convert(p.TA1)
                     , UnifyTypeFactory.convert(p.TA2));
             return ret;
-        }else            throw new NotImplementedException();
+        }else throw new NotImplementedException();
+
     }
 
     /**
@@ -149,7 +150,7 @@ public class UnifyTypeFactory {
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs) {
         if(JavaClassName.Void.equals(t.getName()))return new Void(new NullToken());
-        RefType ret = new RefType(new JavaClassName(t.getName()),convert(t.getTypeParams(), tphs),new NullToken());
+        RefType ret = new RefType(JavaClassName.Void,convert(t.getTypeParams(), tphs),new NullToken());
         return ret;
     }
 
@@ -172,7 +173,6 @@ public class UnifyTypeFactory {
         TypePlaceholder ret = tphs.get(t.getName());
         if(ret == null){ //Dieser TPH wurde vom Unifikationsalgorithmus erstellt
             ret = TypePlaceholder.fresh(new NullToken());
-            tphs.put(t.getName(), ret);
         }
         return ret;
     }

src/de/dhbwstuttgart/syntaxtree/operator/AddOp.java

@@ -0,0 +1,23 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+
+import org.antlr.v4.runtime.Token;
+import org.apache.bcel.Constants;
+import org.apache.bcel.generic.ArithmeticInstruction;
+import org.apache.bcel.generic.DUP;
+import org.apache.bcel.generic.IADD;
+import org.apache.bcel.generic.InstructionList;
+import org.apache.bcel.generic.InvokeInstruction;
+import org.apache.bcel.generic.ObjectType;
+
+
+
+public abstract class AddOp extends Operator
+{
+    public AddOp(Token offset) {
+            super(offset);
+    }
+
+}

src/de/dhbwstuttgart/syntaxtree/operator/AndOp.java

@@ -0,0 +1,18 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
+import de.dhbwstuttgart.syntaxtree.statement.Binary;
+import org.antlr.v4.runtime.Token;
+import org.apache.bcel.generic.InstructionList;
+
+public class AndOp extends LogOp
+{
+
+    public AndOp(Token offset)
+    {
+        super(offset);
+    }
+
+
+    
+}

src/de/dhbwstuttgart/syntaxtree/operator/DivideOp.java

@@ -0,0 +1,12 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import org.antlr.v4.runtime.Token;
+
+
+
+public class DivideOp extends MulOp
+{
+    public DivideOp(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/EqualOp.java

@@ -0,0 +1,15 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import org.antlr.v4.runtime.Token;
+import org.apache.bcel.generic.BranchInstruction;
+import org.apache.bcel.generic.IF_ICMPNE;
+
+
+public class EqualOp extends RelOp
+{
+
+
+    public EqualOp(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/GreaterEquOp.java

@@ -0,0 +1,13 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import org.antlr.v4.runtime.Token;
+
+
+
+public class GreaterEquOp extends RelOp
+{
+
+    public GreaterEquOp(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/GreaterOp.java

@@ -0,0 +1,14 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+import org.antlr.v4.runtime.Token;
+
+
+
+
+public class GreaterOp extends RelOp
+{
+
+
+    public GreaterOp(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/LessEquOp.java

@@ -0,0 +1,15 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import org.antlr.v4.runtime.Token;
+
+
+
+
+public class LessEquOp extends RelOp
+{
+
+
+    public LessEquOp(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/LessOp.java

@@ -0,0 +1,14 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+import org.antlr.v4.runtime.Token;
+
+
+
+
+public class LessOp extends RelOp
+{
+    public LessOp(Token offset)
+    {
+        super(offset);
+    }
+
+}

src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java

@@ -0,0 +1,18 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+import org.antlr.v4.runtime.Token;
+
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+
+
+
+public abstract class LogOp extends Operator
+{
+    
+    public LogOp(Token offset)
+    {
+        super(offset);
+    }
+
+}

src/de/dhbwstuttgart/syntaxtree/operator/MinusOp.java

@@ -0,0 +1,11 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+
+import org.antlr.v4.runtime.Token;
+
+public class MinusOp extends AddOp
+{
+    public MinusOp(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/ModuloOp.java

@@ -0,0 +1,15 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import org.antlr.v4.runtime.Token;
+
+
+
+
+public class ModuloOp extends MulOp
+{
+    public ModuloOp(Token offset)
+    {
+        super(offset);
+    }
+
+}

src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java

@@ -0,0 +1,10 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import org.antlr.v4.runtime.Token;
+
+public abstract class MulOp extends Operator
+{
+    public MulOp(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/NotEqualOp.java

@@ -0,0 +1,11 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import org.antlr.v4.runtime.Token;
+
+public class NotEqualOp extends RelOp
+{
+
+    public NotEqualOp(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/Operator.java

@@ -0,0 +1,13 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+
+import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
+import org.antlr.v4.runtime.Token;
+
+public abstract class Operator extends SyntaxTreeNode
+{
+
+    public Operator(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/OrOp.java

@@ -0,0 +1,15 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import org.antlr.v4.runtime.Token;
+
+
+public class OrOp extends LogOp
+{
+
+    public OrOp(Token offset)
+    {
+        super(offset);
+    }
+
+    
+}

src/de/dhbwstuttgart/syntaxtree/operator/PlusOp.java

@@ -0,0 +1,12 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+
+import org.antlr.v4.runtime.Token;
+
+public class PlusOp extends AddOp
+{
+    public PlusOp(Token offset)
+    {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java

@@ -0,0 +1,11 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import org.antlr.v4.runtime.Token;
+
+public abstract class RelOp extends Operator
+{
+
+    public RelOp(Token offset) {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/operator/TimesOp.java

@@ -0,0 +1,11 @@
+package de.dhbwstuttgart.syntaxtree.operator;
+
+import org.antlr.v4.runtime.Token;
+
+public class TimesOp extends MulOp
+{
+    public TimesOp(Token offset)
+    {
+        super(offset);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/statement/ArgumentList.java

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
 
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import org.antlr.v4.runtime.Token;
 
@@ -20,8 +19,4 @@ public class ArgumentList extends SyntaxTreeNode
 		return expr;
 	}
 
-	@Override
-	public void accept(ASTVisitor visitor) {
-		visitor.visit(this);
-	}
 }

src/de/dhbwstuttgart/syntaxtree/statement/Binary.java

@@ -6,16 +6,12 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 
+import de.dhbwstuttgart.syntaxtree.operator.Operator;
+
 
 // neu von Felix
 public class Binary extends Expression
 {
-    public enum Operator{
-        ADD,
-        SUB,
-        MUL,
-        AND, OR, DIV
-    }
     public Binary(Expression expr1, Expression expr2, Operator op){
         super(null, null);
     }

src/de/dhbwstuttgart/syntaxtree/statement/Expression.java

@@ -1,7 +1,6 @@
 
 package de.dhbwstuttgart.syntaxtree.statement;
 
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
@@ -24,12 +23,4 @@ public abstract class Expression extends SyntaxTreeNode
     }
 
     public abstract void accept(StatementVisitor visitor);
-    
-
-    @Override
-    public void accept(ASTVisitor visitor) {
-        this.accept((StatementVisitor)visitor);
-    }
-
-    public String toString() { return this.getClass().getName() + ":" + type.toString(); }
 }

src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java

@@ -0,0 +1,24 @@
+package de.dhbwstuttgart.syntaxtree.statement;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
+import org.antlr.v4.runtime.Token;
+
+
+public class InstVar extends Expression
+{
+    private Expression expr;
+    public InstVar(Expression instanz, String name, Token offset)
+    {
+        super(instanz.getType(),offset);
+        expr = instanz;
+    }
+
+    @Override
+    public void accept(StatementVisitor visitor) {
+        visitor.visit(this);
+    }
+}

src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java

@@ -8,7 +8,7 @@ import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import org.antlr.v4.runtime.Token;
-//import sun.reflect.generics.reflectiveObjects.NotImplementedException;
+import sun.reflect.generics.reflectiveObjects.NotImplementedException;
 
 import java.util.ArrayList;
 

src/de/dhbwstuttgart/syntaxtree/statement/LocalVar.java

@@ -1,23 +1,28 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
 
 public class LocalVar extends Statement{
 
-    public final String name;
+    protected final String expression;
 
     public LocalVar(String n, RefTypeOrTPHOrWildcardOrGeneric type, Token offset)
     {
         super(type,offset);
-        this.name = n;
+        this.expression = n;
     }
 
     public LocalVar(Expression e1, RefTypeOrTPHOrWildcardOrGeneric type, String access)
     {
         super(type,e1.getOffset());
-        this.name = access;
+        this.expression = access;
     }
 
     @Override

src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java

@@ -31,7 +31,7 @@ public class NewClass extends MethodCall
      * @param start
      */
     public NewClass(RefType newClass, ArgumentList args, Token start) {
-        super(newClass, new Receiver(new EmptyStmt(start)), newClass.getName().toString(), args, start);
+        super(newClass, new Receiver(new EmptyStmt(start)), "new "+newClass.getName().toString(), args, start);
     }
 
     @Override

src/de/dhbwstuttgart/syntaxtree/statement/This.java

@@ -1,6 +1,7 @@
 package de.dhbwstuttgart.syntaxtree.statement;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.syntaxtree.operator.Operator;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;

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

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
 
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import org.antlr.v4.runtime.Token;
 
 /**
@@ -34,8 +33,4 @@ public class ExtendsWildcardType extends WildcardType{
 	}
 
 
-	@Override
-	public void accept(ASTVisitor visitor) {
-		visitor.visit(this);
-	}
 }

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

@@ -1,9 +1,6 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
 
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.typecheck.JavaClassName;
-
 import java.util.List;
 
 /**
@@ -16,17 +13,22 @@ import java.util.List;
  * 
  */
 public class FunN extends RefType {
+	
+	private RefTypeOrTPHOrWildcardOrGeneric R;
+	private List<? extends RefTypeOrTPHOrWildcardOrGeneric> T;
+	
 	/**
 	 * @author Andreas Stadelmeier,  a10023
 	 * Benötigt für den Typinferenzalgorithmus für Java 8
 	 * Generiert einen RefType auf eine FunN<R,T1,...,TN> - Klasse.
-	 * @param params
+	 * @param R
+	 * @param T
 	 * @return
 	 */
-	public FunN(List<RefTypeOrTPHOrWildcardOrGeneric> params) {
+	public FunN(RefTypeOrTPHOrWildcardOrGeneric R, List<? extends RefTypeOrTPHOrWildcardOrGeneric> T) {
-		super(new JavaClassName("Fun"+params.size()), params, new NullToken());
+		super(null,null);
 	}
-
+	
 	/**
 	 * Spezieller Konstruktor um eine FunN ohne Returntype zu generieren
 	 

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.typecheck.GenericTypeName;
 import de.dhbwstuttgart.typecheck.JavaClassName;
 import org.antlr.v4.runtime.Token;
@@ -21,10 +20,5 @@ public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
     public String getUniqueIdentifier(){
         return name.toString();
     }
-
-    @Override
-    public void accept(ASTVisitor visitor) {
-        visitor.visit(this);
-    }
 }
 

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.typecheck.JavaClassName;
 import org.antlr.v4.runtime.Token;
 
@@ -101,9 +100,5 @@ public class RefType extends RefTypeOrTPHOrWildcardOrGeneric
     }
 
 
-    @Override
-    public void accept(ASTVisitor visitor) {
-        visitor.visit(this);
-    }
 }
 

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

@@ -1,14 +1,10 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import org.antlr.v4.runtime.Token;
 
-public abstract class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{
+public class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{
     public RefTypeOrTPHOrWildcardOrGeneric(Token offset) {
         super(offset);
     }
-
-    @Override
-    public abstract void accept(ASTVisitor visitor);
 }

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

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
 
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import org.antlr.v4.runtime.Token;
 
 /**
@@ -43,9 +42,4 @@ public class SuperWildcardType extends WildcardType{
 	public boolean isSuper() {
 		return true;
 	}
-
-	@Override
-	public void accept(ASTVisitor visitor) {
-		visitor.visit(this);
-	}
 }

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

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.syntaxtree.type;
 import java.util.Hashtable;
 
-import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import org.antlr.v4.runtime.Token;
@@ -66,9 +65,4 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
     public String getName() {
         return name;
     }
-
-    @Override
-    public void accept(ASTVisitor visitor) {
-        visitor.visit(this);
-    }
 }

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

@@ -1,13 +0,0 @@
-package de.dhbwstuttgart.syntaxtree.visual;
-
-import de.dhbwstuttgart.syntaxtree.*;
-
-public class ASTPrinter {
-
-    public static String print(SourceFile toPrint){
-        StringBuilder output = new StringBuilder();
-        new OutputGenerator(output).visit(toPrint);
-        return output.toString();
-    }
-
-}

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

@@ -1,20 +0,0 @@
-package de.dhbwstuttgart.syntaxtree.visual;
-
-import de.dhbwstuttgart.syntaxtree.*;
-import de.dhbwstuttgart.syntaxtree.statement.*;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
-import de.dhbwstuttgart.syntaxtree.type.*;
-
-import java.lang.reflect.Modifier;
-import java.util.Iterator;
-
-public class ASTTypePrinter extends ASTPrinter{
-
-    public static String print(SourceFile toPrint){
-        StringBuilder output = new StringBuilder();
-        new TypeOutputGenerator(output).visit(toPrint);
-        return output.toString();
-    }
-
-}

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

@@ -1,307 +0,0 @@
-package de.dhbwstuttgart.syntaxtree.visual;
-
-import de.dhbwstuttgart.syntaxtree.*;
-import de.dhbwstuttgart.syntaxtree.statement.*;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
-import de.dhbwstuttgart.syntaxtree.type.*;
-
-import java.lang.reflect.Modifier;
-import java.util.Iterator;
-
-public class OutputGenerator implements ASTVisitor {
-    private static final String TAB = "  ";
-    String tabs = "";
-    protected final StringBuilder out;
-
-    public OutputGenerator(StringBuilder out){
-        this.out = out;
-    }
-
-    public void tab() {
-        tabs += TAB;
-    }
-
-    public void untab() {
-        tabs = tabs.substring(0,tabs.length()-TAB.length());
-    }
-
-    @Override
-    public void visit(SourceFile sourceFile) {
-        for(ClassOrInterface cl : sourceFile.getClasses()){
-            cl.accept(this);
-        }
-    }
-
-    @Override
-    public void visit(ArgumentList argumentList) {
-        out.append("(");
-        Iterator<Expression> expressionIterator = argumentList.getArguments().iterator();
-        while(expressionIterator.hasNext()){
-            expressionIterator.next().accept(this);
-            if(expressionIterator.hasNext())out.append(", ");
-        }
-        out.append(")");
-    }
-
-    @Override
-    public void visit(GenericTypeVar genericTypeVar) {
-        out.append(genericTypeVar.getName().toString());
-    }
-
-    @Override
-    public void visit(FormalParameter formalParameter) {
-        formalParameter.getType().accept(this);
-        out.append(" ");
-        out.append(formalParameter.getName());
-    }
-
-    @Override
-    public void visit(GenericDeclarationList genericTypeVars) {
-        Iterator<GenericTypeVar> genericIterator = genericTypeVars.iterator();
-        if(genericIterator.hasNext()){
-            out.append("<");
-            while(genericIterator.hasNext()){
-                genericIterator.next().accept(this);
-                if(genericIterator.hasNext())out.append(", ");
-            }
-            out.append(">");
-        }
-    }
-
-    @Override
-    public void visit(Field field) {
-        field.getType().accept(this);
-        out.append(" ");
-        out.append(field.getName());
-        out.append(";");
-    }
-
-    @Override
-    public void visit(Method method) {
-        method.getType().accept(this);
-        out.append(" " + method.getName());
-        method.getParameterList().accept(this);
-        method.block.accept(this);
-        out.append("\n");
-    }
-
-    @Override
-    public void visit(ParameterList formalParameters) {
-        out.append("(");
-        Iterator<FormalParameter> genericIterator = formalParameters.getFormalparalist().iterator();
-        if(genericIterator.hasNext()){
-            while(genericIterator.hasNext()){
-                genericIterator.next().accept(this);
-                if(genericIterator.hasNext())out.append(", ");
-            }
-        }
-        out.append(")");
-    }
-
-    @Override
-    public void visit(ClassOrInterface classOrInterface) {
-        if((Modifier.INTERFACE & classOrInterface.getModifiers()) == 1){
-            out.append("interface ");
-        }else{
-            out.append("class ");
-        }
-        out.append(classOrInterface.getClassName().toString());
-        classOrInterface.getGenerics().accept(this);
-        out.append(" {\n\n");
-        tab();
-        for(Field f : classOrInterface.getFieldDecl()){
-            out.append(tabs);
-            f.accept(this);
-            out.append("\n");
-        }
-        for(Method m : classOrInterface.getMethods()){
-            out.append(tabs);
-            m.accept(this);
-            out.append("\n");
-        }
-        untab();
-        out.append("}");
-    }
-
-    @Override
-    public void visit(RefType refType) {
-        out.append(refType.getName().toString());
-        Iterator<RefTypeOrTPHOrWildcardOrGeneric> genericIterator = refType.getParaList().iterator();
-        if(genericIterator.hasNext()){
-            out.append("<");
-            while(genericIterator.hasNext()){
-                genericIterator.next().accept(this);
-                if(genericIterator.hasNext())out.append(", ");
-            }
-            out.append(">");
-        }
-    }
-
-    @Override
-    public void visit(SuperWildcardType superWildcardType) {
-        out.append("? super ");
-        superWildcardType.getInnerType().accept(this);
-    }
-
-    @Override
-    public void visit(TypePlaceholder typePlaceholder) {
-        out.append("TPH "+ typePlaceholder.getName());
-    }
-
-    @Override
-    public void visit(ExtendsWildcardType extendsWildcardType) {
-        out.append("? extends ");
-        extendsWildcardType.getInnerType().accept(this);
-    }
-
-    @Override
-    public void visit(GenericRefType genericRefType) {
-        out.append(genericRefType.getName().toString());
-    }
-
-    @Override
-    public void visit(LambdaExpression lambdaExpression) {
-        lambdaExpression.params.accept(this);
-        out.append(" -> ");
-        lambdaExpression.methodBody.accept(this);
-    }
-
-    @Override
-    public void visit(Assign assign) {
-        assign.lefSide.accept(this);
-        out.append(" = ");
-        assign.rightSide.accept(this);
-    }
-
-    @Override
-    public void visit(Binary binary) {
-
-    }
-
-    @Override
-    public void visit(Block block) {
-        tab();
-        out.append("{\n");
-        for(Statement stmt : block.getStatements()){
-            out.append(tabs);
-            stmt.accept(this);
-            out.append(";\n");
-        }
-        untab();
-        out.append(tabs);
-        out.append("}");
-    }
-
-    @Override
-    public void visit(CastExpr castExpr) {
-
-    }
-
-    @Override
-    public void visit(EmptyStmt emptyStmt) {
-
-    }
-
-    @Override
-    public void visit(FieldVar fieldVar) {
-        fieldVar.receiver.accept(this);
-        out.append("." + fieldVar.fieldVarName);
-    }
-
-    @Override
-    public void visit(ForStmt forStmt) {
-
-    }
-
-    @Override
-    public void visit(IfStmt ifStmt) {
-
-    }
-
-    @Override
-    public void visit(InstanceOf instanceOf) {
-
-    }
-
-    @Override
-    public void visit(LocalVar localVar) {
-        out.append(localVar.name);
-    }
-
-    @Override
-    public void visit(LocalVarDecl localVarDecl) {
-        localVarDecl.getType().accept(this);
-        out.append(" " + localVarDecl.getName());
-    }
-
-    @Override
-    public void visit(MethodCall methodCall) {
-        methodCall.receiver.accept(this);
-        out.append("."+methodCall.name);
-        methodCall.getArgumentList().accept(this);
-    }
-
-    @Override
-    public void visit(NewClass methodCall) {
-        out.append("new ");
-        out.append(methodCall.name);
-        methodCall.getArgumentList().accept(this);
-    }
-
-    @Override
-    public void visit(NewArray newArray) {
-
-    }
-
-    @Override
-    public void visit(Receiver receiver) {
-        receiver.expr.accept(this);
-    }
-
-    @Override
-    public void visit(Return aReturn) {
-        out.append("return ");
-        aReturn.retexpr.accept(this);
-    }
-
-    @Override
-    public void visit(ReturnVoid aReturn) {
-        out.append("return");
-    }
-
-    @Override
-    public void visit(StaticClassName staticClassName) {
-
-    }
-
-    @Override
-    public void visit(Super aSuper) {
-
-    }
-
-    @Override
-    public void visit(This aThis) {
-        out.append("this");
-    }
-
-    @Override
-    public void visit(UnaryPlus unaryPlus) {
-
-    }
-
-    @Override
-    public void visit(WhileStmt whileStmt) {
-
-    }
-
-    @Override
-    public void visit(Null aNull) {
-
-    }
-
-    @Override
-    public void visit(Literal literal) {
-
-    }
-}

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

@@ -1,236 +0,0 @@
-package de.dhbwstuttgart.syntaxtree.visual;
-
-import de.dhbwstuttgart.syntaxtree.*;
-import de.dhbwstuttgart.syntaxtree.statement.*;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
-import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
-import de.dhbwstuttgart.syntaxtree.type.*;
-
-import java.lang.reflect.Modifier;
-import java.util.Iterator;
-
-public class TypeOutputGenerator extends OutputGenerator {
-
-    TypeOutputGenerator(StringBuilder out){
-        super(out);
-    }
-
-    @Override
-    public void visit(SourceFile sourceFile) {
-        super.visit(sourceFile);
-    }
-
-    @Override
-    public void visit(ArgumentList argumentList) {
-        super.visit(argumentList);
-    }
-
-    @Override
-    public void visit(GenericTypeVar genericTypeVar) {
-        super.visit(genericTypeVar);
-    }
-
-    @Override
-    public void visit(FormalParameter formalParameter) {
-        super.visit(formalParameter);
-    }
-
-    @Override
-    public void visit(GenericDeclarationList genericTypeVars) {
-        super.visit(genericTypeVars);
-    }
-
-    @Override
-    public void visit(Field field) {
-        super.visit(field);
-    }
-
-    @Override
-    public void visit(Method method) {
-        super.visit(method);
-    }
-
-    @Override
-    public void visit(ParameterList formalParameters) {
-        super.visit(formalParameters);
-    }
-
-    @Override
-    public void visit(ClassOrInterface classOrInterface) {
-        super.visit(classOrInterface);
-    }
-
-    @Override
-    public void visit(RefType refType) {
-        super.visit(refType);
-    }
-
-    @Override
-    public void visit(SuperWildcardType superWildcardType) {
-        super.visit(superWildcardType);
-    }
-
-    @Override
-    public void visit(TypePlaceholder typePlaceholder) {
-        super.visit(typePlaceholder);
-    }
-
-    @Override
-    public void visit(ExtendsWildcardType extendsWildcardType) {
-        super.visit(extendsWildcardType);
-    }
-
-    @Override
-    public void visit(GenericRefType genericRefType) {
-        super.visit(genericRefType);
-    }
-
-    @Override
-    public void visit(LambdaExpression lambdaExpression) {
-        out.append("(");
-        super.visit(lambdaExpression);
-        out.append(")");
-        this.out.append("::");
-        lambdaExpression.getType().accept(this);
-    }
-
-    @Override
-    public void visit(Assign assign) {
-        super.visit(assign);
-    }
-
-    @Override
-    public void visit(Binary binary) {
-        super.visit(binary);
-    }
-
-    @Override
-    public void visit(Block block) {
-        out.append("(");
-        super.visit(block);
-        out.append(")");
-        this.out.append("::");
-        block.getType().accept(this);
-    }
-
-    @Override
-    public void visit(CastExpr castExpr) {
-        super.visit(castExpr);
-    }
-
-    @Override
-    public void visit(EmptyStmt emptyStmt) {
-        super.visit(emptyStmt);
-    }
-
-    @Override
-    public void visit(FieldVar fieldVar) {
-        out.append("(");
-        super.visit(fieldVar);
-        out.append(")");
-        this.out.append("::");
-        fieldVar.getType().accept(this);
-    }
-
-    @Override
-    public void visit(ForStmt forStmt) {
-        super.visit(forStmt);
-    }
-
-    @Override
-    public void visit(IfStmt ifStmt) {
-        super.visit(ifStmt);
-    }
-
-    @Override
-    public void visit(InstanceOf instanceOf) {
-        super.visit(instanceOf);
-    }
-
-    @Override
-    public void visit(LocalVar localVar) {
-        out.append("(");
-        super.visit(localVar);
-        out.append(")");
-        this.out.append("::");
-        localVar.getType().accept(this);
-    }
-
-    @Override
-    public void visit(LocalVarDecl localVarDecl) {
-        super.visit(localVarDecl);
-    }
-
-    @Override
-    public void visit(MethodCall methodCall) {
-        out.append("(");
-        super.visit(methodCall);
-        out.append(")");
-        this.out.append("::");
-        methodCall.getType().accept(this);
-    }
-
-    @Override
-    public void visit(NewClass methodCall) {
-        super.visit(methodCall);
-    }
-
-    @Override
-    public void visit(NewArray newArray) {
-        super.visit(newArray);
-    }
-
-    @Override
-    public void visit(Receiver receiver) {
-        super.visit(receiver);
-    }
-
-    @Override
-    public void visit(Return aReturn) {
-        super.visit(aReturn);
-    }
-
-    @Override
-    public void visit(ReturnVoid aReturn) {
-        super.visit(aReturn);
-    }
-
-    @Override
-    public void visit(StaticClassName staticClassName) {
-        super.visit(staticClassName);
-    }
-
-    @Override
-    public void visit(Super aSuper) {
-        super.visit(aSuper);
-    }
-
-    @Override
-    public void visit(This aThis) {
-        out.append("(");
-        super.visit(aThis);
-        out.append(")");
-        this.out.append("::");
-        aThis.getType().accept(this);
-    }
-
-    @Override
-    public void visit(UnaryPlus unaryPlus) {
-        super.visit(unaryPlus);
-    }
-
-    @Override
-    public void visit(WhileStmt whileStmt) {
-        super.visit(whileStmt);
-    }
-
-    @Override
-    public void visit(Null aNull) {
-        super.visit(aNull);
-    }
-
-    @Override
-    public void visit(Literal literal) {
-        super.visit(literal);
-    }
-}

src/de/dhbwstuttgart/typecheck/GenericTypeName.java

@@ -1,7 +1,7 @@
 package de.dhbwstuttgart.typecheck;
 
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
-//import jdk.nashorn.internal.ir.Node;
+import jdk.nashorn.internal.ir.Node;
 
 public class GenericTypeName extends JavaClassName {
     private final static String DELIMITER = "%";

src/de/dhbwstuttgart/typedeployment/TypeInsert.java

@@ -1,31 +0,0 @@
-package de.dhbwstuttgart.typedeployment;
-
-import org.antlr.v4.runtime.Token;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-public class TypeInsert {
-    Set<TypeInsertPoint> inserts;
-
-    public TypeInsert(Token point, String toInsert){
-        inserts = new HashSet<>();
-        inserts.add(new TypeInsertPoint(point, toInsert));
-    }
-
-    public TypeInsert(Set<TypeInsertPoint> points){
-        inserts = points;
-    }
-
-    public String insert(String intoSource){
-        String ret = intoSource;
-        List<TypeInsertPoint> offsets = new ArrayList<>();
-        for(TypeInsertPoint insertPoint : inserts){
-            ret = insertPoint.insert(ret, offsets);
-            offsets.add(insertPoint);
-        }
-        return ret;
-    }
-}

src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java

@@ -2,175 +2,53 @@ package de.dhbwstuttgart.typedeployment;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.*;
-import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.ResultSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import org.antlr.v4.runtime.Token;
 
-import java.lang.reflect.Type;
+import java.util.ArrayList;
-import java.util.*;
+import java.util.List;
 
-/**
- * TODO:
- * Falls in Feldern Generics entstehen, dann werden diese als Klassenparameter eingesetzt
- * Für die Instanzierung von Klassen kann man dann beispielsweise nur noch den Diamond-Operator verwenden
- *
- * Es müssen zu einem TPH alle in Beziehung stehenden Constraints gefunden werden
- */
 public class TypeInsertFactory {
-    public static List<TypeInsert> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults){
+    public static List<TypeInsertPoint> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults){
-        List<TypeInsert> ret = new ArrayList<>();
+        List<TypeInsertPoint> ret = new ArrayList<>();
         for(ClassOrInterface cl : forSourcefile.getClasses()){
             //Felder:
             for(Field field : cl.getFieldDecl()){
                 if(field.getType() instanceof TypePlaceholder){
-                    for(Set<Pair> pairs : withResults.results)
+                    RefTypeOrTPHOrWildcardOrGeneric resolved = withResults.resolveType(field.getType());
-                        ret.add(new TypeInsert(createInsertPoints(
+                    String toInsert = getString(resolved) + " ";
-                            field.getType(), field.getType().getOffset(), cl, null, pairs)));
+                    ret.add(new TypeInsertPoint(field.getType().getOffset(), toInsert));
                 }
             }
 
             for(Method m : cl.getMethods()){
-                for(Set<Pair> pairs : withResults.results)
+                RefTypeOrTPHOrWildcardOrGeneric resolved = withResults.resolveType(m.getReturnType());
-                    ret.add(new TypeInsert(createInsertPoints(
+                String toInsert = getString(resolved) + " ";
-                        m.getReturnType(), m.getReturnType().getOffset(), cl, m, pairs)));
+                ret.add(new TypeInsertPoint(m.getReturnType().getOffset(), toInsert));
 
                 for(FormalParameter param : m.getParameterList().getFormalparalist()){
-                    for(Set<Pair> pairs : withResults.results)
+                    resolved = withResults.resolveType(param.getType());
-                        ret.add(new TypeInsert(createInsertPoints(
+                    toInsert = getString(resolved) + " ";
-                            param.getType(), param.getType().getOffset(), cl, m, pairs)));
+                    ret.add(new TypeInsertPoint(param.getType().getOffset(), toInsert));
+
                 }
             }
         }
         return ret;
     }
 
-    private static Set<TypeInsertPoint> createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m,
+    private static String getString(RefTypeOrTPHOrWildcardOrGeneric resolved) {
-                                                    Set<Pair> pairs) {
+        if(resolved instanceof RefType){
-        Set<TypeInsertPoint> ret = new HashSet<>();
+            return ((RefType) resolved).getName().toString();
-        Set<TypePlaceholder> additionalInserts = new HashSet<>();
+        }else if(resolved instanceof TypePlaceholder){
-        for (Pair pair : pairs) {
+            return ((TypePlaceholder) resolved).getName();
-            RefTypeOrTPHOrWildcardOrGeneric relatedType = null;
+        }else if(resolved instanceof GenericRefType){
-            if (pair.TA1.equals(type)) {
+            return ((GenericRefType)resolved).getName().getShortName().toString();
-                relatedType = pair.TA2;
-            } else if (pair.TA2.equals(type)) {
-                relatedType = pair.TA1;
-            }
-            if (relatedType != null) {
-                //Es wurde ein direkter Treffer gefunden:
-                if (pair.OperatorEqual()) { //resolved ist vom Typ RefType
-                    RefType resolved = ((RefType) relatedType);
-                    String insert = createInsertString(resolved, additionalInserts);
-                    ret.add(new TypeInsertPoint(offset, insert));
-                } else { //Ansonsten ist es ein TPH
-                    additionalInserts.add((TypePlaceholder) type);
-                    //Dann wurde er nicht aufgelöst und es kann nur der TPH als Generic eingesetzt werden:
-                    ret.add(new TypeInsertPoint(offset, ((TypePlaceholder) type).getName()));
-                }
-            }
-        }
-        //Alle Bounds finden:
-        Set<Pair> newGenerics = new HashSet<>();
-        boolean added = true;
-        while(added){
-            added = false;
-            for(Pair pair : pairs){
-                if (additionalInserts.contains(pair.TA1) || additionalInserts.contains(pair.TA2)) {
-                    newGenerics.add(pair);
-                    added |= additionalInserts.add((TypePlaceholder) pair.TA1);
-                    added |= additionalInserts.add((TypePlaceholder) pair.TA2);
-                }
-            }
-        }
-
-        //Alle TPHs die man noch als Generics anfügen muss einsetzen:
-        additionalInserts.clear();
-        for(Pair subtypings : newGenerics){
-            if(additionalInserts.contains(subtypings.TA1)){
-                additionalInserts.remove(subtypings.TA1);
-            }
-        }
-        for(TypePlaceholder tph : additionalInserts){
-            newGenerics.add(new Pair(tph, null));
-        }
-
-        ret.add(createGenericInsert(newGenerics, cl, m));
-
-        return ret;
-    }
-
-    private static String createInsertString(RefType resolved, Set<TypePlaceholder> additionalInserts) {
-        String insert = resolved.getName().toString();
-        if(resolved.getParaList().size() > 0){
-            insert += "<";
-            Iterator<RefTypeOrTPHOrWildcardOrGeneric> iterator = resolved.getParaList().iterator();
-            while(iterator.hasNext()){
-                RefTypeOrTPHOrWildcardOrGeneric typeParam = iterator.next();
-                if(typeParam instanceof TypePlaceholder){
-                    insert += ((TypePlaceholder) typeParam).getName();
-                    additionalInserts.add((TypePlaceholder) typeParam);
-                }else if(typeParam instanceof RefType) {
-                    insert += createInsertString((RefType) typeParam, additionalInserts);
-                }else if(typeParam instanceof SuperWildcardType){
-                    insert += "? super " + createInsertString(((SuperWildcardType) typeParam).getInnerType(), additionalInserts);
-                }else if(typeParam instanceof ExtendsWildcardType){
-                    insert += "? extends " + createInsertString(((ExtendsWildcardType) typeParam).getInnerType(), additionalInserts);
-                }else throw new NotImplementedException();
-                if(iterator.hasNext())insert += ", ";
-            }
-            insert += ">";
-        }
-        return insert;
-    }
-
-    private static TypeInsertPoint createGenericInsert(Set<Pair> toInsert, ClassOrInterface cl, Method m){
-        //Momentan wird Methode ignoriert. Parameter werden immer als Klassenparameter angefügt:
-        //Offset zum Einstzen bestimmen:
-        Token offset;
-        String insert = "";
-        String end;
-        if(cl.getGenerics().iterator().hasNext()){
-            //offset = cl.getGenerics().iterator().next().getOffset();
-            offset = cl.getGenerics().getOffset();
-            end=",";
         }else{
-            offset = cl.getGenerics().getOffset();
+            throw new NotImplementedException();
-            insert += "<";
-            end = ">";
         }
-
-        //Alle einzusetzenden Generics und deren Bounds bestimmen:
-        HashMap<TypePlaceholder, HashSet<TypePlaceholder>> genericsAndBounds = new HashMap<>();
-        for(Pair p : toInsert){
-            if(!genericsAndBounds.containsKey(p.TA1)){
-                genericsAndBounds.put((TypePlaceholder) p.TA1, new HashSet<>());
-            }
-            if(p.TA2 != null){
-                genericsAndBounds.get(p.TA1).add((TypePlaceholder) p.TA2);
-                if(!genericsAndBounds.containsKey(p.TA2)){
-                    genericsAndBounds.put((TypePlaceholder) p.TA2, new HashSet<>());
-                }
-            }
-        }
-
-        //String zum Einsetzen (Generics mit bounds) generieren:
-        Iterator<TypePlaceholder> it = genericsAndBounds.keySet().iterator();
-        if(! it.hasNext())return new TypeInsertPoint(offset, "");
-        while(it.hasNext()){
-            TypePlaceholder tph = it.next();
-            insert += tph.getName();
-            Set<TypePlaceholder> bounds = genericsAndBounds.get(tph);
-            if(bounds.size() > 0){
-                insert += " extends ";
-                Iterator<TypePlaceholder> boundIt = bounds.iterator();
-                while(boundIt.hasNext()){
-                    TypePlaceholder bound = boundIt.next();
-                    insert += bound.getName();
-                    if(boundIt.hasNext())insert += " & ";
-                }
-            }
-            if(it.hasNext())insert+=",";
-        }
-        return new TypeInsertPoint(offset, insert + end);
     }
-}
+}

src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java

@@ -2,23 +2,16 @@ package de.dhbwstuttgart.typedeployment;
 
 import org.antlr.v4.runtime.Token;
 
-import java.util.List;
-import java.util.stream.Collectors;
-
 public class TypeInsertPoint {
     Token point;
     private String insertString;
 
     public TypeInsertPoint(Token point, String toInsert){
         this.point = point;
-        this.insertString = (toInsert.length()>1) ? toInsert + " " : toInsert;
+        this.insertString = toInsert;
     }
 
-    public String insert(String intoSource, List<TypeInsertPoint> additionalOffset){
+    public String insert(String intoSource){
-        int offset = additionalOffset.stream().filter((token ->
+        return new StringBuilder(intoSource).insert(point.getStartIndex(), insertString).toString();
-                //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();
     }
 }

src/de/dhbwstuttgart/typeinference/ResultSet.java

@@ -7,30 +7,30 @@ import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Set;
 
 public class ResultSet {
-    public final Set<Set<Pair>> results;
+    Set<Set<Pair>> results;
     public ResultSet(Set<Set<Pair>> results){
         this.results = results;
     }
 
-    public List<Pair> resolveType(RefTypeOrTPHOrWildcardOrGeneric type) {
+    public RefTypeOrTPHOrWildcardOrGeneric resolveType(RefTypeOrTPHOrWildcardOrGeneric type) {
         /*//Probleme:
             * Es müssen teilweise mehrere TPH eingesetzt werden
             * Es werden alle eingesetzt, welch in der Kette stehen!
             * TPHs müssen zu eindeutigen Namen aufgelöst werden
          */
-        final List<Pair> ret = new ArrayList<>();
+        final RefTypeOrTPHOrWildcardOrGeneric ret;
         for(Set<Pair> pairs : results)for(Pair pair : pairs){
-            //if(pair.OperatorEqual()){ //type ist vom Typ TypePlaceholder
+            if(pair.OperatorEqual()){ //type ist vom Typ TypePlaceholder
-            if(pair.TA1.equals(type) || pair.TA2.equals(type)){
+                if(pair.TA1.equals(type)){
-                ret.add(pair);
+                    return pair.TA2;
+                }else if(pair.TA2.equals(type)){
+                    return pair.TA1;
+                }
             }
-            //}
         }
-        return ret;
+        return type;
     }
 }

src/de/dhbwstuttgart/typeinference/constraints/ConstraintsFactory.java

@@ -14,7 +14,7 @@ import java.util.List;
 public class ConstraintsFactory {
     public static Pair createPair(RefTypeOrTPHOrWildcardOrGeneric t1, RefTypeOrTPHOrWildcardOrGeneric t2, PairOperator equalsdot, TypeInferenceBlockInformation info){
         //Check whether Generics are in the same class:
-        return new Pair(checkGeneric(t1, info), checkGeneric(t2, info), equalsdot);
+        return new Pair(checkGeneric(t1, info), checkGeneric(t2, info));
     }
     public static Pair createPair(RefTypeOrTPHOrWildcardOrGeneric t1,
                                   RefTypeOrTPHOrWildcardOrGeneric t2, TypeInferenceBlockInformation info){

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

@@ -1,17 +1,13 @@
 package de.dhbwstuttgart.typeinference.typeAlgo;
 
-//import com.sun.org.apache.xpath.internal.Arg;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
-import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.statement.literal.Literal;
 import de.dhbwstuttgart.syntaxtree.statement.literal.Null;
-import de.dhbwstuttgart.syntaxtree.type.FunN;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
@@ -22,7 +18,6 @@ import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 
 import java.util.*;
-import java.util.stream.Collectors;
 
 public class TYPE implements StatementVisitor{
 
@@ -39,18 +34,6 @@ public class TYPE implements StatementVisitor{
 
     @Override
     public void visit(LambdaExpression lambdaExpression) {
-        TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken());
-        List<RefTypeOrTPHOrWildcardOrGeneric> lambdaParams = lambdaExpression.params.getFormalparalist().stream().map((formalParameter -> formalParameter.getType())).collect(Collectors.toList());
-        //lambdaParams.add(tphRetType);
-        lambdaParams.add(0,tphRetType);
-        constraintsSet.addUndConstraint(
-                ConstraintsFactory.createPair(lambdaExpression.getType(),
-                        new FunN(lambdaParams),PairOperator.EQUALSDOT,info));
-        constraintsSet.addUndConstraint(
-                ConstraintsFactory.createPair(lambdaExpression.getReturnType(),
-                        tphRetType,info));
-
-        //Constraints des Bodys generieren:
         TYPE lambdaScope = new TYPE(new TypeInferenceBlockInformation(info, lambdaExpression));
         lambdaExpression.methodBody.accept(lambdaScope);
         constraintsSet.addAll(lambdaScope.getConstraints());
@@ -118,6 +101,11 @@ public class TYPE implements StatementVisitor{
         throw new NotImplementedException();
     }
 
+    @Override
+    public void visit(InstVar instVar) {
+        throw new NotImplementedException();
+    }
+
     @Override
     public void visit(LocalVar localVar) {
         // Es werden nur bei Feldvariablen Constraints generiert. Lokale Variablen sind eindeutig
@@ -171,7 +159,7 @@ public class TYPE implements StatementVisitor{
     public void visit(Return returnExpr) {
         returnExpr.retexpr.accept(this);
         constraintsSet.addUndConstraint(ConstraintsFactory.createPair(
-                returnExpr.getType(),info.getCurrentTypeScope().getReturnType(), PairOperator.EQUALSDOT, info));
+                returnExpr.getType(),info.getCurrentTypeScope().getReturnType(), info));
     }
 
     @Override
@@ -221,7 +209,7 @@ public class TYPE implements StatementVisitor{
     protected Constraint<Pair> generateConstraint(MethodCall forMethod, MethodAssumption assumption, TypeInferenceBlockInformation info){
         Constraint methodConstraint = new Constraint();
         methodConstraint.add(ConstraintsFactory.createPair(forMethod.receiver.getType(), assumption.getReceiverType(), PairOperator.SMALLERDOT, info));
-        methodConstraint.add(ConstraintsFactory.createPair(assumption.getReturnType(), forMethod.getType(), PairOperator.EQUALSDOT, info));
+        methodConstraint.add(ConstraintsFactory.createPair(assumption.getReturnType(), forMethod.getType(), PairOperator.SMALLERDOT, info));
         methodConstraint.addAll(generateParameterConstraints(forMethod, assumption, info));
         return methodConstraint;
     }
@@ -229,26 +217,19 @@ public class TYPE implements StatementVisitor{
     protected Set<Pair> generateParameterConstraints(MethodCall foMethod, MethodAssumption assumption, TypeInferenceBlockInformation info) {
         Set<Pair> ret = new HashSet<>();
         for(int i = 0;i<foMethod.arglist.getArguments().size();i++){
-            ret.add(ConstraintsFactory.createPair(foMethod.arglist.getArguments().get(i).getType(),
+            ret.add(ConstraintsFactory.createPair(assumption.getArgTypes().get(i),
-                    assumption.getArgTypes().get(i), PairOperator.SMALLERDOT, info));
+                    foMethod.arglist.getArguments().get(i).getType(), PairOperator.SMALLERDOT, info));
         }
         return ret;
     }
 
 
-    public static List<MethodAssumption> getMethods(String name, int numArgs, TypeInferenceBlockInformation info) {
+    public static List<MethodAssumption> getMethods(String name, ArgumentList arglist, TypeInferenceBlockInformation info) {
         List<MethodAssumption> ret = new ArrayList<>();
-        if(name.equals("apply")){
-            List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
-            for(int i = 0; i< numArgs + 1 ; i++){
-                funNParams.add(TypePlaceholder.fresh(new NullToken()));
-            }
-            ret.add(new MethodAssumption(new FunN(funNParams), funNParams.get(0), funNParams.subList(1, funNParams.size())));
-        }
         for(ClassOrInterface cl : info.getAvailableClasses()){
             for(Method m : cl.getMethods()){
                 if(m.getName().equals(name) &&
-                        m.getParameterList().getFormalparalist().size() == numArgs){
+                        m.getParameterList().getFormalparalist().size() == arglist.getArguments().size()){
                     RefTypeOrTPHOrWildcardOrGeneric retType = info.checkGTV(m.getType());
 
                     ret.add(new MethodAssumption(cl.getType(), retType, convertParams(m.getParameterList(),info)));
@@ -258,11 +239,7 @@ public class TYPE implements StatementVisitor{
         return ret;
     }
 
-    public static List<MethodAssumption> getMethods(String name, ArgumentList arglist, TypeInferenceBlockInformation info) {
+    protected static List<RefTypeOrTPHOrWildcardOrGeneric> convertParams(ParameterList parameterList, TypeInferenceBlockInformation info){
-        return getMethods(name, arglist.getArguments().size(), info);
-    }
-
-        protected static List<RefTypeOrTPHOrWildcardOrGeneric> convertParams(ParameterList parameterList, TypeInferenceBlockInformation info){
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
         for(FormalParameter fp : parameterList.getFormalparalist()){
             params.add(info.checkGTV(fp.getType()));

test/astfactory/ASTFactoryTest.java

@@ -1,6 +1,6 @@
 package astfactory;
 
-//import javafx.collections.ObservableList;
+import javafx.collections.ObservableList;
 import org.junit.Test;
 
 import java.lang.reflect.ParameterizedType;

test/javFiles/Faculty.jav

@@ -1,13 +0,0 @@
-class Faculty {
-
-  Integer mul(Integer x, Integer y) {
-  	return x;
-   }
-
-  m () {
-   auto fact = (Integer x) -> {
-        return mul(x, fact.apply(x));
-   };
-   return fact;
-  }
-}

test/javFiles/Lambda.jav

@@ -1,18 +1,20 @@
 class Lambda{
 
+String var;
+
 methode(){
-    return ((f) -> f);
+    return () -> (f) -> {
+        f.apply(this, var);
+        return var;
+    };
 }
-}
+
-/*
-interface Fun0<A>{
-    A apply();
 }
 
 interface Fun1<A,B>{
     A apply(B b);
 }
-*/
+
 interface Fun2<A,B,C>{
     A apply(B b, C c);
 }

test/javFiles/Lambda2.jav

@@ -4,14 +4,8 @@ public class Lambda2
    public static void main(List<String> args){
        auto listOfStrings = new List<String>();
        auto listOfObjects;
-       listOfObjects = map(listOfStrings, (a) -> a);
+       //listOfObjects = map(listOfStrings, (a) -> a);
 }
-
-public map(a , b){
-    b.apply(a);
-    return a;
-}
-
 /*
 public static <I,O> List<O> map(List<I> input, Function<I,O> func) {
   List<O> output;

test/javFiles/Lambda3.jav

@@ -1,23 +0,0 @@
-
-public class Lambda2
-{
-    /*
-    public static <A> List<A> map(List<? extends A> input,
-    Function<? super A, ? extends A> func){
-      input.add(func.apply(input.get()));
-    }
-    */
-    public map(input,func){
-       input.add(func.apply(input.get()));
-       return map(new List<String>(), func);
-    }
-}
-
-class List<A>{
-    A get();
-    void add(A);
-}
-
-class Function<A,B>{
-    B apply(A a);
-}

test/javFiles/mathStruc.jav

@@ -1,12 +0,0 @@
-class mathStruc<A> {
-
-mathStruc(A a) { }
-
-A model(){ A a; return a; }
-
-methode(){
-auto innerOp = o -> ms ->
- new mathStruc<A>(o.apply(this.model(),ms.model()));
- return innerOp;
- }
-}

test/typeinference/JavaTXCompilerTest.java

@@ -3,11 +3,6 @@ package typeinference;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.parser.ClassNotFoundException;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
-import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
-import de.dhbwstuttgart.syntaxtree.visual.OutputGenerator;
-import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertPoint;
 import de.dhbwstuttgart.typeinference.ResultSet;
 import org.junit.Test;
@@ -23,29 +18,25 @@ import java.util.List;
 
 import static org.junit.Assert.*;
 
-public class JavaTXCompilerTest extends JavaTXCompiler {
+public class JavaTXCompilerTest {
 
     private static final String rootDirectory = System.getProperty("user.dir")+"/test/javFiles/";
     private static final List<File> filesToTest = new ArrayList<>();
 
     @Test
     public void test() throws IOException, ClassNotFoundException {
-    	//filesToTest.add(new File(rootDirectory+"Faculty.jav"));
+        filesToTest.add(new File(rootDirectory+"Lambda2.jav"));
-    	filesToTest.add(new File(rootDirectory+"mathStruc.jav"));
-        //filesToTest.add(new File(rootDirectory+"Faculty.jav"));
-        //filesToTest.add(new File(rootDirectory+"Lambda.jav"));
-        //filesToTest.add(new File(rootDirectory+"Lambda2.jav"));
-        //filesToTest.add(new File(rootDirectory+"Lambda3.jav"));
         //filesToTest.add(new File(rootDirectory+"Vector.jav"));
         //filesToTest.add(new File(rootDirectory+"Generics.jav"));
         //filesToTest.add(new File(rootDirectory+"MethodsEasy.jav"));
+        //filesToTest.add(new File(rootDirectory+"Lambda.jav"));
         //filesToTest.add(new File(rootDirectory+"Matrix.jav"));
+        JavaTXCompiler compiler = new JavaTXCompiler();
         for(File f : filesToTest){
-            this.parse(f);
+            compiler.parse(f);
-            System.out.println(ASTTypePrinter.print(this.sourceFiles.get(sourceFiles.size()-1)));
+            List<TypeInsertPoint> result = compiler.getTypeInserts(f);
-            List<TypeInsert> result = this.getTypeInserts(f);
             String content = readFile(f.getPath(), StandardCharsets.UTF_8);
-            for(TypeInsert tip : result){
+            for(TypeInsertPoint tip : result){
                 System.out.println(tip.insert(content));
             }
         }
@@ -58,5 +49,4 @@ public class JavaTXCompilerTest extends JavaTXCompiler {
         byte[] encoded = Files.readAllBytes(Paths.get(path));
         return new String(encoded, encoding);
     }
-
+}
-}