JavaTX/JavaCompilerCore
2
0
Fork 3
Code Issues 94 Pull Requests Actions Packages Projects Releases Wiki Activity

Backup

Browse Source
This commit is contained in:
JanUlrich 2014-05-07 09:36:31 +02:00
parent 5c6a61f2ef
commit ef641065e2
3 changed files with 24 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
Readme.md
View File

@ -31,14 +31,15 @@
* unifiziert Constraints aller im SourceFile vorkommenden Klassen
4. Erstellen von TypeInsertSet
* j
* Durchlaufen des Syntaxbaumes
* Jeder Knoten erstellt TypeInsertSets anhand des ResultSets.
* Bei nichtauflösung eines TPH muss GenericVar eingesetzt werden:
* Im Syntaxbaum wird dazu die addGenericVar-Methode aufgerufen, welche einen TypeInsertPoint generiert.
* Mit dem Einsetzen einer Generischen Variablen müssen auch alle anderen Knoten im Syntaxbaum, deren
Typ ebenfalls dieser TypePlaceholder ist.
* Dies entsteht allerdings automatisch, da das gesamte ermittelte ResultSet als TIS eingesetzt wird.
* Dazu alle Abhängigkeite in Form von Pairs aus dem ResultSet ermitteln.
* GenericVarTypeInsertPoints generieren und in TypeInsertSet speichern.
* Beim Hinzufügen von GenericVarTypeInsertPoints wird kontrolliert, ob diese bereits (auch in Teilen) schon vorhanden sind.
5. Einsetzen eines TypeInsertSet (optional)
1. Auf allen TypeInsertPoints die getUnresolvedTPHs-Methoden aufrufen
2. Alle Abhängigkeiten dieser

19
src/mycompiler/SyntaxTreeNode.java
View File

@ -4,6 +4,7 @@ import java.util.Vector;
import typinferenz.ResultSet;
import typinferenz.TypeInsertPoint;
import typinferenz.TypeInsertSet;
import typinferenz.TypeInsertable;
import typinferenz.exceptions.DebugException;
import typinferenz.exceptions.TypeinferenceException;
@ -63,18 +64,26 @@ public abstract class SyntaxTreeNode {
return true;
}
public Vector<TypeInsertPoint> getTypeInsertPoints(ResultSet result) {
/**
* Methode zur Generierung der TypeInsertPoints
* @param insertSet - Generierte InsertPoints werden dem insertSet angefügt
* @param result - Das ResultSet auf dessen Basis die InsertPoints generiert werden
*/
public void addTypeInsertPoints(TypeInsertSet insertSet,ResultSet result) {
Vector<TypeInsertPoint> ret = new Vector<TypeInsertPoint>();
for(SyntaxTreeNode node : this.getChildren()){
ret.addAll(node.getTypeInsertPoints(result));
}
//Fall der Knoten ein TypeInsertable ist, kann direkt der TypeInsertPoint generiert werden.
if(this instanceof TypeInsertable){
TypeInsertable that = (TypeInsertable)this;
Type t = that.getType();
if(t instanceof TypePlaceholder)
ret.add(that.createTypeInsertPoint((TypePlaceholder) t, result));//ret.addAll(((TypePlaceholder)t).getTypeInsertPoints(result));
}
insertSet.add(ret);
//Nachdem die InsertPoints und GenericVarTypeInsertPoints angefügt wurden, kann im Knoten abgestiegen werden:
for(SyntaxTreeNode node : this.getChildren()){
node.addTypeInsertPoints(insertSet, result);
}
return ret;
}
}

44
src/typinferenz/TypeInsertSet.java
View File

@ -62,62 +62,26 @@ public class TypeInsertSet {
}
genericTIPs.add(toAdd);
}
/*
//... und dem TypeInsertSet anfügen:
for(GenericTypeInsertPoint p : genericTIPs){
for(GenericTypeInsertPoint p2 : genericTIPs){
//Doppelte Generische Variablen definitionen ausschließen:
for(TypeInsertPoint toAdd : p.merge(p2)){
this.add(toAdd);
//TODO: Alle Typen, welche die einzusetzenden Generischen Typen beinhalten, müssen ebenfalls eingesetzt werden.
}
}
//this.add(p);
}
//Anschließend sortieren:
*/
//Anschließend sortieren (nach dem Offset der InsertPoints):
Collections.sort(points);
for(TypeInsertPoint p : points){
/*
//TODO: Verbessern. Momentan noch komischer Hack:
//Kontrollieren ob beim Einsetzen Generische Typvariablen entstehen:
Iterator<Pair> it = p.getUnresolvedPairs().iterator();
String genericTypeParameters = "<";
while(it.hasNext()){
genericTypeParameters += new GenericTypeVar(it.next(), 0).printJavaCode(p.getResultSet());
if(it.hasNext())genericTypeParameters += ", ";
}
genericTypeParameters += ">";
//HACK: Reftype mit dem Typ der einzusetzenden Generischen Variablen:
TypeInsertPoint tip = new TypeInsertPoint(p.getGenericTypeVarInsertNode(), new RefType(genericTypeParameters,0), p.getResultSet());
//ret = tip.insertType(fileContent, additionalOffset);
//additionalOffset += tip.getInsertLength();
*/
//Zuerst den Typ einsetzen
JavaCodeResult insertCode = p.insertType(ret, additionalOffset);
ret = insertCode.toString();
/*
//Das additional Offset noch nicht korrigieren, da die generischen Parameter noch vor den Typ müssen.
//Jetzt sind die übriggebliebenen TPHs bekannt und die benötigten Generischen Variablen können berechnet werden.
Vector<Pair> unresolvedPairs = p.getResultSet().getConstraintsFor(insertCode.getUnresolvedTPH());
if(unresolvedPairs.size()>0){ //Nur falls es wirklich was zum Einsetzen gibt:
Iterator<Pair> it = unresolvedPairs.iterator();
String genericTypeParameters = "<";
while(it.hasNext()){
genericTypeParameters += new GenericTypeVar(it.next(), 0).printJavaCode(p.getResultSet());
if(it.hasNext())genericTypeParameters += ", ";
}
genericTypeParameters += ">";
//Der Generische Variablen String zum Einsetzen ist nun vorhanden
TypeInsertPoint tip = new TypeInsertPoint(p.getGenericTypeVarInsertNode(), new RefType(genericTypeParameters,0), p.getResultSet());
ret = tip.insertType(insertCode.toString(), additionalOffset).toString();
//Jetzt das gesamte Offset korrigieren:
additionalOffset += tip.getInsertLength();
}
*/
//Dann Additional Offset korrigieren:
additionalOffset += p.getInsertLength();
}
return ret;