Import Test funktioniert jetzt

src/mycompiler/SourceFile.java

@@ -703,6 +703,7 @@ public class SourceFile
             	}
             }
             
+            /*
             //Alle Generischen Typvariablen in TPH umwandeln:
             HashMap<GenericTypeVar,TypePlaceholder> gtv2tph = new HashMap<GenericTypeVar,TypePlaceholder>();
             for(Pair pair : constraints){
@@ -723,7 +724,7 @@ public class SourceFile
         			pair.TA2 = tph;
         		}
             }
-            
+            */
             //Erst die Unifizierung erstellen:
             Vector<Pair> constraintsClone = (Vector<Pair>)constraints.clone();
             Vector<Vector<Pair>> unifyResult = Unify.unify(constraintsClone, finiteClosure);
@@ -1159,6 +1160,8 @@ public class SourceFile
             for(int j=0;j<methods.length;j++){
                 if(java.lang.reflect.Modifier.isPublic(methods[j].getModifiers())){
                     String methodName=methods[j].getName();
+                    if(methodName.equals("add")){
+                    
                     java.lang.reflect.Type genericReturnType=methods[j].getGenericReturnType();
                     Type returnType=createTypeFromJavaGenericType(genericReturnType,methods[j].getReturnType(),jreSpiderRegistry);
     
@@ -1181,6 +1184,8 @@ public class SourceFile
                     method.setParameterList(parameterList);
                     //basicAssumptions.addMethodIntersectionType(new CIntersectionType(method));
                     parentClass.addField(method);
+                	
+                    }
                  }
             }
             

src/mycompiler/SyntaxTreeNode.java

@@ -4,6 +4,7 @@ import java.util.Vector;
 
 import typinferenz.exceptions.TypinferenzException;
 import mycompiler.myclass.Class;
