From 1ec9c3f67f1596f657bd37ed3d8ffca0533590f2 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Tue, 3 Mar 2015 18:24:14 +0100 Subject: [PATCH 1/3] Fehler in Umwandlung von RefType zu GTV in BoGTV beheben --- .../dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java b/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java index 516abdbe..46a043f3 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java @@ -88,14 +88,16 @@ public class BoundedGenericTypeVar extends GenericTypeVar ConstraintsSet ret = super.TYPE(ass); //ass.addGenericVarAssumption(this); //Die Type methode der BoundedGenericTypeVar schreibt zusätzlich noch die Constraints für die bounds + Vector tempBounds = new Vector<>(); if(this.bounds != null){ for(Type ev : this.bounds){ ConstraintType extendsType = ass.getTypeFor(ev, this); if(extendsType == null)throw new TypeinferenceException("Der Typ "+ev.getName()+" ist nicht korrekt", this); - + tempBounds.add(extendsType.getType()); //ret.add(new SingleConstraint(ass.getTypeFor(this, this), extendsType )); } } + this.bounds = tempBounds; return ret; } From e8538be1c28decab6a66e08b20c7c341b3f148c6 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 4 Mar 2015 13:50:09 +0100 Subject: [PATCH 2/3] Fehler in Umwandlung von GTV zu TPH beheben --- .../typeinference/ResultSet.java | 1 + .../assumptions/TypeAssumptions.java | 20 +++++++++++++++---- .../TypeInsertTests/GenericTypeVarTest.java | 15 ++++++-------- .../TypeInsertTests/IntTest.java | 2 +- 4 files changed, 24 insertions(+), 14 deletions(-) diff --git a/src/de/dhbwstuttgart/typeinference/ResultSet.java b/src/de/dhbwstuttgart/typeinference/ResultSet.java index e86335f0..a856d6d9 100755 --- a/src/de/dhbwstuttgart/typeinference/ResultSet.java +++ b/src/de/dhbwstuttgart/typeinference/ResultSet.java @@ -5,6 +5,7 @@ import java.util.Vector; import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; +import de.dhbwstuttgart.typeinference.exceptions.DebugException; /** * Im Grunde Sammlung von Pair s mit Equal-Operatoren. diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/TypeAssumptions.java b/src/de/dhbwstuttgart/typeinference/assumptions/TypeAssumptions.java index acd08a43..ecb6c6c5 100755 --- a/src/de/dhbwstuttgart/typeinference/assumptions/TypeAssumptions.java +++ b/src/de/dhbwstuttgart/typeinference/assumptions/TypeAssumptions.java @@ -327,15 +327,27 @@ public class TypeAssumptions { //if(ass.inheritsType(t))return t; if(ass.getIdentifier().equals(t.getName())){ //Generische Variable gefunden! + //Erkennen, ob sich inNode im gleichen Kontext wie die GTV aus den Assumptions befindet. + boolean sameContext = true; + //Der GTV-Kontext der einzusetzenden GTV GTVDeclarationContext gtvDeclNode = ass.getAssumedType().getDeclarationContext(); - if(gtvDeclNode == null || gtvDeclNode.isClass() - || !gtvDeclNode.equals(inNode.getGTVDeclarationContext())){ //hier muss nach der ParentClass von inNode gefragt werden, da die ParentClass von t nicht immer korrekt ist! (TODO: Überprüfen) + //Der GTV-Kontext von inNOde + GTVDeclarationContext gtvNode = inNode.getGTVDeclarationContext(); + //Überprüfungen (siehe Dokumentation): + if(gtvDeclNode.isClass()){ //GTV wurde in Klasse definiert + if(! gtvNode.getParentClass().equals(gtvDeclNode))sameContext = false; + }else{ //GTV wurde in Methode oder Feld definiert: + if(! gtvNode.equals(gtvDeclNode))sameContext = false; + } + + if(sameContext){ + TypeAssumptions.log.debug(t+" ist in Klasse: "+ass.getAssumedType().getParentClass(), Section.ASSUMPTIONS); + return new ConstraintType(ass.getAssumedType()); + }else{ TypeAssumptions.log.debug(t+" ist NICHT in Klasse: "+ass.getAssumedType().getParentClass(), Section.ASSUMPTIONS); //Ist die Generische Variable nicht aus dieser Klasse, so muss sie zu einem TPH umgewandelt werden: return new ConstraintType(ass.getAssumedType().getTypePlaceHolder(inNode)); } - TypeAssumptions.log.debug(t+" ist in Klasse: "+ass.getAssumedType().getParentClass(), Section.ASSUMPTIONS); - return new ConstraintType(ass.getAssumedType()); } } diff --git a/test/plugindevelopment/TypeInsertTests/GenericTypeVarTest.java b/test/plugindevelopment/TypeInsertTests/GenericTypeVarTest.java index 40aad284..0721692c 100644 --- a/test/plugindevelopment/TypeInsertTests/GenericTypeVarTest.java +++ b/test/plugindevelopment/TypeInsertTests/GenericTypeVarTest.java @@ -4,23 +4,20 @@ import java.util.Vector; import org.junit.Test; +import de.dhbwstuttgart.logger.Logger; +import de.dhbwstuttgart.logger.LoggerConfiguration; +import de.dhbwstuttgart.logger.Section; + public class GenericTypeVarTest { private static final String TEST_FILE = "GenericTypeVarTest.jav"; - private static final String TEST_FILE2 = "GenericTypeVarTest2.jav"; - /* @Test public void run(){ + Logger.setStandardConfiguration(new LoggerConfiguration().setOutput(Section.ASSUMPTIONS, System.out)); Vector mustContain = new Vector(); mustContain.add("String methode"); MultipleTypesInsertTester.test(this.TEST_FILE, mustContain); } - */ - @Test - public void run2(){ - Vector mustContain = new Vector(); - mustContain.add("String var2"); - MultipleTypesInsertTester.test(TEST_FILE2, mustContain); - } + } diff --git a/test/plugindevelopment/TypeInsertTests/IntTest.java b/test/plugindevelopment/TypeInsertTests/IntTest.java index 8020e667..95fd200f 100644 --- a/test/plugindevelopment/TypeInsertTests/IntTest.java +++ b/test/plugindevelopment/TypeInsertTests/IntTest.java @@ -11,7 +11,7 @@ public class IntTest { @Test public void run(){ Vector mustContain = new Vector(); - mustContain.add("int var"); + mustContain.add("Integer var"); MultipleTypesInsertTester.test(this.TEST_FILE, mustContain); } From 90e4c3bc966c936b22ee3e5bd205cb69dffc61a8 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Thu, 5 Mar 2015 13:56:42 +0100 Subject: [PATCH 3/3] Doku erweitert --- doc/documentation.md | 28 ++++++++----------- .../typeinference/ResultSet.java | 1 - .../GenericTypeInsertPoint.java | 18 ++++++------ .../typedeployment/TypeInsertSet.java | 8 ++++++ 4 files changed, 30 insertions(+), 25 deletions(-) diff --git a/doc/documentation.md b/doc/documentation.md index 0b88a6bc..74c5add5 100644 --- a/doc/documentation.md +++ b/doc/documentation.md @@ -29,6 +29,17 @@ * Stellt die Typeinsetzung für eine der generierten Lösungen dar * Setzt alle Typen und generischen Variablen ein, welche zu dieser Lösung gehören +### Einsetzen von Generischen Variablen +Die einzusetzenden Generischen Variablen werden erst beim Einsetzen eines Typs generiert. + +* Ablauf: + * 1. Alle TypePlaceholder im einzusetzenden Typ ermitteln. + * 2. Alle Constraints die mit diesen TPHs zusammenhängen ermitteln (Das kann möglicherweise wegfallen) + * 3. Alle TPHs, aus Schritt 1 und 2 zusammenfügen. + * 4. Kontrollieren, welche TPHs in dem InsertKontext noch nicht bekannt sind. + * 5. Alle Unbekannten TPHs herausfiltern (von den Pairs nur TA2) + * 6. Alle unbekannten TPHs + Pairs als GenericTypeInsertPoint deklarieren. + ## Ablauf Typinferenz: 1. Parsen @@ -53,19 +64,4 @@ 5. Einsetzen eines TypeInsertSet (optional) 1. Auf allen TypeInsertPoints die getUnresolvedTPHs-Methoden aufrufen 2. Alle Abhängigkeiten dieser - -# Typinferenz für Java 8 - -## Programmablauf - -1. SourceFile parst die Java-Dateien -2. SourceFile erstellt die Basic/Global Assumptions -3. Das Globale AssumptionSet wird anschließend jeder Klasse im Syntaxbaum mit dem TRProg aufruf übergeben -4. Jede Klasse verwaltet lokale Variablen in ihrem eigenen AssumptionSet. Das Globale ist Klassenübergreifend und jede AssumptionType darf darin nur einmalig gesetzt werden. -5. Haben alle Klassen ihrer Constraints erstellt können diese Unifiziert werden. - -## Overloading - -* Die Overloading Klasse generiert Constraints aus einem Methodenaufruf. - - + diff --git a/src/de/dhbwstuttgart/typeinference/ResultSet.java b/src/de/dhbwstuttgart/typeinference/ResultSet.java index a856d6d9..d13429be 100755 --- a/src/de/dhbwstuttgart/typeinference/ResultSet.java +++ b/src/de/dhbwstuttgart/typeinference/ResultSet.java @@ -105,7 +105,6 @@ public class ResultSet implements Iterable { } } } - return ret; } diff --git a/src/de/dhbwstuttgart/typeinference/typedeployment/GenericTypeInsertPoint.java b/src/de/dhbwstuttgart/typeinference/typedeployment/GenericTypeInsertPoint.java index bd16e90b..751fea6b 100644 --- a/src/de/dhbwstuttgart/typeinference/typedeployment/GenericTypeInsertPoint.java +++ b/src/de/dhbwstuttgart/typeinference/typedeployment/GenericTypeInsertPoint.java @@ -170,15 +170,17 @@ class GenericVarPatch { public void removeUnusedTPHs(Vector usedTPHs) { this.usedTPHs = usedTPHs; return; - /* - for(TypePlaceholder tph : usedTPHs){ - //Zuerst alle extends Typen kontrollieren und entfernen: - for(GenericVarExtendsDeclarationPatch p : this.genericVarExtendDeclarations){ - if(p.definesGenericVar(tph))return; - } - } - */ + } + + /* + for(TypePlaceholder tph : usedTPHs){ + //Zuerst alle extends Typen kontrollieren und entfernen: + for(GenericVarExtendsDeclarationPatch p : this.genericVarExtendDeclarations){ + if(p.definesGenericVar(tph))return; + } + } + */ } diff --git a/src/de/dhbwstuttgart/typeinference/typedeployment/TypeInsertSet.java b/src/de/dhbwstuttgart/typeinference/typedeployment/TypeInsertSet.java index c588aaea..6bce9a06 100644 --- a/src/de/dhbwstuttgart/typeinference/typedeployment/TypeInsertSet.java +++ b/src/de/dhbwstuttgart/typeinference/typedeployment/TypeInsertSet.java @@ -92,7 +92,15 @@ public class TypeInsertSet { allTPHs.add(tph); } } + for(Pair pair : pairs) + for(TypePlaceholder tph : pair.getTypePlaceholder()){ + if(!allTPHs.contains(tph)){ + allTPHs.add(tph); + } + } //TODO: Schritt 4 (Es wird nicht kontrolliert, ob der TPH in dem Kontext schon bekannt ist) + + /* // und Schritt 5: (Es werden nur die TPHs übernommen, welche noch nicht in den involvedTPHs vorkommen) for(Pair pair : pairs)for(Type t : pair.getTypes())for(TypePlaceholder tph : t.getInvolvedTypePlaceholder()){