BCEL aktualisiert

in addMethod :
String methodNameAndTypes = m.getName()+Arrays.toString(m.getArgumentTypes());
durch
String methodNameAndTypes = m.getReturnType().getSignature()+m.getName()+Arrays.toString(m.getArgumentTypes());
ersetzt
	modified:   OL.jav
Main-Klasse hinzugefuegt

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/JavaCompilerCore.iml" filepath="$PROJECT_DIR$/JavaCompilerCore.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

JavaCompilerCore.iml

@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="EclipseModuleManager">
+    <libelement value="jar://$MODULE_DIR$/lib/junit-4.0.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/cloning.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/guava-10.0.1.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/commons-bcel6-6.0-SNAPSHOT.jar!/" />
+    <libelement value="jar://$MODULE_DIR$/lib/bcel-6.0-SNAPSHOT.jar!/" />
+    <src_description expected_position="0">
+      <src_folder value="file://$MODULE_DIR$/src" expected_position="0" />
+      <src_folder value="file://$MODULE_DIR$/BCEL" expected_position="1" />
+      <src_folder value="file://$MODULE_DIR$/" expected_position="2" />
+      <src_folder value="file://$MODULE_DIR$/test" expected_position="3" />
+    </src_description>
+  </component>
+  <component name="NewModuleRootManager" inherit-compiler-output="false">
+    <output url="file://$MODULE_DIR$/bin" />
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="false" />
+    </content>
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
+    <orderEntry type="module-library">
+      <library name="junit-4.0.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/junit-4.0.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES>
+          <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.0/junit-4.0-sources.jar!/" />
+        </SOURCES>
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="cloning.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/cloning.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="guava-10.0.1.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/guava-10.0.1.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="commons-bcel6-6.0-SNAPSHOT.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/commons-bcel6-6.0-SNAPSHOT.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES>
+          <root url="file://$USER_HOME$/Development/intellijworkspace/bcel/src/main/java" />
+        </SOURCES>
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="bcel-6.0-SNAPSHOT.jar">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/bcel-6.0-SNAPSHOT.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>

src/de/dhbwstuttgart/bytecode/ClassGenerator.java