+import mycompiler.mytype.GenericTypeVar;
 
 public abstract class SyntaxTreeNode {
 
@@ -14,6 +15,8 @@ public abstract class SyntaxTreeNode {
 	 * Erfüllt folgenden Aufgaben:
 	 * 1. Füllt fehlende Typangaben mit TPHs auf.
 	 * 2. Verknüpft die Knoten des Syntaxbaums. (setzt Parent)
+	 * 3. Wechselt RefTypes gegebenenfalls mit GenericTypeVars aus.
+	 * 4. Führt einen Teil des Syntaxckecks durch.
 	 * 
 	 */
 	public void parserPostProcessing(SyntaxTreeNode parent) {
@@ -42,6 +45,7 @@ public abstract class SyntaxTreeNode {
 		return this.toString();
 	}
 	
+	
 	@Override
 	public boolean equals(Object object){
 		if(!(object instanceof SyntaxTreeNode))return false;

src/mycompiler/myclass/Class.java

@@ -59,6 +59,7 @@ import org.apache.log4j.Logger;
 
 
 
+
 import sun.reflect.generics.reflectiveObjects.NotImplementedException;
 import typinferenz.ConstraintsSet;
 import typinferenz.JavaCodeResult;
@@ -67,6 +68,7 @@ import typinferenz.ResultSet;
 import typinferenz.Typeable;
 import typinferenz.UndConstraint;
 import typinferenz.FunN;
+import typinferenz.assumptions.ClassAssumption;
 import typinferenz.assumptions.TypeAssumptions;
 import typinferenz.exceptions.TypinferenzException;
 import typinferenz.*;
@@ -1247,6 +1249,7 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface
 
     /**
      * Erstellt einen RefType, welcher auf diese Klasse verweist
+     * Ersetzt alle Generischen Variablen in der Parameterliste mit TPH
      * @return
      */
 	public RefType getType() {
@@ -1265,6 +1268,7 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface
 	 */
 	public TypeAssumptions getPublicFieldAssumptions() {
 		TypeAssumptions ret = this.getPrivateFieldAssumptions();
+		ret.addClassAssumption(new ClassAssumption(this));
 		for(Field f : this.getFields()){
 			ret.add(f.createTypeAssumptions(this));
 		}

src/mycompiler/myclass/Constructor.java

@@ -242,7 +242,7 @@ public class Constructor extends Method {
 	public TypeAssumptions createTypeAssumptions(Class classmember) {
 		Class parentClass = this.getParentClass();
 		TypeAssumptions ret = new TypeAssumptions();
-		ret.addConstructorAssumption(new ConstructorAssumption(this, parentClass));
+		ret.addAssumption(new ConstructorAssumption(this, parentClass));
 		return ret;
 	}
 

src/mycompiler/myclass/Field.java

@@ -105,6 +105,12 @@ public abstract class Field extends SyntaxTreeNode implements TypeInsertable, Ty
 		return new TypeInsertPoint(tph, this, resultSet.getTypeEqualTo(tph), resultSet);
 	}
 	
+	/**
+	 * Wird im Zuge des ParserPostProcessing aufgerufen.
+	 * Der Parser kann den Unterschied zwischen einem RefType und einer GTV nicht erkennen.
+	 * Diese Methode ersetzt die RefTypes gegebenenfalls durch eine GTV.
+	 * @param paralist
+	 */
 	public void wandleRefTypeAttributes2GenericAttributes(Vector<Type> paralist){
 		// Zuerst Returntype untersuchen
         Type type=getType();

src/mycompiler/myclass/FieldDeclaration.java

@@ -15,6 +15,7 @@ import mycompiler.mybytecode.ClassFile;
 import mycompiler.myexception.JVMCodeException;
 import mycompiler.mystatement.Expr;
 import mycompiler.mytype.GenericTypeVar;
+import mycompiler.mytype.RefType;
 import mycompiler.mytype.Type;
 import mycompiler.mytype.TypePlaceholder;
 import mycompiler.mytypereconstruction.replacementlistener.CReplaceTypeEvent;
@@ -91,7 +92,7 @@ public class FieldDeclaration extends Field{
 		 */
 		if(this.getType() == null)throw new TypinferenzException("Der Typ eines Feldes darf nicht null sein");
 		//assumptions.add(TypeAssumptions.createFieldVarAssumption(classmember.getName(), this.getName(), this.getType()));
-		assumptions.addFieldAssumption(new FieldAssumption(this,classmember));
+		assumptions.addAssumption(new FieldAssumption(this,classmember));
 		return assumptions;
 	}
 	
@@ -127,7 +128,13 @@ public class FieldDeclaration extends Field{
 	@Override
 	public ConstraintsSet TYPE(TypeAssumptions publicAssumptions) {
 		ConstraintsSet ret = new ConstraintsSet();
-		this.setType(publicAssumptions.getTypeFor(this.getType()));
+		/*
+		if(this.getType() instanceof GenericTypeVar){
+			//Falls Typ ein GTV ist muss er syntaktisch kontrolliert werden...
+			GenericTypeVar gtv = (GenericTypeVar) this.getType();
+		}
+		*/
+		if(this.getType()!=null && (this.getType() instanceof RefType))this.setType(publicAssumptions.getTypeFor((RefType)this.getType()));
 		SingleConstraint c1 = new SingleConstraint(this.getType(), this.getType());
 		ret.add(c1); //Damit die TypVariable des Felds in den Constraints auftaucht
 		

src/mycompiler/myclass/FormalParameter.java

@@ -25,6 +25,7 @@ import org.apache.log4j.Logger;
 
 
 
+
 import sun.reflect.generics.reflectiveObjects.NotImplementedException;
 import typinferenz.JavaCodeResult;
 import typinferenz.ResultSet;
@@ -53,6 +54,17 @@ public class FormalParameter extends SyntaxTreeNode implements ITypeReplacementL
     }
     
     
+    @Override
+	public boolean equals(Object object) {
+		if(!super.equals(object))return false;
+		if(!(object instanceof FormalParameter))return false;
+		FormalParameter equals = (FormalParameter)object;
+		if((this.type==null)!=(equals.type == null))return false;
+		if(this.type != null)return this.type.equals(equals.type);
+		return true;
+	}
+
+
 	// ino.method.setType.23404.defdescription type=javadoc
     /**
      * <br/>Author: J<EFBFBD>rg B<EFBFBD>uerle

src/mycompiler/myclass/Method.java

@@ -537,14 +537,14 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
    
     
 	public ConstraintsSet TYPE(TypeAssumptions ass) {
-		this.returntype = ass.getTypeFor(this.returntype);
+		if((this.returntype instanceof RefType))this.returntype = ass.getTypeFor((RefType)this.returntype);
 		ConstraintsSet ret = new ConstraintsSet();
 		TypeAssumptions localAss = new TypeAssumptions();
 		localAss.add(ass); //Die globalen Assumptions anhängen
 		//Die Parameter zu den Assumptions hinzufügen:
 		if(this.parameterlist!=null)for(FormalParameter param : this.parameterlist){
-			param.setType(ass.getTypeFor(param.getType()));
+			if(param.getType() instanceof RefType)param.setType(ass.getTypeFor((RefType)param.getType()));
-			localAss.addParameterAssumption(new ParameterAssumption(param));
+			localAss.addAssumption(new ParameterAssumption(param));
 		}
 		ret.add(this.block.TYPEStmt(localAss));
 		//eine Verknüpfung mit der Type Assumption aus dem Assumption Set und dem ermittelten Typ der Methode:
@@ -574,7 +574,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	public TypeAssumptions createTypeAssumptions(Class classmember) {
 		Class parentClass = this.getParentClass();
 		TypeAssumptions ret = new TypeAssumptions();
-		ret.addMethodAssumption(new MethodAssumption(this, parentClass));
+		ret.addAssumption(new MethodAssumption(this, parentClass));
 		return ret;
 		/*
 		TypeAssumptions assumptions = new TypeAssumptions();

src/mycompiler/myclass/ParameterList.java

@@ -3,11 +3,13 @@ package mycompiler.myclass;
 // ino.end
 // ino.module.ParameterList.8565.import 
 import java.util.Vector;
+
 import typinferenz.JavaCodeResult;
 import typinferenz.ResultSet;
 import mycompiler.mybytecode.ClassFile;
 import mycompiler.mybytecode.CodeAttribute;
 import mycompiler.mytype.*;
+
 import java.util.Iterator;
 
 // ino.end
@@ -37,6 +39,9 @@ public class ParameterList implements Iterable<FormalParameter>
     
     
     
+
+
+
 	// ino.method.get_codegen_ParameterList.23629.definition 
     public String get_codegen_ParameterList(Vector paralist)
     // ino.end
@@ -153,5 +158,13 @@ public class ParameterList implements Iterable<FormalParameter>
 		return this.formalparameter.iterator();
 	}
 
+    @Override
+	public boolean equals(Object obj) {
+    	if(!(obj instanceof ParameterList))return false;
+		ParameterList equals = (ParameterList)obj;
+		if((this.formalparameter == null )!=(equals.formalparameter==null))return false;
+		if(this.formalparameter!=null)return this.formalparameter.equals(equals.formalparameter);
+    	return true;
+	}
 }
 // ino.end

src/mycompiler/mystatement/LambdaExpression.java

@@ -152,7 +152,7 @@ public class LambdaExpression extends Expr{
 			if(param.getType()==null)param.setType(TypePlaceholder.fresh(this));
 			int offset = 0;
 			//Jeder Parameter der LambdaExpression wird als CParaTypeAssumption der Assumption liste hinzugefügt:
-			ArgumentAssumptions.addParameterAssumption(new ParameterAssumption(param));
+			ArgumentAssumptions.addAssumption(new ParameterAssumption(param));
 			paramTypes.add(param.getType());
 		}
 		this.setType(TypePlaceholder.fresh(this));

src/mycompiler/mystatement/LocalVarDecl.java

@@ -460,8 +460,8 @@ public class LocalVarDecl extends Statement implements TypeInsertable
 	@Override
 	public ConstraintsSet TYPEStmt(TypeAssumptions assumptions) {
 		ConstraintsSet ret = new ConstraintsSet();
-		this.setType(assumptions.getTypeFor(this.getType()));
+		if((this.getType() instanceof RefType))this.setType(assumptions.getTypeFor((RefType)this.getType()));
-		assumptions.addLocalVarAssumption(new LocalVarAssumption(this));
+		assumptions.addAssumption(new LocalVarAssumption(this));
 		//assumptions.remove(null); // falls Variable mit diesem Namen bereits vorhanden.
 		this.setType(new Void(0)); //Return typ einer Variablendeklaration ist Void
 		return ret;

src/mycompiler/mytype/GenericTypeVar.java

@@ -3,11 +3,13 @@ package mycompiler.mytype;
 // ino.end
 
 // ino.module.GenericTypeVar.8671.import 
+import java.util.HashMap;
 import java.util.Vector;
 // ino.end
 
 
 
+
 import mycompiler.mytypereconstruction.replacementlistener.ITypeReplacementListener;
 import typinferenz.JavaCodeResult;
 import typinferenz.ResultSet;
@@ -15,7 +17,7 @@ import typinferenz.ResultSet;
 
 // ino.class.GenericTypeVar.26505.description type=javadoc
 /**
- * 
+ * TODO: Diese Klasse überarbeiten. Pair genericTypeVar ist nicht implementiert.
  * @author J<EFBFBD>rg B<EFBFBD>uerle
  * @version $Date: 2013/09/22 20:12:53 $
  */
@@ -34,7 +36,7 @@ public class GenericTypeVar extends Type
     // ino.method.GenericTypeVar.26509.defdescription type=line
     // private Hashtable<String, Vector<GenericTypeVar>> m_TypeErasureList;
     // ino.end
-	private TypePlaceholder tph;
+	private static HashMap<GenericTypeVar,TypePlaceholder> tph = new HashMap<GenericTypeVar,TypePlaceholder>();
     
 	/**
 	 * 
@@ -91,6 +93,8 @@ public class GenericTypeVar extends Type
     }
     // ino.end
     
+    
+    
     // ino.method.toString.26518.definition 
     public String toString()
     // ino.end
@@ -100,6 +104,11 @@ public class GenericTypeVar extends Type
     }
     // ino.end
 
+    @Override
+	public int hashCode() {
+		return this.name.hashCode();
+	}
+
 	// ino.method.get_codegen_Type.26521.defdescription type=javadoc
     /**
      * hoti 4.5.06
@@ -137,8 +146,12 @@ public class GenericTypeVar extends Type
 	}
 
 	public TypePlaceholder getTypePlaceHolder() {
-		if(this.tph == null)this.tph = TypePlaceholder.fresh();
+		if(!this.tph.containsKey(this)){
-		return this.tph;
+			this.tph.put(this, TypePlaceholder.fresh());
+		}
+		return this.tph.get(this);
+		//if(this.tph == null)this.tph = TypePlaceholder.fresh();
+		//return this.tph;
 	}
 
 	@Override

src/typinferenz/FunNInterface.java

@@ -39,7 +39,7 @@ public class FunNInterface extends Class{
 	public TypeAssumptions getPublicFieldAssumptions() {
 		//return super.getPublicFieldAssumptions();
 		TypeAssumptions ret = new TypeAssumptions();
-		ret.addMethodAssumption(new MethodAssumption(this.getApplyFunction(), this));
+		ret.addAssumption(new MethodAssumption(this.getApplyFunction(), this));
 		return ret;
 	}
 

src/typinferenz/SingleConstraint.java

@@ -54,10 +54,8 @@ public class SingleConstraint extends UndConstraint{
 		if(p1 instanceof RefType)((RefType)p1).GTV2TPH();
 		if(p2 instanceof RefType)((RefType)p2).GTV2TPH();
 		
-		if((p1 instanceof GenericTypeVar))
+		if((p1 instanceof GenericTypeVar))p1 = ((GenericTypeVar)p1).getTypePlaceHolder();
-			p1 = ((GenericTypeVar)p1).getTypePlaceHolder();
+		if((p2 instanceof GenericTypeVar))p2 = ((GenericTypeVar)p2).getTypePlaceHolder();
-		if((p2 instanceof GenericTypeVar))
-			p2 = ((GenericTypeVar)p2).getTypePlaceHolder();
 		
 		// BaseTypes werden in RefTypes umgewandelt. Constraints dürfen nur RefTypes oder TypePlaceholder enthalten, da sonst der Unify-Algorithmus nicht funktioniert.
 		if(!(p1 instanceof RefType) && !(p1 instanceof TypePlaceholder) && !(p1 instanceof GenericTypeVar))p1 = new RefType(p1);

src/typinferenz/assumptions/ClassAssumption.java

@@ -4,6 +4,12 @@ import mycompiler.myclass.*;
 import mycompiler.myclass.Class;
 import mycompiler.mytype.*;
 
+/**
+ * Nicht wirklich eine Assumption.
+ * Wird benutzt um Typen von Variablen zu verifizieren.
+ * @author janulrich
+ *
+ */
 public class ClassAssumption{
 
 	private Class classType;

src/typinferenz/assumptions/MethodAssumption.java

@@ -1,5 +1,8 @@
 package typinferenz.assumptions;
 
+import java.util.Iterator;
+
+import mycompiler.myclass.FormalParameter;
 import mycompiler.myclass.Method;
 import mycompiler.myclass.Class;
 import mycompiler.mytypereconstruction.typeassumption.CParaTypeAssumption;
@@ -41,7 +44,17 @@ public class MethodAssumption extends FieldAssumption {
 
 
 	public String toString(){
-		return "MethodAssumption: "+this.method.toString();
+		String ret = "MethodAssumption: ";
+		ret += this.method.getType().toString()+" ";
+		ret += this.method.get_Name().toString()+"(";
+		Iterator<FormalParameter> it = this.method.parameterlist.formalparameter.iterator();
+		while(it.hasNext()){
+			FormalParameter fp = it.next();
+			ret+=fp.toString();
+			if(it.hasNext())ret += ",";
+		}
+		ret+=")";
+		return ret;
 	}
 	
 	@Override

src/typinferenz/assumptions/TypeAssumptions.java

@@ -68,27 +68,6 @@ public class TypeAssumptions {
 		this.thisClassName = thisClassName;
 	}
 	
-	public void addMethodAssumption(MethodAssumption mAss){
-		if(!this.methodAssumptions.contains(mAss))this.methodAssumptions.add(mAss);
-	}
-	
-	public void addConstructorAssumption(
-			ConstructorAssumption constructorAssumption) {
-		this.constructorAssumptions.add(constructorAssumption);
-	}
-	
-	public void addFieldAssumption(FieldAssumption ass){
-		this.fieldAssumptions.add(ass);
-	}
-	
-	public void addLocalVarAssumption(LocalVarAssumption ass){
-		this.localVarAssumptions.add(ass);
-	}
-	
-	public void addParameterAssumption(ParameterAssumption ass){
-		this.parameterAssumptions.add(ass);
-	}
-	
 	/**
 	 * Liefert alle bekannten öffentlichen Feldern mit dem Namen withName. Dabei werden alle bekannten Klassen durchsucht.
 	 * @param withName
@@ -234,18 +213,35 @@ public class TypeAssumptions {
 		return ret;
 	}
 	
+	public void addAssumption(Assumption ass){
+		if(ass instanceof MethodAssumption)this.methodAssumptions.add((MethodAssumption)ass);//if(!this.methodAssumptions.contains(ass))this.methodAssumptions.add((MethodAssumption)ass);
+		if(ass instanceof FieldAssumption)this.fieldAssumptions.add((FieldAssumption)ass);//if(!this.fieldAssumptions.contains(ass))this.fieldAssumptions.add((FieldAssumption)ass);
+		if(ass instanceof LocalVarAssumption)this.localVarAssumptions.add((LocalVarAssumption)ass);//if(!this.localVarAssumptions.contains(ass))this.localVarAssumptions.add((LocalVarAssumption)ass);
+		if(ass instanceof ParameterAssumption)if(!this.parameterAssumptions.contains(ass))this.parameterAssumptions.add((ParameterAssumption)ass);//this.parameterAssumptions.add((ParameterAssumption)ass);
+		if(ass instanceof ConstructorAssumption)if(!this.constructorAssumptions.contains(ass))this.constructorAssumptions.add((ConstructorAssumption)ass);//this.constructorAssumptions.add((ConstructorAssumption)ass);
+	}
+	
+	private void addAllAssumptions(Vector<Assumption> assumptions){
+		for(Assumption ass : assumptions){
+			this.addAssumption(ass);
+		}
+	}
+	
 	public TypeAssumptions add(TypeAssumptions assumptions){
-		this.methodAssumptions.addAll(assumptions.methodAssumptions);
+		//for(MethodAssumption ass : assumptions.methodAssumptions){
-		this.fieldAssumptions.addAll(assumptions.fieldAssumptions);
+		//	if(!this.methodAssumptions.contains(ass))this.methodAssumptions.add(ass);
-		this.localVarAssumptions.addAll(assumptions.localVarAssumptions);
+		//}
-		this.parameterAssumptions.addAll(assumptions.parameterAssumptions);
+		//this.methodAssumptions.addAll(assumptions.methodAssumptions);
-		this.constructorAssumptions.addAll(assumptions.constructorAssumptions);
+		//this.fieldAssumptions.addAll(assumptions.fieldAssumptions);
+		//this.localVarAssumptions.addAll(assumptions.localVarAssumptions);
+		//this.parameterAssumptions.addAll(assumptions.parameterAssumptions);
+		//this.constructorAssumptions.addAll(assumptions.constructorAssumptions);
+		this.addAllAssumptions(assumptions.getAllAssumptions());
 		this.classAssumptions.addAll(assumptions.classAssumptions);
 		return this;
 	}
 
 	
-	
 	@Override
 	public TypeAssumptions clone(){
 		TypeAssumptions ret = new TypeAssumptions();
@@ -281,7 +277,9 @@ public class TypeAssumptions {
 	 * @return
 	 * @throws TypinferenzException
 	 */
-	public Type getTypeFor(Type t) throws TypinferenzException{
+	public Type getTypeFor(RefType t) throws TypinferenzException{
+		//TODO: Die Parameterliste noch kontrollieren: (hier könnte es Constraints geben: "? extends String")
+		//Alle bekannten Klassen nach diesem Typ durchsuchen:
 		String typName = t.getName();
 		String[] names = typName.split("[.]");
 		for(ClassAssumption ass : this.classAssumptions){
@@ -296,7 +294,9 @@ public class TypeAssumptions {
 				if(!names.equals(assNames))match = false;
 			}
 			if(match){
-				return ass.getAssumedClass().getType();
+				RefType ret = ass.getAssumedClass().getType(); //Dadurch erhält der RefType den vollen Namen (bsp. java.lang.Integer)
+				ret.set_ParaList(t.get_ParaList());
+				return ret;
 			}
 		}
 		throw new TypinferenzException("Der Typ "+t.getName()+" ist nicht korrekt");

test/plugindevelopment/TypeInsertTester.java

@@ -68,6 +68,7 @@ public class TypeInsertTester{
 	}
 	
 	//Source: https://stackoverflow.com/questions/326390/how-to-create-a-java-string-from-the-contents-of-a-file
+	//PS: benötigt Java 7
 	public static String getFileContent(String path)throws IOException 
 	{
 		byte[] encoded = Files.readAllBytes(Paths.get(path));

test/plugindevelopment/TypeInsertTests/GenericTypeVarTest.java

@@ -7,12 +7,19 @@ import org.junit.Test;
 public class GenericTypeVarTest {
 
 	private static final String TEST_FILE = "GenericTypeVarTest.jav";
-	
+	private static final String TEST_FILE2 = "GenericTypeVarTest2.jav";
+	/*
 	@Test
 	public void run(){
 		Vector<String> mustContain = new Vector<String>();
 		mustContain.add("String methode");
 		MultipleTypesInsertTester.test(this.TEST_FILE, mustContain);
 	}
-	
+	*/
+	@Test
+	public void run2(){
+		Vector<String> mustContain = new Vector<String>();
+		mustContain.add("String var2");
+		MultipleTypesInsertTester.test(TEST_FILE2, mustContain);
+	}
 }

test/plugindevelopment/TypeInsertTests/GenericTypeVarTest2.jav

@@ -0,0 +1,14 @@
+class GTVTest<GTV1>{
+GTVTest2<String> var;
+var2;
+
+methode(){
+	return var.test(var2);
+}
+}
+
+class GTVTest2<GTV2>{
+	test(GTV2 param){
+		return param;
+	}
+}