diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java index c6a2f5b3..ed809c63 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java @@ -124,7 +124,8 @@ public class UnifyTypeFactory { } public static UnifyType convert(GenericTypeVar t){ - return new PlaceholderType(t.get_Name()); + //return new PlaceholderType(t.get_Name()); + return new ReferenceType(t.get_Name()); } public static UnifyConstraintsSet convert(ConstraintsSet constraints) { diff --git a/src/de/dhbwstuttgart/syntaxtree/type/FunN.java b/src/de/dhbwstuttgart/syntaxtree/type/FunN.java index efe96c26..b2d27792 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/FunN.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/FunN.java @@ -1,15 +1,20 @@ package de.dhbwstuttgart.syntaxtree.type; +import java.util.ArrayList; import java.util.Iterator; +import java.util.List; + import de.dhbwstuttgart.typeinference.Menge; import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; import de.dhbwstuttgart.bytecode.ClassGenerator; import de.dhbwstuttgart.parser.JavaClassName; import de.dhbwstuttgart.syntaxtree.Method; import de.dhbwstuttgart.syntaxtree.ParameterList; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption; import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions; +import de.dhbwstuttgart.typeinference.exceptions.DebugException; /** * @see Spezifikation "Complete Typeinference in Java 8" von Martin Plümicke @@ -23,7 +28,7 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions; public class FunN extends RefType { private Type R; - private Menge T; + private List T; /** * @author Andreas Stadelmeier, a10023 @@ -33,7 +38,7 @@ public class FunN extends RefType { * @param T * @return */ - public FunN(Type R, Menge T) { + public FunN(Type R, List T) { super("",null,0); if(T==null || R == null)throw new NullPointerException(); setT(T); @@ -44,11 +49,11 @@ public class FunN extends RefType { /** * Spezieller Konstruktor um eine FunN ohne Returntype zu generieren */ - protected FunN(Menge T){ + protected FunN(List list){ super("",null,0); - if(T==null)throw new NullPointerException(); - setT(T); - this.name = new JavaClassName("Fun"+T.size());//getName(); + if(list==null)throw new NullPointerException(); + setT(list); + this.name = new JavaClassName("Fun"+list.size());//getName(); } /** @@ -68,15 +73,6 @@ public class FunN extends RefType { setT(t); this.name = new JavaClassName("Fun"+parameterCount); - /* - Menge t = new Menge(); - for(int i=0;i t = new Menge(); if(R!=null)t.add(R); if(T!=null)t.addAll(T); + for(Type type : t){ + if(type instanceof WildcardType){ + throw new DebugException("Der FunN-Typ darf keine Wildcards in den Parameter enthalten"); + } + } this.set_ParaList(t); } - protected void setT(Menge T){ - this.T = T; + protected void setT(List list){ + this.T = list; calculateNewParalist(); } protected void setR(Type R){ @@ -137,6 +138,16 @@ public class FunN extends RefType { return ret; } + @Override + public Type TYPE(TypeAssumptions ass, SyntaxTreeNode parent){ + //FunN Typen müssen nicht geprüft werden. Sie werden schließlich nur von unserem Typinferenzalgorithmus erstellt: + List paraList = new ArrayList<>(); + for(Type t : this.T){ + paraList.add(t.TYPE(ass, parent)); + } + FunN ret = new FunN(this.R.TYPE(ass, parent),paraList); + return ret; + } /* public CMethodTypeAssumption toCMethodTypeAssumption() { diff --git a/src/de/dhbwstuttgart/typeinference/FunNInterface.java b/src/de/dhbwstuttgart/typeinference/FunNInterface.java index 920b4899..5a8e7280 100644 --- a/src/de/dhbwstuttgart/typeinference/FunNInterface.java +++ b/src/de/dhbwstuttgart/typeinference/FunNInterface.java @@ -2,9 +2,12 @@ package de.dhbwstuttgart.typeinference; import de.dhbwstuttgart.typeinference.Menge; +import java.util.List; + import de.dhbwstuttgart.parser.JavaClassName; import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.modifier.Modifiers; +import de.dhbwstuttgart.syntaxtree.type.FunN; import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.Type; @@ -78,5 +81,15 @@ public class FunNInterface extends Class{ return new FunNMethod(this.get_ParaList()); //return new FunNMethod(this.get_ParaList().size()-1); } + + @Override + public RefType getType() { + List paraList = this.get_ParaList(); + Type R = paraList.get(0); + paraList.remove(0); + return new FunN(R, paraList); + } + + } diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/TypeAssumptions.java b/src/de/dhbwstuttgart/typeinference/assumptions/TypeAssumptions.java index 7ece0a81..fe59bbd2 100755 --- a/src/de/dhbwstuttgart/typeinference/assumptions/TypeAssumptions.java +++ b/src/de/dhbwstuttgart/typeinference/assumptions/TypeAssumptions.java @@ -257,18 +257,6 @@ public class TypeAssumptions { * @return null, falls der Typ nicht vorhanden ist. */ public Type getTypeFor(Type t, SyntaxTreeNode inNode){ - /* - if(t instanceof WildcardType){ - WildcardType wt = (WildcardType)t; - Type innerType = wt.GetWildcardType(); - innerType = getTypeFor(innerType, t).getType(); - wt.SetWildcardType(innerType); - return new ConstraintType(wt); - } - - if(t instanceof TypePlaceholder) - return new ConstraintType((TypePlaceholder)t); //Handelt es sich um einen TypePlaceholder kann dieser nicht in den Assumptions vorkommen. - */ //Alle bekannten Klassen nach diesem Typ durchsuchen: JavaClassName typName = t.getName(); for(ClassAssumption ass : this.classAssumptions){ diff --git a/test/plugindevelopment/TypeInsertTests/MultipleTypesInsertTester.java b/test/plugindevelopment/TypeInsertTests/MultipleTypesInsertTester.java index 4542f9f0..77e1c27b 100755 --- a/test/plugindevelopment/TypeInsertTests/MultipleTypesInsertTester.java +++ b/test/plugindevelopment/TypeInsertTests/MultipleTypesInsertTester.java @@ -69,11 +69,12 @@ public class MultipleTypesInsertTester extends TypeInsertTester{ } catch (IOException | yyException e) { e.printStackTrace(); TestCase.fail(); + }finally{ + writeLog(sourceFileToInfere+".log"); } for(String containString : mustContain){ TestCase.assertTrue("\""+containString+"\" muss in den inferierten Lösungen vorkommen",gesamterSrc.contains(containString)); } - writeLog(sourceFileToInfere+".log"); } public static void testSingleInsert(String sourceFileToInfere, Menge mustContain){