@@ -40,6 +40,7 @@ public class ClassGenerator extends ClassGen{
 	
 	private Map<String, ClassGenerator> extraClasses = new HashMap<>();
 	private List<String> methodsNamesAndTypes = new LinkedList<>();
+	private MethodGenerator methodGenerator;
 
 	public ClassGenerator(String name, Type superClass, String string, short accessflags, String[] strings, TypeinferenceResults typeinferenceResults) {
 		super(name,superClass.get_Name(),string,accessflags,strings, new DHBWConstantPoolGen());
@@ -171,7 +172,8 @@ public class ClassGenerator extends ClassGen{
 
 	@Override
 	public void addMethod(Method m) {
-		String methodNameAndTypes = m.getName()+Arrays.toString(m.getArgumentTypes());
+		String methodNameAndTypes = m.getReturnType().toString()+m.getName()+Arrays.toString(m.getArgumentTypes());
+
 		
 		if(methodsNamesAndTypes.contains(methodNameAndTypes)){
 			return;
@@ -180,9 +182,13 @@ public class ClassGenerator extends ClassGen{
 		methodsNamesAndTypes.add(methodNameAndTypes);
 		super.addMethod(m);
 	}
-	
-	
-	
-	
-	
+
+	public void setMethodeGenerator(MethodGenerator methodGenerator) {
+		this.methodGenerator = methodGenerator;
+	}
+
+	public MethodGenerator getMethodGenerator() {
+		return methodGenerator;
+	}
+
 }

src/de/dhbwstuttgart/bytecode/DHBWInstructionFactory.java

@@ -139,23 +139,6 @@ public class DHBWInstructionFactory extends InstructionFactory{
         return new INVOKEDYNAMIC(index);
 	}
 
-	public static LocalVariableInstruction createLoad(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
-		return InstructionFactory.createLoad(bytecodeType, getStoreIndex(variableName));
-	}
-	
-	public LocalVariableInstruction createStore(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
-		return InstructionFactory.createStore(bytecodeType, getStoreIndex(variableName));
-	}
-	
-	public static Integer getStoreIndex(String variableName) {
-		if(storeIndexes.get(variableName) == null){
-			Integer index = storeIndexes.size()+1;
-			storeIndexes.put(variableName, index);
-		}
-		
-		return storeIndexes.get(variableName);
-	}
-
 	public static Type createObjectType() {
 		return new org.apache.commons.bcel6.generic.ObjectType("java.lang.Object");
 	}
@@ -163,8 +146,4 @@ public class DHBWInstructionFactory extends InstructionFactory{
 	public Attribute createSignatureAttribute(String signature) {
 		return new Signature(cp.addUtf8("Signature"),2,cp.addUtf8(signature),cp.getConstantPool());
 	}
-
-	public void resetStoreIndexes() {
-		//storeIndexes.clear();
-	}
 }

src/de/dhbwstuttgart/bytecode/MethodGenerator.java

@@ -4,6 +4,9 @@ import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Vector;
 
 import org.apache.commons.bcel6.classfile.Attribute;
 import org.apache.commons.bcel6.classfile.ConstantPool;
@@ -16,7 +19,9 @@ import org.apache.commons.bcel6.classfile.Visitor;
 import org.apache.commons.bcel6.generic.BranchInstruction;
 import org.apache.commons.bcel6.generic.ConstantPoolGen;
 import org.apache.commons.bcel6.generic.Instruction;
+import org.apache.commons.bcel6.generic.InstructionFactory;
 import org.apache.commons.bcel6.generic.InstructionList;
+import org.apache.commons.bcel6.generic.LocalVariableInstruction;
 import org.apache.commons.bcel6.generic.MethodGen;
 import org.apache.commons.bcel6.generic.StackMapTableGen;
 import org.apache.commons.bcel6.generic.Type;
@@ -30,15 +35,22 @@ import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.statement.Return;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.Menge;
 import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
 
 public class MethodGenerator extends MethodGen{
 
+	private Map<String, Integer> storeIndexes = new HashMap<>();
+
 	public MethodGenerator(int access_flags, Type return_type, Type[] arg_types, String[] arg_names, String method_name,
-			String class_name, InstructionList il, ConstantPoolGen cp) {
+			String class_name, InstructionList il, ConstantPoolGen cp) {		
 		super(access_flags, return_type, arg_types, arg_names, method_name, class_name, il, cp);
+		
+		for(String name: arg_names){
+			getStoreIndex(name);
+		}
 	}
 	
 	public Method createMethod(ClassGenerator cg, ParameterList parameter, de.dhbwstuttgart.syntaxtree.type.Type retType, Block block, TypeinferenceResultSet rs){
@@ -58,7 +70,8 @@ public class MethodGenerator extends MethodGen{
 						il.append(factory.createReturn( org.apache.commons.bcel6.generic.Type.VOID));
 					}
 		}
-		
+
+		method.getInstructionList().setPositions();
 		method.stripAttributes(true);
 		method.setMaxStack(); //Die Stack Größe automatisch berechnen lassen (erst nach dem alle Instructions angehängt wurden)
 		method.setMaxLocals();
@@ -80,6 +93,23 @@ public class MethodGenerator extends MethodGen{
 		return method.getMethod();
 	}
 	
+	public LocalVariableInstruction createLoad(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
+		return InstructionFactory.createLoad(bytecodeType, getStoreIndex(variableName));
+	}
+	
+	public LocalVariableInstruction createStore(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
+		return InstructionFactory.createStore(bytecodeType, getStoreIndex(variableName));
+	}
+	
+	public Integer getStoreIndex(String variableName) {
+		if(storeIndexes.get(variableName) == null){
+			Integer index = storeIndexes.size()+1;
+			storeIndexes.put(variableName, index);
+		}
+		
+		return storeIndexes.get(variableName);
+	}
+	
 		
 }
 

src/de/dhbwstuttgart/parser/JavaParser.jay

@@ -663,15 +663,6 @@ modifier                         :  PUBLIC
 
 classtype : classorinterfacetype
             {
-		//PL 05-07-30 eingefuegt containedTypes ANFANG
-		RefType RT = new RefType($1.get_Name_1Element(),null,-1);
-		//RT.set_UsedId($1);
-		//RT.setName(RT.get_UsedId().get_Name_1Element());
-		RT.set_ParaList($1.get_RealParaList());
-		//RT.setName($1.get_Name_1Element());
-		containedTypes.addElement(RT);
-		//PL 05-07-30 eingefuegt containedTypes ENDE
-
                 $$ = $1;
             }
 
@@ -2026,6 +2017,7 @@ classinstancecreationexpression : NEW classtype '(' ')'
 					{
 						NewClass NC = new NewClass($2.getOffset(),$2.getVariableLength());
 						NC.set_UsedId($2);
+						
 						usedIdsToCheck.addElement($2);
 						//auskommentiert von Andreas Stadelmeier (a10023) NC.setType(TypePlaceholder.fresh());
 						$$=NC;

src/de/dhbwstuttgart/syntaxtree/Method.java

@@ -78,15 +78,12 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 	private Modifiers modifiers;
 	protected static Logger inferencelog = Logger.getLogger("inference");
 	protected static Logger parserlog = Logger.getLogger("parser");
-	
-	protected Menge<org.apache.commons.bcel6.generic.Type[]> createdMethods = new Menge<>();
 
 	public Method(int offset) {
 		super(offset);
 	}
 
-	public Method(String name, Type returnType, ParameterList parameterList,
-			Block block, GenericDeclarationList gtvDeclarations, int offset) {
+	public Method(String name, Type returnType, ParameterList parameterList, Block block, GenericDeclarationList gtvDeclarations, int offset) {
 		this(offset);
 		/*
 		 * if(parameterList != null)parameterList.parserPostProcessing(this);
@@ -419,7 +416,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		ArrayList<String> argumentNames = new ArrayList<String>();
 		
 		if(this.parameterlist != null && this.parameterlist.size() > 0){
-			generateArgumentList(argumentTypes, argumentNames, cg, _factory, t);
+			generateArgumentList(argumentTypes, argumentNames, cg, t);
 		}
 		
 		short constants = Constants.ACC_PUBLIC;
@@ -429,15 +426,15 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
 		
 		MethodGenerator method = new MethodGenerator(constants, returnType.getBytecodeType(cg, t), argumentTypes.toArray(new org.apache.commons.bcel6.generic.Type[parameterlist.size()]) , argumentNames.toArray(new String[parameterlist.size()]), this.get_Method_Name(), getParentClass().name, il, _cp);
 		
+		cg.setMethodeGenerator(method);
+		
 		cg.addMethod(method.createMethod(cg, getParameterList(), returnType, get_Block(), t));
 	}
 
-	private void generateArgumentList(ArrayList<org.apache.commons.bcel6.generic.Type> argumentTypes, ArrayList<String> argumentNames, ClassGenerator cg, DHBWInstructionFactory _factory, TypeinferenceResultSet t) {
+	private void generateArgumentList(ArrayList<org.apache.commons.bcel6.generic.Type> argumentTypes, ArrayList<String> argumentNames, ClassGenerator cg, TypeinferenceResultSet t) {
 		for(FormalParameter parameter : this.parameterlist){
 			argumentTypes.add(parameter.getType().getBytecodeType(cg, t));
 			argumentNames.add(parameter.getIdentifier());
-			
-			_factory.getStoreIndex(parameter.getIdentifier());
 		}
 	}
 }

src/de/dhbwstuttgart/syntaxtree/SourceFile.java

@@ -4,11 +4,14 @@ package de.dhbwstuttgart.syntaxtree;
 
 // ino.module.SourceFile.8722.import 
 import java.io.IOException;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Set;
 import java.util.function.Function;
 
@@ -49,7 +52,9 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.unify.Unifikationsalgorithmus;
 import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 
@@ -195,7 +200,122 @@ public class SourceFile
             InterfaceVektor.addElement((Interface) e);
         }
     }
-    
+        
+    /**
+     * PL 2014-10-25
+     * schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind
+     * Rückgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
+     * @param var
+     * @param vars
+     * @param indexe
+     * @return
+     */
+    static Menge<Integer> schnitt1 (Menge<PlaceholderType> var, Menge<Menge<PlaceholderType>> vars, Menge<Integer> indexe) {
+        int j = -1;
+        for (Menge<PlaceholderType> varelems : vars) {
+                j++;
+                if (varelems != null) {
+                        if (var.stream().map(x -> varelems.contains(x)).reduce(false, (a,b) -> (a || b))
+                                        && (!indexe.contains(j)))
+                        {
+                                Menge<PlaceholderType> rekvarelements = vars.elementAt(j);
+                                vars.setElementAt(null, j);//Element erledigt muss nicht nochmals bearbeitet werden.
+                                indexe.addElement(j);
+                                indexe = schnitt1(rekvarelements, vars, indexe);
+                        }
+                }
+        }
+        return indexe;
+    }
+
+    /**
+     * Bildet Schnittmengen der Mengen von Typeplaceholders
+     * Rueckgabe ist die Menge der Menge von Indizies die Schnittmengen sind.
+     * @param vars
+     * @return
+     */
+    public static Menge<Menge<Integer>> schnitt (Menge<Menge<PlaceholderType>> vars) {
+        Menge<Menge<Integer>> ret = new Menge<>();
+        int i = -1;
+        for (Menge<PlaceholderType> var : vars) {
+                i++;
+                if (var != null) {//Element wurde noch bearbeitet
+                        Menge<Integer> indexe = new Menge<>();
+                        indexe.add(i);
+                        ret.add(schnitt1(var, vars, indexe));
+                }
+        }
+        return ret;
+    }
+
+    public static Set<Set<UnifyPair>> cartesianProduct(List<UnifyPair> constraints, FiniteClosure finiteClosure){
+    	//IDEE: Man bildet Zusammenhangskomponenten von Paaren, die gemeinsame Variablen haben
+        //      und unifizert nur die Zusammenhangskomponenten in Schritten 1 - 5
+        //Schritt 1: Alle Variablen in den Paaren von Elementen einsammeln
+        Menge<Menge<PlaceholderType>> constraintsclonevars = constraints.stream().map(p -> {Menge<PlaceholderType> TPHs = new Menge<>(); 
+          TPHs.addAll(p.getInvolvedPlaceholderTypes());
+          TPHs.addAll(p.getInvolvedPlaceholderTypes());
+          return TPHs;}
+          ).collect(Menge::new, Menge::add, Menge::addAll);    	
+
+        
+        //Schritt 2: Schnittmengen jedes Elements mit jedem Elememt von vars bilden und dann index zusammenfassen
+        //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden müssen
+      	Menge<Menge<Integer>> indexeset = new Menge<>();
+      	if (constraintsclonevars != null && constraintsclonevars.size()>0) { 
+      		indexeset = SourceFile.schnitt(constraintsclonevars);
+      	}
+      	
+      	//Schritt 3: Umwandlung der Indizes in die zugehoerigen Elemente
+      	//           In streamconstraintsclone sind die Mengen von Paar enthalten die unifiziert werden muessen
+      	Stream<Menge<UnifyPair>> streamconstraintsclone = indexeset.stream().<Menge<UnifyPair>>map(x -> x.stream()
+      			                                                           .<UnifyPair>map(i -> constraints.get(i))
+      			                                                               .<Menge<UnifyPair>>collect(Menge::new, Menge::add, Menge::addAll));
+     	//Menge<Menge<Pair>> vecconstraintsclone = streamconstraintsclone.collect(Menge::new, Menge::add, Menge::addAll);
+          //System.out.println();
+      	//Schritt 4: Unifikation  
+      	Menge<Set<Set<UnifyPair>>> vecunifyResult =
+      			//streamconstraintsclone.map(x -> Unify.unify(x, finiteClosure)).collect(Menge::new, Menge::add, Menge::addAll);
+      			//DEBUG-Variante
+      			streamconstraintsclone.map(x -> 
+      			  	{ 	Set<Set<UnifyPair>> z = new TypeUnify().unify(x, finiteClosure);
+      					return z;
+      			  	}
+      					).collect(Menge::new, Menge::add, Menge::addAll);
+      			  	
+      	
+      	//card gibt die Cardinalitaet der unifizierten Mengen an
+      	Menge<Integer> card = vecunifyResult.stream().map(x -> x.size()).collect(Menge::new, Menge::add, Menge::addAll);
+      			;//.reduce(1,(a,b) -> { if ((a > 0) && (b > 0)) return (a * b); else return 1; });
+      			
+          //Schritt 5: Bildung des cartesischen Produkts
+          //sollte wieder entfernt werden: Weiterarbeit mit: 
+      	//[[x_1 -> t_1, x_2 -> t2], [x_1 -> t'_1, x_2 -> t'_2]] x ... x [[x_n -> t_1n], [x_n -> t2n], [x_n -> t3n]] 
+      	Set<Set<UnifyPair>> cardprodret_start = new Menge<>();
+      	cardprodret_start.add(new Menge<UnifyPair>());
+      	
+      	//cart. Produkt mit Linkverschiebung
+      	Set<Set<UnifyPair>> unifyResult = vecunifyResult.stream().reduce(cardprodret_start, (x, y) -> {
+      		Set<Set<UnifyPair>> cardprodret= new Menge<>();
+      		if (y.size() > 0) {
+      			//System.out.println(y);
+      			//Menge<Menge<Pair>> cardprodretold = x;
+					//cardprodret = new Menge<>();
+					for(Set<UnifyPair> xElement : x) {
+						for (Set<UnifyPair> yElement : y){
+							Set<UnifyPair> help = new Menge<>(); 
+							help.addAll(yElement);
+							help.addAll(xElement);
+							cardprodret.add(help);
+						}
+					}
+      		}
+      		else 
+      			return new Menge<>(); //kein unifiziertes Ergebnis, damit wird das Geseamtergebnis []
+      		return cardprodret;
+      	});
+      	return unifyResult;
+    }
     
     /////////////////////////////////////////////////////////////////////////
     // TypeReconstructionAlgorithmus
@@ -232,11 +352,6 @@ public class SourceFile
     	globalAssumptions.add(importAssumptions);
     	typinferenzLog.debug("Von JRE erstellte Assumptions: "+importAssumptions, Section.TYPEINFERENCE);
     	
-    	//FiniteClosure generieren:
-    	FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(globalAssumptions);
-    	
-    	typinferenzLog.debug("FiniteClosure: \n"+finiteClosure, Section.TYPEINFERENCE);
-    	
     	ConstraintsSet oderConstraints = new ConstraintsSet();
     	//Alle Constraints der in dieser SourceFile enthaltenen Klassen sammeln:
         for(Class klasse : KlassenVektor){
@@ -249,6 +364,11 @@ public class SourceFile
          */////////////////
         //UnifyTypeFactory.convert(oderConstraints);
         
+
+    	//FiniteClosure generieren:
+    	FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(globalAssumptions);
+    	
+    	typinferenzLog.debug("FiniteClosure: \n"+finiteClosure, Section.TYPEINFERENCE);
         
         ////////////////
         //Typen in UnifyTypen umwandeln:
@@ -256,13 +376,11 @@ public class SourceFile
         UnifyConstraintsSet unifyConstraints = UnifyTypeFactory.convert(oderConstraints);
         
         //Unmögliche ConstraintsSets aussortieren durch Unifizierung
-        Function<Menge<UnifyPair>,Menge<Menge<UnifyPair>>> unifier = (pairs)->{
-        	Menge<Menge<UnifyPair>> retValue = new Menge<>();
-        	Set<Set<UnifyPair>> unifiedPairs = new TypeUnify().unify(pairs, finiteClosure);
-        	return retValue;};
-        //oderConstraints.filterWrongConstraints(unifier);
+        Unifikationsalgorithmus unifier = (pairs)->new TypeUnify().unify(pairs, finiteClosure);
         	
-        //oderConstraints.unifyUndConstraints(unifier); //rausgeworfen für Tests (08.12.2015)
+        unifyConstraints.filterWrongConstraints(unifier);
+        	
+        unifyConstraints.unifyUndConstraints(unifier); //rausgeworfen für Tests (08.12.2015)
 
     	typinferenzLog.debug("Übriggebliebene Konstraints:\n"+oderConstraints+"\n", Section.TYPEINFERENCE);
     	
@@ -273,7 +391,9 @@ public class SourceFile
 	    ////////////////
         Set<Set<UnifyPair>> xConstraints = unifyConstraints.cartesianProduct();
         	
-        
+    	
+        //Sets zu Listen umwandeln:
+        //Set<List<UnifyPair>> allUnifiedConstraints = xConstraints.stream().map((set)-> new ArrayList<>(set)).collect(Menge::new, Menge::add, Menge::addAll);;
 
         typinferenzLog.debug("Finite Closure: "+finiteClosure, Section.TYPEINFERENCE);
         typinferenzLog.debug("Karthesisches Produkt der Constraints: "+xConstraints, Section.TYPEINFERENCE);
@@ -286,74 +406,7 @@ public class SourceFile
     	boolean unifyFail = true;
         for(Set<UnifyPair> constraints : xConstraints){
         	//Alle durch das Karthesische Produkt entstandenen Möglichkeiten durchgehen:
-            //Menge<Menge<Pair>> result = new Menge<Menge<Pair>>();
             
-          //IDEE: Man bildet Zusammenhangskomponenten von Paaren, die gemeinsame Variablen haben
-          //      und unifizert nur die Zusammenhangskomponenten in Schritten 1 - 5
-           /*
-          //Schritt 1: Alle Variablen in den Paaren von Elementen einsammeln
-          Menge<Menge<TypePlaceholder>> constraintsclonevars = constraints.stream().map(p -> {Menge<TypePlaceholder> TPHs = new Menge<>(); 
-            TPHs.addAll(p.TA1.getInvolvedTypePlaceholder());
-            TPHs.addAll(p.TA2.getInvolvedTypePlaceholder());
-            return TPHs;}
-            ).collect(Menge::new, Menge::add, Menge::addAll);    	
-
-          //Schritt 2: Schnittmengen jedes Elements mit jedem Elememt von vars bilden und dann index zusammenfassen
-          //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden müssen
-        	Menge<Menge<Integer>> indexeset = new Menge<>();
-        	if (constraintsclonevars != null && constraintsclonevars.size()>0) { 
-        		indexeset = Unify.schnitt(constraintsclonevars);
-        	}
-        	
-        	//Schritt 3: Umwandlung der Indizes in die zugehoerigen Elemente
-        	//           In streamconstraintsclone sind die Mengen von Paar enthalten die unifiziert werden muessen
-        	Stream<Menge<MPair>> streamconstraintsclone = indexeset.stream().map(x -> x.stream()
-        			                                                           .map(i -> constraintsClone.elementAt(i))
-        			                                                               .<Menge<MPair>>collect(Menge::new, Menge::add, Menge::addAll));
-       	//Menge<Menge<Pair>> vecconstraintsclone = streamconstraintsclone.collect(Menge::new, Menge::add, Menge::addAll);
-            //System.out.println();
-        	//Schritt 4: Unifikation  
-        	Set<Set<Set<MPair>>> vecunifyResult =
-        			//streamconstraintsclone.map(x -> Unify.unify(x, finiteClosure)).collect(Menge::new, Menge::add, Menge::addAll);
-        			//DEBUG-Variante
-        			streamconstraintsclone.map(x -> 
-        			  	{ 	Set<Set<MPair>> z = new Unify().unify(x, finiteClosure);
-        					return z;
-        			  	}
-        					).collect(Menge::new, Menge::add, Menge::addAll);
-        			  	
-        	
-        	//card gibt die Cardinalitaet der unifizierten Mengen an
-        	Menge<Integer> card = vecunifyResult.stream().map(x -> x.size()).collect(Menge::new, Menge::add, Menge::addAll);
-        			;//.reduce(1,(a,b) -> { if ((a > 0) && (b > 0)) return (a * b); else return 1; });
-        			
-            //Schritt 5: Bildung des cartesischen Produkts
-            //sollte wieder entfernt werden: Weiterarbeit mit: 
-        	//[[x_1 -> t_1, x_2 -> t2], [x_1 -> t'_1, x_2 -> t'_2]] x ... x [[x_n -> t_1n], [x_n -> t2n], [x_n -> t3n]] 
-        	Set<Set<Pair>> cardprodret_start = new Menge<>();
-        	cardprodret_start.add(new Menge<Pair>());
-        	
-        	//cart. Produkt mit Linkverschiebung
-        	Set<Set<Pair>> unifyResult = vecunifyResult.stream().reduce(cardprodret_start, (x, y) -> {
-        		Set<Set<Pair>> cardprodret= new Menge<>();
-        		if (y.size() > 0) {
-        			//System.out.println(y);
-        			//Menge<Menge<Pair>> cardprodretold = x;
-					//cardprodret = new Menge<>();
-					for(int j = 0; j < x.size(); j++) {
-						for (int k = 0; k < y.size(); k++){
-							Set<Pair> help = new Menge<>(); 
-							help.addAll(y.elementAt(k));
-							help.addAll(x.elementAt(j));
-							cardprodret.add(help);
-						}
-					}
-        		}
-        		else 
-        			return new Menge<>(); //kein unifiziertes Ergebnis, damit wird das Geseamtergebnis []
-        		return cardprodret;
-        	});
-        	*/
         	typinferenzLog.debug("\nUnifiziere Constraints:\n"+constraints, Section.TYPEINFERENCE);
         	typinferenzLog.debug("\nFC:\n"+finiteClosure, Section.TYPEINFERENCE);
         	long start = System.currentTimeMillis();
@@ -361,7 +414,7 @@ public class SourceFile
 			long time = System.currentTimeMillis()-start;
 			typinferenzLog.debug("\nErgebnis der Unifizierung:\n"+unifyResult, Section.TYPEINFERENCE);
 			typinferenzLog.debug("\nAnzahl Lösungen:\n"+unifyResult.size(), Section.TYPEINFERENCE);
-			typinferenzLog.debug("\nZeit für Unifizierung: "+time + "ms", Section.TYPEINFERENCE);
+			//typinferenzLog.debug("\nZeit für Unifizierung: "+time + "ms", Section.TYPEINFERENCE);
 			
 			
             Menge<Menge<Pair>> convertedResult = unifyResult.parallelStream().<Menge<Pair>>map((Set<UnifyPair> resultSet)->{

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

@@ -50,10 +50,10 @@ public class UnifyTypeFactory {
 	public static FiniteClosure generateFC(TypeAssumptions fromAss){
 		HashSet<UnifyPair> pairs = new HashSet<>();
 		for(ClassAssumption cAss : fromAss.getClassAssumptions()){
-			UnifyType tl = UnifyTypeFactory.convert(cAss.getAssumedClass().getType());
-			RefType superClass = cAss.getAssumedClass().getSuperClass();
+			UnifyType tl = UnifyTypeFactory.convert(cAss.getAssumedClass().getType().TYPE(fromAss, cAss.getAssumedClass()));
+			Type superClass = cAss.getAssumedClass().getSuperClass();
 			if(superClass != null){
-				UnifyType tr = UnifyTypeFactory.convert(superClass);
+				UnifyType tr = UnifyTypeFactory.convert(superClass.TYPE(fromAss, cAss.getAssumedClass()));
 				pairs.add(generateSmallerPair(tl, tr));
 			}
 		}
@@ -125,8 +125,8 @@ public class UnifyTypeFactory {
 	}
 	
 	public static UnifyType convert(GenericTypeVar t){
-		//return new PlaceholderType(t.get_Name());
-		return new ReferenceType(t.get_Name());
+		return new PlaceholderType(TypePlaceholder.fresh(NULL_NODE).get_Name());
+		//return new ReferenceType(t.get_Name());
 	}
 
 	public static UnifyConstraintsSet convert(ConstraintsSet constraints) {
@@ -172,7 +172,7 @@ public class UnifyTypeFactory {
 
 	public static Type convert(ReferenceType t) {
 		//TODO: Hier kann man die GTVs extrahieren
-		if(t.getName() == "void")return new Void(NULL_NODE, 0);
+		if(t.getName().toString().equals(Void.VOID_NAME))return new Void(NULL_NODE, 0);
 		RefType ret = new RefType(t.getName(),null,0);
 		ret.set_ParaList(convert(t.getTypeParams()));
 		return ret;
@@ -197,7 +197,7 @@ public class UnifyTypeFactory {
 	public static Type convert(PlaceholderType t) {
 		TypePlaceholder ret = TypePlaceholder.getInstance(t.getName());
 		if(ret == null){ //Dieser TPH wurde vom Unifikationsalgorithmus erstellt
-			ret = TypePlaceholder.fresh(NULL_NODE);
+			ret = TypePlaceholder.fresh(t.getName(), NULL_NODE);
 		}
 		return ret;
 	}

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

@@ -95,7 +95,9 @@ public abstract class Operator extends SyntaxTreeNode
 		}else if(returnType.equals("java.lang.Long")){
 			il.append(_cg.getInstructionFactory().createInvoke("java.lang.Long", "longValue", org.apache.commons.bcel6.generic.Type.LONG, new  org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
 		}else if(returnType.equals("java.lang.String")){
-			
+			throw new NotImplementedException(returnType);
+		}else if(returnType.equals("java.lang.Boolean")){
+			il.append(_cg.getInstructionFactory().createInvoke("java.lang.Boolean", "booleanValue", org.apache.commons.bcel6.generic.Type.BOOLEAN, new  org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
 		}else{
 			throw new NotImplementedException(returnType);
 		}

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

@@ -179,8 +179,7 @@ public class Assign extends Expr
 	@Override
 	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 			DHBWInstructionFactory _factory = new DHBWInstructionFactory(cg, cg.getConstantPool());
-			InstructionList il = expr2.genByteCode(cg, rs);//expr2 rechte expr
-			
+			InstructionList il = expr2.genByteCode(cg, rs);//expr2 rechte expr			
 			
 			/*
 			String expr2Type = expr2.getType().get_Name().toString();
@@ -207,7 +206,7 @@ public class Assign extends Expr
 			}
 			*/
 			//Es wird momentan immer von RefType ausgegangen:
-			il.append(_factory.createStore(expr2.getType().getBytecodeType(cg, rs), expr1.get_Name()));
+			il.append(cg.getMethodGenerator().createStore(expr2.getType().getBytecodeType(cg, rs), expr1.get_Name()));
 			
 			return il;
 	}

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

@@ -169,7 +169,7 @@ public class LocalOrFieldVarOrClassname extends Expr
 		
 		String name = this.get_Name();
 		
-		il.append(cg.getInstructionFactory().createLoad(byteCodeType, name));
+		il.append(cg.getMethodGenerator().createLoad(byteCodeType, name));
 		return il;
 	}
 

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

@@ -376,7 +376,7 @@ public class LocalVarDecl extends Statement implements TypeInsertable
 
 	@Override
 	public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
-		_cg.getInstructionFactory().getStoreIndex(get_Name());
+		_cg.getMethodGenerator().getStoreIndex(get_Name());
 		return new InstructionList();
 	}
 }

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

@@ -326,8 +326,6 @@ public class MethodCall extends Expr
 	public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
 		InstructionList il = new InstructionList();
 		DHBWInstructionFactory _factory = cg.getInstructionFactory();
-		//TODO: später wiederherstelln?
-		_factory.resetStoreIndexes();
 		
 		il.append(receiver.get_Expr().genByteCode(cg, rs));
 		
@@ -346,7 +344,7 @@ public class MethodCall extends Expr
 			argumentTypen = new  org.apache.commons.bcel6.generic.Type[this.getArgumentList().size()];
 			int i = 0;
 			for(Expr argument : this.arglist.expr){
-				_factory.getStoreIndex(argument.get_Name());
+				cg.getMethodGenerator().getStoreIndex(argument.get_Name());
 				
 				argumentTypen[i] = argument.getType().getBytecodeType(cg, rs);
 				//Das Argument auf den Stack legen:

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

@@ -1,10 +1,12 @@
 // ino.module.NewClass.8642.package 
 package de.dhbwstuttgart.syntaxtree.statement;
+import java.util.ArrayList;
 // ino.end
 // ino.module.NewClass.8642.import 
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Iterator;
+import java.util.List;
 
 import org.apache.commons.bcel6.Constants;
 import  org.apache.commons.bcel6.generic.ClassGen;
@@ -23,6 +25,7 @@ import de.dhbwstuttgart.myexception.NotImplementedException;
 import de.dhbwstuttgart.myexception.SCExcept;
 import de.dhbwstuttgart.myexception.SCStatementException;
 import de.dhbwstuttgart.syntaxtree.Class;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.misc.UsedId;
 import de.dhbwstuttgart.syntaxtree.type.FunN;
@@ -60,6 +63,7 @@ public class NewClass extends Expr
     // ino.attribute.arglist.25837.declaration 
     private ArgumentList arglist;
 	private boolean isStatement = false;
+	private List<Type> parameterList = new ArrayList<>();
     // ino.end
     // ino.attribute.parserlog.25840.declaration 
     protected static Logger parserlog = Logger.getLogger("parser");
@@ -131,7 +135,6 @@ public class NewClass extends Expr
     
 	@Override
 	public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) {
-		//TODO: Das hier noch vervollständigen
 		ConstraintsSet ret = new ConstraintsSet();
 		UndConstraint callConstraints = new UndConstraint();
 		
@@ -144,7 +147,19 @@ public class NewClass extends Expr
 			ret.add(this.arglist.expr.elementAt(i).TYPEExpr(assumptions));
 			callConstraints.addConstraint( this.arglist.expr.elementAt(i).getType().TYPE(assumptions, this), cA.getParameterType(i).TYPE(assumptions, this));
 		}
-		Type thisT = assumptions.checkType(new RefType(this.get_Name(),this,0), (SyntaxTreeNode)this);
+		//Die Parameterliste befindet sich in der UsedID:
+		for(Type param : this.usedid.get_ParaList()){
+			this.parameterList.add(param.TYPE(assumptions, this));
+		}
+		
+		//Den Typ der Instruktion setzen:
+		RefType refTypeToCheck;
+		if(this.parameterList.size() == 0){
+			refTypeToCheck = new RefType(this.get_Name(),this,0);
+		}else{
+			refTypeToCheck = new RefType(this.get_Name(),this.parameterList,this,0);
+		}
+		Type thisT = assumptions.checkType(refTypeToCheck, (SyntaxTreeNode)this);
 		this.setType(thisT);
 		
 		return ret;

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

@@ -602,17 +602,18 @@ public class RefType extends ObjectType implements IMatchable
 					sb.append(((RefType) type).getCombinedType(cg, rs).replace(".", "%"));
 				}else if(type instanceof TypePlaceholder){
 					sb.append(((TypePlaceholder) type).getBytecodeType(cg, rs).toString().replace(".", "%"));
+				}else if(type instanceof WildcardType){
+					return this.getName().toString();
 				}else{
 					sb.append(type.getBytecodeType(cg, rs).toString().replace(".", "%"));
 				}
 				
 				sb.append("%");
 			}
-		}else{
-			sb.append(this.getName().toString());
-		}
+			return sb.toString();
+		}			
 		
-		return sb.toString();
+		return sb.append(this.getName().toString()).toString();
 	}
 	
 	public GenericClassType getGenericClassType(){

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

@@ -17,11 +17,6 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 
-class Test {
-	void methode(ArrayList<? super Integer> t){
-		
-	}
-}
 
 //TODO: Die Klasse Type muss abstract werden!
 // ino.class.Type.26716.declaration 

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

@@ -15,13 +15,14 @@ public class Void extends RefType
 // ino.end
 // ino.class.Void.26857.body
 {
+	public static final String VOID_NAME = "void";
     // ino.method.Void.26861.definition 
     public Void(SyntaxTreeNode parent,int offset)
     // ino.end
     // ino.method.Void.26861.body 
     {
         super(parent,offset);
-        super.setName("void");
+        super.setName(VOID_NAME);
     }
     // ino.end
     

src/de/dhbwstuttgart/typeinference/unify/model/ExtendsType.java

@@ -1,5 +1,7 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
@@ -81,4 +83,5 @@ public final class ExtendsType extends WildcardType {
 		return "? extends " + wildcardedType;
 	}
 
+	
 }

src/de/dhbwstuttgart/typeinference/unify/model/PlaceholderType.java

@@ -1,5 +1,7 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.Random;
 import java.util.Set;
@@ -106,4 +108,12 @@ public final class PlaceholderType extends UnifyType{
 		
 		return ((PlaceholderType) obj).getName().equals(typeName);
 	}
+	
+
+	@Override
+	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+		ArrayList<PlaceholderType> ret = new ArrayList<>();
+		ret.add(this);
+		return ret;
+	}
 }

src/de/dhbwstuttgart/typeinference/unify/model/TypeParams.java

@@ -1,6 +1,8 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Iterator;
 
 import de.dhbwstuttgart.typeinference.Menge;
@@ -168,5 +170,13 @@ public final class TypeParams implements Iterable<UnifyType>{
 			res += t + ",";
 		return "<" + res.substring(0, res.length()-1) + ">";
 	}
+
+	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+		ArrayList<PlaceholderType> ret = new ArrayList<>();
+		for(UnifyType t : typeParams){
+			ret.addAll(t.getInvolvedPlaceholderTypes());
+		}
+		return ret;
+	}
 }
 

src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java

@@ -1,5 +1,9 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
 /**
  * A pair which contains two types and an operator, e.q. (Integer <. a).
  * @author Florian Steurer
@@ -83,6 +87,13 @@ public class UnifyPair {
 	public String toString() {
 		return "(" + lhs + " " + pairOp + " " + rhs + ")";
 	}
+
+	public List<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+		ArrayList<PlaceholderType> ret = new ArrayList<>();
+		ret.addAll(lhs.getInvolvedPlaceholderTypes());
+		ret.addAll(rhs.getInvolvedPlaceholderTypes());
+		return ret;
+	}
 }
 
 

src/de/dhbwstuttgart/typeinference/unify/model/UnifyType.java

@@ -1,5 +1,8 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
 import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
@@ -87,4 +90,10 @@ public abstract class UnifyType {
 		
 		return typeName + params;
 	}
+
+	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+		ArrayList<PlaceholderType> ret = new ArrayList<>();
+		ret.addAll(typeParams.getInvolvedPlaceholderTypes());
+		return ret;
+	}
 }

src/de/dhbwstuttgart/typeinference/unify/model/WildcardType.java

@@ -1,5 +1,8 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Collection;
+
 /**
  * A wildcard type that is either a ExtendsType or a SuperType.
  * @author Florian Steurer
@@ -53,4 +56,12 @@ public abstract class WildcardType extends UnifyType {
 		WildcardType other = (WildcardType) obj;
 		return other.getWildcardedType().equals(wildcardedType);
 	}
+	
+
+	@Override
+	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+		ArrayList<PlaceholderType> ret = new ArrayList<>();
+		ret.addAll(wildcardedType.getInvolvedPlaceholderTypes());
+		return ret;
+	}
 }

test/KomplexeMenge/KeineDoppeltenVerweise.java

@@ -2,6 +2,7 @@ package KomplexeMenge;
 
 import static org.junit.Assert.*;
 
+import java.util.Set;
 import java.util.Vector;
 
 import org.junit.Test;
@@ -36,7 +37,7 @@ class TestKlasseOderMenge extends OderMenge<TestKlasse>{
 	}
 
 	public void addItem(TestKlasse string) {
-		TestUndMenge toAdd = new TestKlasseUndMenge();
+		TestKlasseUndMenge toAdd = new TestKlasseUndMenge();
 		toAdd.addItem(string);
 		set.add(toAdd);
 	}
@@ -61,24 +62,28 @@ class TestKlasseUndMenge extends UndMenge<TestKlasse>{
 	}
 }
 
+/**
+ * @Depreciated
+ * Tests möglicherweise obsolet
+ */
 public class KeineDoppeltenVerweise {
 	
 	@Test
 	public void test() {
-		OderMenge<TestKlasse> oM1 = new TestOderMenge();
-		OderMenge<TestKlasse> oM2 = new OderMenge<>();
-		UndMenge<TestKlasse> oM3 = new UndMenge<>();
+		TestKlasseOderMenge oM1 = new TestKlasseOderMenge();
+		TestKlasseOderMenge oM2 = new TestKlasseOderMenge();
+		TestKlasseUndMenge oM3 = new TestKlasseUndMenge();
 		oM1.addItem(new TestKlasse("Menge 1, Item 1"));
 		oM1.addItem(new TestKlasse("Menge 1, Item 2"));
 		oM2.addItem(new TestKlasse("Menge 2, Item 1"));
 		oM2.addItem(new TestKlasse("Menge 2, Item 2"));
 		oM3.addItems(oM1);
 		oM3.addItems(oM2);
-		Menge<Menge<TestKlasse>> cP = oM3.cartesianProduct();
+		Set<Set<TestKlasse>> cP = oM3.cartesianProduct();
 		System.out.println(cP);
-		cP.firstElement().firstElement().name="neu";
+		cP.iterator().next().iterator().next().name="neu";
 		System.out.println(cP);
-		check(cP);
+		//check(cP); //TODO Muss neu implementiert werden
 	}
 
 	private <A> void check(Menge<Menge<A>> cP){

test/bytecode/IfTest.java

@@ -1,9 +0,0 @@
-class IfTest{
-
-public static void main(String[] args){
-
-	System.out.println(new IfElseStatement().method(true));
-	System.out.println(new IfElseStatement().method(false));
-}
-
-}

test/bytecode/SourceFileBytecodeTest.java

@@ -21,6 +21,7 @@ public abstract class SourceFileBytecodeTest extends TestCase{
 	protected String testName;
 	
 	public SourceFileBytecodeTest(){
+		super("Bytecode Test");
 		init();
 		
 		if(testName != null){
@@ -29,6 +30,7 @@ public abstract class SourceFileBytecodeTest extends TestCase{
 			outputDirectory = "";
 			
 			SingleClassTester.compileToBytecode(rootDirectory+testFile, rootDirectory+outputDirectory);
+			System.out.println("Test");
 		}else{
 			throw new RuntimeException("rootDirectory, testFile or outputFile is null.");
 		}

test/bytecode/Test.java

@@ -1,27 +0,0 @@
-/**
- * Diese Klasse testet die generierte EmptyClass.class-Datei
- */
-class Test{
-public static void main(String[] args){
-	new EmptyClass();
-	new Assign();
-	System.out.println(new Return().method());
-	new MethodCall().method();
-	System.out.println(new FieldDeclaration().field);
-	System.out.println(new Runnable().method().apply());
-	Runnable r = new Runnable().method().apply();
-	Test t = new Identity<Test,Test>().op.apply(new Test());
-	System.out.println(t);
-}
-}
-
-class Test2<X>{
-	Fun1<? extends X,? super X> m() {
-		Fun1<? extends X,? super X> f =  new Identity<X,X>().op;
-		return f;
-	}
-public static void main(String[] args){
-	Matrix2<Integer,Integer> m2 = new Matrix2<>();
-	System.out.println(m2.op.apply((Integer x) -> x));
-}
-}

test/bytecode/Test2.java

@@ -1,6 +0,0 @@
-class Test2{
-
-	public static void main(java.lang.String[] args){
-		new NewStatement(1).method();
-}
-}

test/bytecode/Test3.java

@@ -1,6 +0,0 @@
-class Test3{
-
-public static void main(String[] args){
-System.out.println(new LambdaExpr2Test().op.apply());
-}
-}

test/bytecode/TestStackMap.java

@@ -1,8 +0,0 @@
-class TestStackMap{
-
-public static void main(String[] args){
-	IfElseStatement test = new IfElseStatement();
-	System.out.println(test.method(false));
-}
-
-}

test/bytecode/UninitializedVariable.jav

@@ -0,0 +1,15 @@
+import java.util.Vector;
+
+class UninitializedVariable{
+
+	Integer method(Integer v) {
+		return v;
+	}
+	
+	public static void main(String[] args) {
+		UninitializedVariable ol;
+		ol = new UninitializedVariable();
+		Integer v;
+		ol.method(v);
+   } 
+}

test/bytecode/UninitializedVariableTest.java

@@ -0,0 +1,39 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.io.IOException;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+
+import plugindevelopment.TypeInsertTester;
+import de.dhbwstuttgart.core.MyCompiler;
+import de.dhbwstuttgart.core.MyCompilerAPI;
+import de.dhbwstuttgart.logger.LoggerConfiguration;
+import de.dhbwstuttgart.logger.Section;
+import de.dhbwstuttgart.parser.JavaParser.yyException;
+import de.dhbwstuttgart.typeinference.ByteCodeResult;
+import de.dhbwstuttgart.typeinference.Menge;
+import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
+import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
+
+public class UninitializedVariableTest extends SourceFileBytecodeTest{
+	@Override
+	protected void init() {
+		testName = "UninitializedVariable";
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
+	}
+	
+	@Test
+	public void testConstruct() throws Exception{
+	    ClassLoader classLoader = getClassLoader();
+
+	    Class cls =  classLoader.loadClass(testName);
+	    
+		Object obj = cls.newInstance();
+		assertTrue(true);
+	}
+}

test/bytecode/VariableMultimethods.jav

@@ -0,0 +1,14 @@
+class VariableMultimethods{
+	public Integer method(Integer z, Integer x, Integer y){
+		return x+y+z;
+	}
+	
+	public Integer method(Integer x, Integer y){
+		return x+y;
+	}
+	
+	public Integer method(Integer y){
+		return y;
+	}
+	
+}

test/bytecode/VariableMultimethodsTest.java

@@ -0,0 +1,98 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Vector;
+
+import org.junit.Test;
+
+import org.junit.Ignore;
+
+import bytecode.SourceFileBytecodeTest;
+
+
+public class VariableMultimethodsTest extends SourceFileBytecodeTest{
+	@Override
+	protected void init() {
+		testName = "VariableMultimethods";
+		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
+	}
+	
+	@Test
+	public void testConstruct() throws Exception{
+	    ClassLoader classLoader = getClassLoader();
+
+	    Class cls =  classLoader.loadClass(testName);
+	    
+		Object obj = cls.newInstance();
+		assertTrue(true);
+	}
+	
+	@Test
+	public void testOneArgument() throws Exception{
+	    ClassLoader classLoader = getClassLoader();
+
+	    Class cls =  classLoader.loadClass(testName);
+	    
+		Object obj = cls.newInstance();
+		
+		Integer y = 1;
+		
+		Class[] params = new Class[]{
+				y.getClass()
+		};
+		
+		Method method = cls.getDeclaredMethod("method", params);
+		Integer returnValue = (Integer) method.invoke(obj, y);
+		assertEquals(new Integer(1), returnValue);
+	}
+	
+	@Test
+	public void testTwoArgument() throws Exception{
+	    ClassLoader classLoader = getClassLoader();
+
+	    Class cls =  classLoader.loadClass(testName);
+	    
+		Object obj = cls.newInstance();
+		
+		Integer x = 1;
+		Integer y = 2;
+		
+		Class[] params = new Class[]{
+				x.getClass(),
+				y.getClass()
+		};
+		
+		Method method = cls.getDeclaredMethod("method", params);
+		Integer returnValue = (Integer) method.invoke(obj, x, y);
+		assertEquals(new Integer(3), returnValue);
+	}
+	
+	@Test
+	public void testThreeArgument() throws Exception{
+	    ClassLoader classLoader = getClassLoader();
+
+	    Class cls =  classLoader.loadClass(testName);
+	    
+		Object obj = cls.newInstance();
+		
+		Integer z = 1;
+		Integer x = 2;
+		Integer y = 4;
+		
+		Class[] params = new Class[]{
+				z.getClass(),
+				x.getClass(),
+				y.getClass()
+		};
+		
+		Method method = cls.getDeclaredMethod("method", params);
+		Integer returnValue = (Integer) method.invoke(obj, z, x, y);
+		assertEquals(new Integer(7), returnValue);
+	}
+}

test/bytecode/WhileTest.java

@@ -1,8 +1,14 @@
 package bytecode;
 
 import org.junit.Test;
+import org.junit.runners.Suite;
 
 public class WhileTest extends SourceFileBytecodeTest{
+
+	public WhileTest(){
+		super();
+	}
+
 	@Override
 	protected void init() {
 		testName = "WhileTest";

test/bytecode/types/ExtendsTypeTest.java

@@ -1,33 +0,0 @@
-package bytecode.types;
-
-import static org.junit.Assert.*;
-
-import java.io.File;
-import java.lang.reflect.Method;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.Vector;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import bytecode.SourceFileBytecodeTest;
-
-public class ExtendsTypeTest extends SourceFileBytecodeTest{
-	@Override
-	protected void init() {
-		testName = "ExtendsType";
-		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
-	}
-
-	@Test
-	@Ignore
-	public void testConstruct() throws Exception{
-	    ClassLoader classLoader = getClassLoader();
-
-	    Class cls =  classLoader.loadClass(testName);
-	    
-		Object obj = cls.newInstance();
-		assertTrue(true);
-	}
-}

test/bytecode/types/ExtendsVectorStringTest.java

@@ -61,7 +61,7 @@ public class ExtendsVectorStringTest extends ASTBytecodeTest{
 		    
 			Object obj = cls.newInstance();
 
-		    Class objectClass =  classLoader.loadClass("java.lang.Object");
+		    Class objectClass =  classLoader.loadClass("java.lang.String");
 			
 			Class[] params = new Class[1];
 			params[0] = objectClass;

test/bytecode/types/OL.jav

@@ -1,6 +1,18 @@
 class OL {
 
-	m(x) { return x + x; }
+    m(x) { return x + x; }
+	
+	m(Boolean x) { return x; }
+}
+
+  
+
+class Main {
+
+	main(x) { 
+		ol;
+		ol = new OL();
+		return ol.m(x);
+	} 
 	
- 	Boolean m(Boolean x) {return x; }
 }

test/bytecode/types/SuperType.java

@@ -1,37 +0,0 @@
-package bytecode.types;
-
-import static org.junit.Assert.*;
-
-import java.io.File;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.Vector;
-
-import org.junit.Test;
-
-import org.junit.Ignore;
-
-import bytecode.SourceFileBytecodeTest;
-
-
-public class SuperType extends SourceFileBytecodeTest{
-
-	@Override
-	protected void init() {
-		testName = "ExtendsType";
-		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
-	}
-	
-	@Test
-	@Ignore
-	public void testConstruct() throws Exception{
-	    ClassLoader classLoader = getClassLoader();
-
-	    Class cls =  classLoader.loadClass(testName);
-	    
-		Object obj = cls.newInstance();
-		assertTrue(true);
-	}
-}

test/bytecode/types/WildcardTest.jav

@@ -1,13 +1,11 @@
 import java.util.Vector;
 
-class SuperType{
-	Vector<Number> numberVector;
-
-	void method() {
-		method(numberVector);
+class WildcardTest{	
+	void lower(Vector<? super Integer> v) {
+		
 	}
 	
-	void method(Vector<? super Integer> v) {
+	void upper(Vector<? extends Integer> v) {
 		
 	}
 }

test/bytecode/types/WildcardTest.java

@@ -12,7 +12,7 @@ import bytecode.SourceFileBytecodeTest;
 public class WildcardTest extends SourceFileBytecodeTest{
 	@Override
 	protected void init() {
-		testName = "Wildcard";
+		testName = "WildcardTest";
 		rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
 	}
 	

test/plugindevelopment/InsertSingleTypeTest.java

@@ -7,6 +7,7 @@ import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.typeinference.Menge;
 
 import org.junit.Test;
@@ -43,8 +44,9 @@ public class InsertSingleTypeTest {
 		String inferedSource = "";
 		MyCompilerAPI compiler = MyCompiler.getAPI(new LoggerConfiguration().setOutput(Section.TYPEINFERENCE, System.out));
 		try {
-			compiler.parse(new File(rootDirectory + sourceFileToInfere));
-			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction();
+			SourceFile parsed = compiler.parse(new File(rootDirectory + sourceFileToInfere));Menge<SourceFile> sourceFiles = new Menge<>();
+			sourceFiles.add(parsed);
+			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction(sourceFiles);
 			TestCase.assertTrue("Es darf nicht mehr als eine L�sungsm�glichkeit geben und nicht "+results.size(), results.size()==1);
 			return results.firstElement();
 		} catch (IOException | yyException e) {

test/plugindevelopment/MartinTestCases/Tester.java

@@ -3,6 +3,7 @@ package plugindevelopment.MartinTestCases;
 import java.io.File;
 import java.io.IOException;
 
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.typeinference.Menge;
 
 import org.junit.Test;
@@ -27,8 +28,10 @@ public class Tester extends TypeInsertTester{
 		String inferedSource = "";
 		MyCompilerAPI compiler = MyCompiler.getAPI(new LoggerConfiguration().setOutput(Section.TYPEINFERENCE, System.out));
 		try {
-			compiler.parse(new File(rootDirectory + sourceFileToInfere));
-			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction();
+			SourceFile parsed = compiler.parse(new File(rootDirectory + sourceFileToInfere));
+			Menge<SourceFile> sourceFiles = new Menge<>();
+			sourceFiles.add(parsed);
+			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction(sourceFiles);
 			//TestCase.assertTrue("Es darf nicht mehr als eine L�sungsm�glichkeit geben und nicht "+results.size(), results.size()==1);
 			for(TypeinferenceResultSet result : results){
 				TypeInsertSet point = result.getTypeInsertionPoints();

test/plugindevelopment/TypeInsertTester.java

@@ -8,6 +8,8 @@ import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Paths;
+
+import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.typeinference.Menge;
 
 import de.dhbwstuttgart.logger.Logger;
@@ -44,8 +46,10 @@ public class TypeInsertTester{
 		String inferedSource = "";
 		MyCompilerAPI compiler = MyCompiler.getAPI(logConfig);
 		try {
-			compiler.parse(new File(rootDirectory + sourceFileToInfere));
-			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction();
+			SourceFile parsed = compiler.parse(new File(rootDirectory + sourceFileToInfere));
+			Menge<SourceFile> sourceFiles = new Menge<>();
+			sourceFiles.add(parsed);
+			Menge<TypeinferenceResultSet> results = compiler.typeReconstruction(sourceFiles);
 			TestCase.assertTrue("Es darf nicht mehr als eine Lösungsmöglichkeit geben und nicht "+results.size(), results.size()==1);
 			for(TypeinferenceResultSet result : results){
 				TypeInsertSet point = result.getTypeInsertionPoints();

test/plugindevelopment/TypeInsertTests/OverloadingVector.jav

@@ -0,0 +1,21 @@
+import java.util.Vector;
+
+class OverloadingVector{
+
+	void method(Vector<String> v) {
+
+	}
+	
+	void method(Vector<Integer> v) {
+	
+	}
+	
+	main(String args) {
+		ol;
+		ol = new OverloadingVector();
+		v;
+		v = new Vector<String> ();
+		ol.method(v);
+    }
+	
+}

test/plugindevelopment/TypeInsertTests/OverloadingVectorTest.java

@@ -0,0 +1,15 @@
+package plugindevelopment.TypeInsertTests;
+
+import de.dhbwstuttgart.typeinference.Menge;
+
+import org.junit.Test;
+
+public class OverloadingVectorTest {
+	private static final String TEST_FILE = "OverloadingVector.jav";
+	
+	@Test
+	public void run(){
+		Menge<String> mustContain = new Menge<String>();
+		MultipleTypesInsertTester.testSingleInsert(this.TEST_FILE, mustContain);
+	}
+}

test/unify/UnifyTest.java

@@ -861,9 +861,11 @@ public class UnifyTest {
 
 		UnifyType tphT1 = tf.getPlaceholderType("T1");
 		UnifyType tphT2 = tf.getPlaceholderType("T2");
-
-		UnifyType vector = tf.getSimpleType("Vector", "T");
-		UnifyType vectorE = tf.getSimpleType("Vector", tphT2);
+
+		UnifyType gtv = tf.getSimpleType("gtv");
+		UnifyType vector = tf.getSimpleType("Vector", gtv);
+		UnifyType vectorT2 = tf.getSimpleType("Vector", tphT2);
+		
 		UnifyType string = tf.getSimpleType("String");
 		UnifyType vectorString = tf.getSimpleType("Vector", string);
 		
@@ -872,8 +874,8 @@ public class UnifyTest {
 		IFiniteClosure fc = fcb.getFiniteClosure();
 		
 		Set<UnifyPair> eq = new HashSet<UnifyPair>();
+		eq.add(new UnifyPair(vectorT2, tphT1, PairOperator.SMALLERDOT));
 		eq.add(new UnifyPair(tphT1, vectorString, PairOperator.SMALLERDOT));
-		eq.add(new UnifyPair(vectorE, tphT1, PairOperator.SMALLERDOT));
 
 		Set<Set<UnifyPair>> actual = new TypeUnify().unifySequential(eq, fc);