From eec8e4d1a8b6a16b6844cf0613ce4892e740480f Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Fri, 20 Jun 2014 11:18:45 +0200 Subject: [PATCH] =?UTF-8?q?Generics=20werden=20eingesetzt.=20Unvollst?= =?UTF-8?q?=C3=A4ndiger=20Zustand?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/mycompiler/SyntaxTreeNode.java | 6 ++++-- src/typinferenz/GenericTypeInsertPoint.java | 17 ++++++++++++----- .../typedeployment/TypeInsertSet.java | 18 +++++++++--------- test/plugindevelopment/TRMEqualTest.java | 2 +- 4 files changed, 26 insertions(+), 17 deletions(-) diff --git a/src/mycompiler/SyntaxTreeNode.java b/src/mycompiler/SyntaxTreeNode.java index 378fa814..1b5cab30 100644 --- a/src/mycompiler/SyntaxTreeNode.java +++ b/src/mycompiler/SyntaxTreeNode.java @@ -86,15 +86,17 @@ public abstract class SyntaxTreeNode{ tip = that.createTypeInsertPoint((TypePlaceholder) t, result); insertSet.add(tip);//ret.addAll(((TypePlaceholder)t).getTypeInsertPoints(result)); } - /* + //Für den Fall, dass dieser Knoten Generische Variablen halten kann. if(that instanceof Generic && that.getOffset()>=0){ //Alle unresolvedTPHs ermitteln und GenericTypeVarInsertPoints bilden: Vector uTPHs = insertSet.getUnresolvedTPHs(); + /* for(TypePlaceholder tph : uTPHs){//GenericInsertPoints für diese TPHs bilden: GenericTypeInsertPoint genericTIP = new GenericTypeInsertPoint(that,tph,result); insertSet.add(genericTIP); } + */ if(uTPHs.size()>0){//Nur wenn es auch unresolvedTPHs gibt: Vector gPairs = result.getConstraintsFor(uTPHs); if(gPairs.size()>0){ @@ -103,7 +105,7 @@ public abstract class SyntaxTreeNode{ } } } - */ + } diff --git a/src/typinferenz/GenericTypeInsertPoint.java b/src/typinferenz/GenericTypeInsertPoint.java index 8aed5e8e..0ca14fd7 100644 --- a/src/typinferenz/GenericTypeInsertPoint.java +++ b/src/typinferenz/GenericTypeInsertPoint.java @@ -127,14 +127,21 @@ public class GenericTypeInsertPoint extends TypeInsertPoint { @Override public JavaCodeResult insertType(String fileContent, int additionalOffset) { //TODO: Es kann sein, dass eine Methode bereits Generische Variablen hat, diese müssen dann an diese Liste angefügt werden. - return super.insertType(fileContent, additionalOffset); + + return super.insertType(fileContent, additionalOffset); } public boolean associatedWith(TypeInsertPoint tip, ResultSet resultSet) { - if(!(tip.point instanceof TypePlaceholder))return false; - Vector tphs = new Vector<>(); - tphs.add((TypePlaceholder)tip.point); - resultSet.getConstraintsFor(tphs); + if((tip.type instanceof TypePlaceholder)){ + Vector tphs = new Vector<>(); + tphs.add((TypePlaceholder)tip.type); + for(Pair p : resultSet.getConstraintsFor(tphs)){ + if(p.TA1.equals(this.type))return true; + if(p.TA2.equals(this.type))return true; + if(this.genericPairs.contains(p))return true; + } + } + return false; } } diff --git a/src/typinferenz/typedeployment/TypeInsertSet.java b/src/typinferenz/typedeployment/TypeInsertSet.java index de413292..91e30e65 100644 --- a/src/typinferenz/typedeployment/TypeInsertSet.java +++ b/src/typinferenz/typedeployment/TypeInsertSet.java @@ -16,6 +16,14 @@ import mycompiler.mytype.Pair; import mycompiler.mytype.RefType; import mycompiler.mytype.TypePlaceholder; +/* + * Der Plan: + * SyntaxTreeNode generiert die TypeInsertPoints. + * Beim Einsetzen eines TIP werden die ebenfalls von den SyntaxTreeNodes berechneten GenericInsertPoints durchsucht nach den Punkten + * die mit dem einzusetzenden TIP zusammenhängen. + * Das funktioniert mithilfe des ResultSets. Denn es müssen alle Constraints mit einbezogen werden, da der Unify + * Algorithmus als Ergebnis nur die zu einem RefType aufgelösten TPHs ausgibt. + */ /** * Bündelt ein Set von TypeInsertPoints, die alle zu einem TypePlaceholder gehören. * Diese müssen gemeinsam eingesetzt werden. @@ -86,15 +94,7 @@ public class TypeInsertSet { tpj.add(tip); } - /* - * Der Plan: - * SyntaxTreeNode generiert die TypeInsertPoints. - * Beim Einsetzen eines TIP werden die ebenfalls von den SyntaxTreeNodes berechneten GenericInsertPoints durchsucht nach den Punkten - * die mit dem einzusetzenden TIP zusammenhängen. - * Das funktioniert mithilfe des ResultSets. Denn es müssen alle Constraints mit einbezogen werden, da der Unify - * Algorithmus als Ergebnis nur die zu einem RefType aufgelösten TPHs ausgibt. - * - */ + /** * Fügt alle Typen dieses TypeInsertSets in den übergebenen Quellcode ein diff --git a/test/plugindevelopment/TRMEqualTest.java b/test/plugindevelopment/TRMEqualTest.java index 0dd52a0f..c10221f2 100644 --- a/test/plugindevelopment/TRMEqualTest.java +++ b/test/plugindevelopment/TRMEqualTest.java @@ -48,8 +48,8 @@ public class TRMEqualTest { addTestNode("Typ1"); assertTrue("Nach dem Anfügen des selben Typs wie zuvor muss das Set immer noch 2 Element enthalten. Und nicht "+replaceSet.size(),replaceSet.size()==2); } + private void addTestNode(String type){ - Vector resultContent = new Vector(); Pair pair = new Pair(tph,new RefType(type,0)); pair.SetOperator(PairOperator.Equal);