From fa337c554612f297acfc5979c822971fdb1a828c Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Tue, 29 Mar 2016 13:23:05 +0200 Subject: [PATCH] Umstellung auf MPair beginnen --- .settings/org.eclipse.core.resources.prefs | 2 + .../dhbwstuttgart/syntaxtree/SourceFile.java | 44 ++++++++----------- .../syntaxtree/factory/UnifyTypeFactory.java | 38 ++++++++++++++-- .../typeinference/ConstraintsSet.java | 4 ++ .../typeinference/EinzelElement.java | 4 ++ .../typeinference/UndConstraint.java | 4 ++ .../typeinference/unify/Unifier.java | 4 +- 7 files changed, 69 insertions(+), 31 deletions(-) diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs index 5c6e1080..9305e36f 100755 --- a/.settings/org.eclipse.core.resources.prefs +++ b/.settings/org.eclipse.core.resources.prefs @@ -3,4 +3,6 @@ encoding//src/de/dhbwstuttgart/core/MyCompiler.java=UTF-8 encoding//src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java=UTF-8 encoding//src/de/dhbwstuttgart/typeinference/SingleConstraint.java=UTF-8 encoding//src/de/dhbwstuttgart/typeinference/UndConstraint.java=UTF-8 +encoding//src/de/dhbwstuttgart/typeinference/UnifySingleConstraint.java=UTF-8 +encoding//src/de/dhbwstuttgart/typeinference/UnifyUndConstraint.java=UTF-8 encoding/=UTF-8 diff --git a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java index 18e43236..301b73f1 100755 --- a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java +++ b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java @@ -46,6 +46,7 @@ import de.dhbwstuttgart.typeinference.ResultSet; import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; import de.dhbwstuttgart.typeinference.TypeinferenceResults; import de.dhbwstuttgart.typeinference.UndConstraint; +import de.dhbwstuttgart.typeinference.UnifyConstraintsSet; import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption; import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption; import de.dhbwstuttgart.typeinference.assumptions.ParameterAssumption; @@ -255,22 +256,27 @@ public class SourceFile //////////////// - //Karthesisches Produkt bilden: + //Typen in UnifyTypen umwandeln: //////////////// + UnifyConstraintsSet unifyConstraints = UnifyTypeFactory.convert(oderConstraints); //Unmögliche ConstraintsSets aussortieren durch Unifizierung - Function,Menge>> unifier = (pairs)->{ - Menge> retValue = new Menge<>(); - Set convertPairs = UnifyTypeFactory.convert(pairs); - Set> unifiedPairs = new Unify().unify(convertPairs, finiteClosure); + Function,Menge>> unifier = (pairs)->{ + Menge> retValue = new Menge<>(); + Set> unifiedPairs = new Unify().unify(pairs, finiteClosure); return retValue;}; //oderConstraints.filterWrongConstraints(unifier); //oderConstraints.unifyUndConstraints(unifier); //rausgeworfen für Tests (08.12.2015) - + typinferenzLog.debug("Übriggebliebene Konstraints:\n"+oderConstraints+"\n", Section.TYPEINFERENCE); - //Die Constraints in Pair's umwandeln (Karthesisches Produkt bilden): - Set> xConstraints = oderConstraints.cartesianProduct(); + + //////////////// + //Karthesisches Produkt bilden: + //////////////// + Set> xConstraints = unifyConstraints.cartesianProduct(); + + typinferenzLog.debug("Karthesisches Produkt der Constraints: "+xConstraints, Section.TYPEINFERENCE); @@ -280,28 +286,15 @@ public class SourceFile // Unifizierung der Constraints: ////////////////////////////// boolean unifyFail = true; - for(Set constraints : xConstraints){ + for(Set constraints : xConstraints){ //Alle durch das Karthesische Produkt entstandenen Möglichkeiten durchgehen: Menge> result = new Menge>(); - //Alle FunN-Typen werden per clone-methode in RefTypes verwandelt. (Die clone Methode in FunN darf nicht überschrieben werden. - for(Pair p : constraints){ - if(p.TA1 instanceof FunN){ - p.TA1 = p.TA1.clone(); - } - if(p.TA2 instanceof FunN){ - p.TA2 = p.TA2.clone(); - } - } - - //Erst die Unifizierung erstellen: - Menge constraintsClone = (Menge)constraints.clone(); - //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> constraintsclonevars = constraintsClone.stream().map(p -> {Menge TPHs = new Menge<>(); + Menge> constraintsclonevars = constraints.stream().map(p -> {Menge TPHs = new Menge<>(); TPHs.addAll(p.TA1.getInvolvedTypePlaceholder()); TPHs.addAll(p.TA2.getInvolvedTypePlaceholder()); return TPHs;} @@ -362,7 +355,8 @@ public class SourceFile return new Menge<>(); //kein unifiziertes Ergebnis, damit wird das Geseamtergebnis [] return cardprodret; }); - + */ + Set> unifyResult = new Unify().unify(constraints, finiteClosure); //Dann den Ergebnissen anfügen typinferenzLog.debug("\nErgebnis der Unifizierung:\n"+unifyResult, Section.TYPEINFERENCE); result.addAll(unifyResult); diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java index 5e9d1876..9a53305b 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java @@ -11,11 +11,18 @@ import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType; import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.syntaxtree.type.WildcardType; +import de.dhbwstuttgart.typeinference.ConstraintsSet; +import de.dhbwstuttgart.typeinference.EinzelElement; import de.dhbwstuttgart.typeinference.KomplexeMenge; import de.dhbwstuttgart.typeinference.Menge; +import de.dhbwstuttgart.typeinference.OderConstraint; import de.dhbwstuttgart.typeinference.OderMenge; import de.dhbwstuttgart.typeinference.Pair; +import de.dhbwstuttgart.typeinference.UndConstraint; import de.dhbwstuttgart.typeinference.UndMenge; +import de.dhbwstuttgart.typeinference.UnifyConstraintsSet; +import de.dhbwstuttgart.typeinference.UnifyOderConstraint; +import de.dhbwstuttgart.typeinference.UnifyUndConstraint; import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption; import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions; import de.dhbwstuttgart.typeinference.unify.model.ExtendsType; @@ -85,11 +92,34 @@ public class UnifyTypeFactory { return new SimpleType(t.get_Name()); } - public static UndMenge convert(UndMenge constraints) { - return null; + public static UnifyConstraintsSet convert(ConstraintsSet constraints) { + UnifyConstraintsSet ret = new UnifyConstraintsSet(); + for(OderConstraint oC : constraints.getOderConstraints()){ + ret.add(UnifyTypeFactory.convert(oC)); + } + return ret; + } + + private static UnifyOderConstraint convert(OderConstraint set) { + UnifyOderConstraint ret = new UnifyOderConstraint(); + for(UndConstraint oC : set.getUndConstraints()){ + ret.addConstraint(UnifyTypeFactory.convert(oC)); + } + return ret; } - public static OderMenge convert(OderMenge constraints) { - return null; + private static UnifyUndConstraint convert(UndConstraint set) { + UnifyUndConstraint ret = new UnifyUndConstraint(); + for(EinzelElement oC : set.getPairs()){ + ret.add(UnifyTypeFactory.convert(oC)); + } + return ret; + } + + private static MPair convert(EinzelElement p) { + if(!p.getItem().OperatorSmaller())throw new NotImplementedException(); + MPair ret = smaller(UnifyTypeFactory.convert(p.getItem().TA1) + , UnifyTypeFactory.convert(p.getItem().TA2)); + return ret; } } diff --git a/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java b/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java index 84475cbf..5728f1dc 100755 --- a/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java +++ b/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java @@ -90,6 +90,10 @@ public class ConstraintsSet extends UndMenge implements Iterable> getSet() { + return this.getOderConstraints(); + } + + public Menge getOderConstraints() { return this.constraintsSet; } } diff --git a/src/de/dhbwstuttgart/typeinference/EinzelElement.java b/src/de/dhbwstuttgart/typeinference/EinzelElement.java index 58f4970d..17f3b302 100644 --- a/src/de/dhbwstuttgart/typeinference/EinzelElement.java +++ b/src/de/dhbwstuttgart/typeinference/EinzelElement.java @@ -30,4 +30,8 @@ public class EinzelElement implements KomplexeMenge{ return item.toString(); } + public A getItem(){ + return item; + } + } \ No newline at end of file diff --git a/src/de/dhbwstuttgart/typeinference/UndConstraint.java b/src/de/dhbwstuttgart/typeinference/UndConstraint.java index a30e4127..741667f3 100755 --- a/src/de/dhbwstuttgart/typeinference/UndConstraint.java +++ b/src/de/dhbwstuttgart/typeinference/UndConstraint.java @@ -1,6 +1,7 @@ package de.dhbwstuttgart.typeinference; import java.util.Collection; +import java.util.Set; import java.util.Vector; import de.dhbwstuttgart.syntaxtree.type.Type; @@ -41,6 +42,9 @@ public class UndConstraint extends UndMenge { return ret; } + public Set> getPairs(){ + return set; + } /* public UndConstraint(ConstraintType p1, ConstraintType p2) { diff --git a/src/de/dhbwstuttgart/typeinference/unify/Unifier.java b/src/de/dhbwstuttgart/typeinference/unify/Unifier.java index acc14281..b348b28c 100644 --- a/src/de/dhbwstuttgart/typeinference/unify/Unifier.java +++ b/src/de/dhbwstuttgart/typeinference/unify/Unifier.java @@ -2,10 +2,10 @@ package de.dhbwstuttgart.typeinference.unify; import java.util.Set; -import de.dhbwstuttgart.typeinference.Pair; +import de.dhbwstuttgart.typeinference.unify.model.MPair; public interface Unifier { - public Set> apply (Set E); + public Set> apply (Set E); }