Test für Methodenparameter erstellt

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,7 @@ 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 +181,14 @@ 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){
@@ -80,6 +92,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/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/factory/UnifyTypeFactory.java

@@ -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;

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/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
     

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/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,6 @@
 class OL {
-
 	m(x) { return x + x; }
 	
- 	Boolean m(Boolean x) {return x; }
+ 	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/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

@@ -864,7 +864,7 @@ public class UnifyTest {
 
 		UnifyType gtv = tf.getSimpleType("gtv");
 		UnifyType vector = tf.getSimpleType("Vector", gtv);
-		UnifyType vectorE = tf.getSimpleType("Vector", tphT2);
+		UnifyType vectorT2 = tf.getSimpleType("Vector", tphT2);
 		UnifyType string = tf.getSimpleType("String");
 		UnifyType vectorString = tf.getSimpleType("Vector", string);
 		
@@ -873,8 +873,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);