From c1cbb78fe5278be75e0fa088d0abe9721154aad0 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 7 Dec 2016 14:32:48 +0100 Subject: [PATCH] =?UTF-8?q?Aufr=C3=A4umen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../dhbwstuttgart/parser/JavaClassName.java | 3 +- .../parser/JavaClassRegistry.java | 18 ++ src/de/dhbwstuttgart/syntaxtree/Class.java | 166 +---------- .../syntaxtree/ConstructorCall.java | 47 --- .../syntaxtree/ExceptionList.java | 31 +- src/de/dhbwstuttgart/syntaxtree/Generic.java | 2 - .../syntaxtree/NullSyntaxTreeNode.java | 26 -- .../syntaxtree/ParameterList.java | 29 +- .../dhbwstuttgart/syntaxtree/SourceFile.java | 282 +----------------- .../syntaxtree/SyntaxTreeNode.java | 16 +- .../syntaxtree/factory/ASTFactory.java | 88 +++--- .../syntaxtree/factory/UnifyTypeFactory.java | 8 +- .../syntaxtree/statement/SuperCall.java | 11 +- .../syntaxtree/statement/ThisCall.java | 44 +-- .../type/BoundedGenericTypeVar.java | 43 +-- .../syntaxtree/type/GenericTypeVar.java | 32 +- test/unify/UnifyTypeFactoryTest.java | 2 - 17 files changed, 111 insertions(+), 737 deletions(-) create mode 100644 src/de/dhbwstuttgart/parser/JavaClassRegistry.java delete mode 100644 src/de/dhbwstuttgart/syntaxtree/ConstructorCall.java delete mode 100644 src/de/dhbwstuttgart/syntaxtree/NullSyntaxTreeNode.java diff --git a/src/de/dhbwstuttgart/parser/JavaClassName.java b/src/de/dhbwstuttgart/parser/JavaClassName.java index a16adea5..4e6ba81b 100644 --- a/src/de/dhbwstuttgart/parser/JavaClassName.java +++ b/src/de/dhbwstuttgart/parser/JavaClassName.java @@ -18,11 +18,10 @@ public class JavaClassName { private PackageName packageName; /** - * * TODO: JavaClassName sollten aus den Assumptions generiert werden. * Diese wissen, welche Typen und Typnamen existieren und können direkt auf Korrektheit prüfen. */ - private JavaClassName(String name){ + JavaClassName(String name){ if(name == null)throw new NullPointerException(); String[] names = name.split("[.]"); diff --git a/src/de/dhbwstuttgart/parser/JavaClassRegistry.java b/src/de/dhbwstuttgart/parser/JavaClassRegistry.java new file mode 100644 index 00000000..4282f662 --- /dev/null +++ b/src/de/dhbwstuttgart/parser/JavaClassRegistry.java @@ -0,0 +1,18 @@ +package de.dhbwstuttgart.parser; + +import java.util.ArrayList; +import java.util.List; + +/** + * Speichert die Klassen im aktuellen Projektscope + */ +public class JavaClassRegistry { + public List existingClasses = new ArrayList<>(); + + public JavaClassName getName(String className) { + for(JavaClassName name : existingClasses){ + if(name.toString().equals(className))return name; + } + throw new TypeNotPresentException(className, new Throwable()); + } +} diff --git a/src/de/dhbwstuttgart/syntaxtree/Class.java b/src/de/dhbwstuttgart/syntaxtree/Class.java index a31cb42a..1ac2b6ef 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Class.java +++ b/src/de/dhbwstuttgart/syntaxtree/Class.java @@ -1,16 +1,4 @@ -// ino.module.Class.8553.package package de.dhbwstuttgart.syntaxtree; -// ino.end -// ino.module.Class.8553.import -import java.util.ArrayList; -import java.util.Collection; -import java.util.Enumeration; -import java.util.Hashtable; -import java.util.Iterator; -import java.util.LinkedList; -import java.util.List; - -import javax.lang.model.element.Modifier; import org.apache.bcel.generic.ClassGen; import org.apache.bcel.generic.ConstantPoolGen; @@ -35,25 +23,13 @@ import de.dhbwstuttgart.syntaxtree.statement.Statement; import de.dhbwstuttgart.syntaxtree.statement.SuperCall; import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; import de.dhbwstuttgart.syntaxtree.type.RefType; -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.*; import de.dhbwstuttgart.typeinference.assumptions.ClassAssumption; import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions; -import de.dhbwstuttgart.typeinference.exceptions.DebugException; -import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException; -import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; -import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertPoint; -import de.dhbwstuttgart.typeinference.unify.TypeUnify; - -import org.apache.bcel.generic.*; -import org.apache.bcel.classfile.*; -import org.apache.bcel.*; - -import java.io.*; +import java.util.ArrayList; +import java.util.List; /** * Stellt jede Art von Klasse dar. Auch abstrakte Klassen und Interfaces @@ -61,7 +37,7 @@ import java.io.*; public class Class extends GTVDeclarationContext implements IItemWithOffset, Generic, GenericTypeInsertable { /** - * Log4j - Loggerinstanzen + * Loggerinstanzen */ protected static Logger inferencelog = Logger.getLogger("inference"); protected static Logger codegenlog = Logger.getLogger("codegen"); @@ -70,18 +46,17 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen protected Modifiers modifiers; protected JavaClassName name; - private Block class_block; - - private Menge fielddecl = new Menge(); + private List fielddecl = new ArrayList<>(); private GenericDeclarationList genericClassParameters; private int offset; private RefType superClass; + protected boolean isInterface; + private List implementedInterfaces; ///////////////////////////////////////////////////////////////////////// // TypeReconstructionAlgorithmus ///////////////////////////////////////////////////////////////////////// - // ino.method.TRProg.23110.defdescription type=javadoc /** * Ausgangspunkt f�r den Typrekonstruktionsalgorithmus. Hier werden zun�chst * die Mengen von Typannahmen V_fields_methods und V_i erstellt, die als Eingabe @@ -207,46 +182,7 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen return new JavaCodeResult(stringReturn); } - - /** - * Errechnet die Generischen Parameter der Klasse für diese Klasse. - * Die berechneten Variablen werden anschließend in die this.genericTypeVars eingesetzt. Dabei werden alte genericTypeVars überschrieben. - * @param tphs : Alle übriggebliebenen TypePLaceholder - - private void createGenericTypeVars(Menge tphs){ - this.genericClassParameters = new GenericDeclarationList(new Menge()); - for(TypePlaceholder tph : tphs){ - GenericTypeVar toAdd = new GenericTypeVar(tph,this.getOffset()); - if(!this.genericClassParameters.contains(toAdd))this.genericClassParameters.add(toAdd); - } - } - */ - /** - * Errechnet die Generischen Parameter der Klasse für diese Klasse. - * Die berechneten Variablen werden anschließend in die this.genericTypeVars eingesetzt. Dabei werden alte genericTypeVars überschrieben. - * @param reconstructionResult - - public void createGenericTypeVars(TypeinferenceResultSet reconstructionResult){ - this.genericClassParameters = new Menge(); - for(Pair pair : reconstructionResult.getUnifiedConstraints()){ - if(pair.TA2 instanceof TypePlaceholder && pair.TA1 instanceof TypePlaceholder){// if(pair.OperatorSmallerExtends() || pair.OperatorSmaller()){ - Type ta1=reconstructionResult.getUnifiedConstraints().getTypeEqualTo(pair.TA1); - Type ta2=reconstructionResult.getUnifiedConstraints().getTypeEqualTo(pair.TA2); - this.genericClassParameters.add(new GenericTypeVar(new Pair(ta1,ta2),this.getOffset())); - } - } - - for(Pair pair : reconstructionResult.getConstraints()){ - if( ! reconstructionResult.getUnifiedConstraints().contains(pair.TA1)){ - this.genericClassParameters.add(new GenericTypeVar(pair.TA1,this.getOffset())); - } - if( ! reconstructionResult.getUnifiedConstraints().contains(pair.TA2)){ - this.genericClassParameters.add(new GenericTypeVar(pair.TA2, this.getOffset())); - } - } - } - */ - + public int getOffset(){ return this.offset; } @@ -257,12 +193,6 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen * @return */ public RefType getType() { - /* - Menge parameter = new Menge(); - for(Type param : this.get_ParaList()){ - parameter.add(((GenericTypeVar)param).getTypePlaceHolder());//(TypePlaceholder.fresh()); //Hier ist kein ReplacementListener notwendig. Der Typ soll nie eingesetzt werden. Der TPH wird nur gebraucht, damit das Unifizieren funktioniert. - } - */ return new RefType(this.getName().toString(), this.get_ParaList(),this, 0); } @@ -283,24 +213,7 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen } return ret; } - - @Override - public SyntaxTreeNode getParent() { - return this; - } - @Override - public Menge getChildren() { - Menge ret = new Menge(); - //for(Field f : this.getFields()){ - // ret.add(f); - //} - ret.addAll(this.getFields()); - ret.addAll(this.get_ParaList()); - ret.addAll(this.getGenericParameter().getGTVList()); - return ret; - } - @Override public boolean equals(Object obj){ if(!(obj instanceof Class))return false; @@ -355,71 +268,8 @@ public class Class extends GTVDeclarationContext implements IItemWithOffset, Gen public boolean isClass() { return true; } - - protected boolean isInterface; + public boolean isInterface(){ return isInterface; } - /* - private Collection getGenericClasses() { - Collection results = new Menge<>(); - - for(Field field : this.fielddecl){ - Type type = field.getType(); - //Der Type des Feldes - if(type instanceof RefType){ - RefType refType = (RefType) type; - - if(!refType.getCombinedType(null).equals(refType.get_Name().replace(".", "%"))){ - results.addAll(generateGenericClass(refType.getCombinedType(null), new Class("java/util/Vector",-1))); - } - } - - if(field instanceof Method){ - Method method = (Method) field; - ParameterList parameterList = method.getParameterList(); - - //Die Typen der Methodenparameter - for(FormalParameter parameter: parameterList){ - Type parameterType = parameter.getType(); - - if(parameterType instanceof RefType){ - RefType refType = (RefType) parameterType; - - if(!refType.getCombinedType(null).equals(refType.get_Name().replace(".", "%"))){ - results.addAll(generateGenericClass(refType.getCombinedType(null), new Class("java/util/Vector",-1))); - } - } - } - } - } - - return results; - } - */ - - /* - private Menge generateGenericClass(String name, Class superClass){ - //TODO: bytecode -- Generics hinzuf�gen - //Type superClassType = superClass.getType(); - - //TODO: bytecode - //ClassGenerator genericClassGenerator = new ClassGenerator(name, superClassType, name + ".java", Constants.ACC_PUBLIC , new String[] { }, new TypeinferenceResultSet(null, null, null)); - - //TODO: bytecode -- Namen der neuen Klasse - Class generatedClass = new Class(name, 0); - - //TODO: bytecode -- alle Konstruktoren generieren - Block konstruktorBlock = new Block(); - konstruktorBlock.setType(new de.dhbwstuttgart.syntaxtree.type.Void(konstruktorBlock, 0)); - konstruktorBlock.statements.add(new SuperCall(konstruktorBlock)); - Constructor standardKonstruktor = new Constructor(Method.createEmptyMethod(konstruktorBlock, name, superClass), superClass); - standardKonstruktor.parserPostProcessing(generatedClass); - - generatedClass.addField(standardKonstruktor); - - return generatedClass.genByteCode(new TypeinferenceResultSet(generatedClass, new Menge<>(), new ResultSet())); - } - */ } -// ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/ConstructorCall.java b/src/de/dhbwstuttgart/syntaxtree/ConstructorCall.java deleted file mode 100644 index 12987c8f..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/ConstructorCall.java +++ /dev/null @@ -1,47 +0,0 @@ -package de.dhbwstuttgart.syntaxtree; - -import de.dhbwstuttgart.syntaxtree.statement.ArgumentList; -import de.dhbwstuttgart.syntaxtree.statement.MethodCall; -import de.dhbwstuttgart.syntaxtree.statement.Receiver; -import de.dhbwstuttgart.typeinference.ConstraintsSet; -import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption; -import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions; -import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; - -/** - * Diese Klasse stellt den this()-Aufruf dar. - * @author janulrich - * - */ -public class ConstructorCall extends MethodCall -{ - public ConstructorCall(Receiver receiver, String methodName, ArgumentList argumentList, int offset){ - super(receiver, methodName, argumentList,offset); - //this.set_Receiver(receiver); - //this.set_Name(methodName); - //this.set_ArgumentList(argumentList); - } - - /* - @Override - public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) { - throw new TypeinferenceException("this(...)-Aufruf kann nicht als Ausdruck verwendet werden",this); - } - */ - - @Override - public ConstraintsSet overloading(TypeAssumptions assumptions){ - ConstraintsSet ret = new ConstraintsSet(); - ConstructorAssumption cAss = assumptions.getConstructorAssumption(this.get_Name(), this.getArgumentList().size()); - if(cAss == null)throw new TypeinferenceException("Kein Konstruktor mit passender Parameteranzahl vorhanden",this); - - ret.add(constraintsFromMethodAssumption(cAss, assumptions)); - return ret; - } - - @Override - public void parserPostProcessing(SyntaxTreeNode parent) { - super.parserPostProcessing(parent); - } - -} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/syntaxtree/ExceptionList.java b/src/de/dhbwstuttgart/syntaxtree/ExceptionList.java index 5ab263be..1b6694f5 100755 --- a/src/de/dhbwstuttgart/syntaxtree/ExceptionList.java +++ b/src/de/dhbwstuttgart/syntaxtree/ExceptionList.java @@ -1,35 +1,14 @@ -// ino.module.ExceptionList.8559.package package de.dhbwstuttgart.syntaxtree; -// ino.end -// ino.module.ExceptionList.8559.import -import de.dhbwstuttgart.typeinference.Menge; import de.dhbwstuttgart.syntaxtree.type.RefType; +import java.util.List; - - -// ino.class.ExceptionList.23358.declaration public class ExceptionList -// ino.end -// ino.class.ExceptionList.23358.body { - // ino.attribute.reftype.23361.declaration - private Menge reftype = new Menge(); - // ino.end - - - - // ino.method.set_addElem.23364.definition - public void set_addElem(RefType rety) - // ino.end - // ino.method.set_addElem.23364.body - { - reftype.addElement(rety); + private List exceptions; + + public ExceptionList(List exceptions){ + this.exceptions = exceptions; } - // ino.end - - - } -// ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/Generic.java b/src/de/dhbwstuttgart/syntaxtree/Generic.java index 90d63648..743cdbc0 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Generic.java +++ b/src/de/dhbwstuttgart/syntaxtree/Generic.java @@ -11,7 +11,5 @@ import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; * */ public interface Generic { - public void setGenericParameter(GenericDeclarationList params); public Iterable getGenericParameter(); - } \ No newline at end of file diff --git a/src/de/dhbwstuttgart/syntaxtree/NullSyntaxTreeNode.java b/src/de/dhbwstuttgart/syntaxtree/NullSyntaxTreeNode.java deleted file mode 100644 index 5952cd17..00000000 --- a/src/de/dhbwstuttgart/syntaxtree/NullSyntaxTreeNode.java +++ /dev/null @@ -1,26 +0,0 @@ -package de.dhbwstuttgart.syntaxtree; - -import de.dhbwstuttgart.typeinference.Menge; - -/** - * Dieser SyntaxTreeNode kann anstelle von null in einem Syntaxbaum eingesetzt werden. - * Vorsicht: Als Offset wird dann immer 0 zurück gegeben. - */ -public class NullSyntaxTreeNode extends SyntaxTreeNode { - - @Override - public int getOffset() { - return 0; - } - - @Override - public int getVariableLength() { - return 0; - } - - @Override - public Menge getChildren() { - return new Menge<>(); - } - -} diff --git a/src/de/dhbwstuttgart/syntaxtree/ParameterList.java b/src/de/dhbwstuttgart/syntaxtree/ParameterList.java index 02874a1b..4ad42fc5 100755 --- a/src/de/dhbwstuttgart/syntaxtree/ParameterList.java +++ b/src/de/dhbwstuttgart/syntaxtree/ParameterList.java @@ -1,7 +1,5 @@ -// ino.module.ParameterList.8565.package package de.dhbwstuttgart.syntaxtree; -// ino.end -// ino.module.ParameterList.8565.import + import de.dhbwstuttgart.typeinference.Menge; @@ -18,22 +16,17 @@ import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; public class ParameterList extends SyntaxTreeNode implements Iterable { public List formalparameter = new Menge(); - // ino.end public ParameterList(List params){ this.formalparameter = params; } - - // ino.method.getParameterAt.23632.definition + public FormalParameter getParameterAt(int i) - // ino.end - // ino.method.getParameterAt.23632.body { if (i >= formalparameter.size() ) return null; return formalparameter.get(i); } - // ino.end public List sc_get_Formalparalist() @@ -50,18 +43,6 @@ public class ParameterList extends SyntaxTreeNode implements Iterable getChildren() { @@ -142,4 +118,3 @@ public class ParameterList extends SyntaxTreeNode implements Iterabletrue gesetzt ist, wird immer als Superklasse Object - * mit rein geladen. Dies hat natürlich zur Folge, dass man in der GUI jeden Typ - * auswählen muss, weil ALLES in Java von Object erbt. Sobald die GUI das über eine - * Checkbox o.ä. ausblendbar macht kann es aktiviert werden. Ebenso beeinflusst es - * die superclass von allen Class-Objekten. (Wenn true ist jede Class automatisch - * wenn nicht anders eingegeben Subclass von Object (Wie es sein muss)) - */ - // ino.end - // ino.attribute.READ_OBJECT_SUPERCLASSES_FROM_JRE.21361.declaration - public static final boolean READ_OBJECT_SUPERCLASSES_FROM_JRE = false; - // ino.end - - // ino.attribute.READ_BASE_TYPE_SUPERCLASSES_FROM_JRE.21364.decldescription type=javadoc - /** - * Wenn dieses Flag auf false ist, werden für alle Basisklassen (definiert - * durch die Hashtable baseTypeTranslationTable) KEINE Superklassen geladen. D.h. - * Integer hat bspw. nicht die Superklasse Number sondern OBJECT. - * Dies verursacht bei den Int-Operationen ein Problem - * (+,-,*,/,<,>,...) - */ - // ino.end - // ino.attribute.READ_BASE_TYPE_SUPERCLASSES_FROM_JRE.21364.declaration - private static final boolean READ_BASE_TYPE_SUPERCLASSES_FROM_JRE = false; - // ino.end - - /** - * @autor PL - * Wenn dieses Flag auf false ist, werden für alle importierten Klassen - * KEINE Superklassen geladen. - */ - private static final boolean READ_IMPORTED_SUPERCLASSES_FROM_JRE = false; protected static Logger codegenlog = Logger.getLogger("codegen"); protected static Logger inferencelog = Logger.getLogger("inference"); private String pkgName; - public Menge KlassenVektor = new Menge(); - + public List KlassenVektor = new Menge(); + private List imports; + /** * Die SourceFile repräsntiert eine zu einem Syntaxbaum eingelesene Java-Datei. * SourceFile stellt dabei den Wurzelknoten des Syntaxbaumes dar. */ - public SourceFile(){ - // HOTI 4.5.06 - // Base-Type-Translations anlegen (siehe kommentar BaseTypeTranslationTable) - baseTypeTranslationTable=new Hashtable(); - baseTypeTranslationTable.put("int","java.lang.Integer"); - baseTypeTranslationTable.put("char","java.lang.Character"); - baseTypeTranslationTable.put("boolean","java.lang.Boolean"); - baseTypeTranslationTable.put("double","java.lang.Double"); - baseTypeTranslationTable.put("long","java.lang.Long"); - baseTypeTranslationTable.put("float","java.lang.Float"); - //baseTypeTranslationTable.put("this.is.a.temporary.entry","de.dhbwstuttgart.typeinference.Menge"); auskommentiert PL 07-08-11 - - //this.imports=new ImportDeclarations(); - - this.imports.add(new JavaClassName("java.lang.Integer")); - this.imports.add(new JavaClassName("java.lang.String")); - this.imports.add(new JavaClassName("java.lang.Character")); - this.imports.add(new JavaClassName("java.lang.Boolean")); - this.imports.add(new JavaClassName("java.lang.Double")); - this.imports.add(new JavaClassName("java.lang.Float")); - this.imports.add(new JavaClassName("java.lang.Long")); - //this.imports.add(UsedId.createFromQualifiedName("java.lang.Byte")); - - // HOTI 4.5.06 Wenn die Klassen immer als "Daddy" Object haben, - // muss das der JCC auch kennen - if(READ_OBJECT_SUPERCLASSES_FROM_JRE){ - this.imports.add(new JavaClassName("java.lang.Object")); - } - } - - public SourceFile(Menge classDefinitions) { - this.KlassenVektor = classDefinitions; + public SourceFile(List classDefinitions) { + this.KlassenVektor = classDefinitions; } - /** - * HOTI 4.5.06 - * Beinhaltet alle Imports des aktuell geparsten Files - * in Form einer UsedId - */ - private List imports; - - /** - * Table zum Übersetzen der nicht implementierten Base-Types: - * Überall im Compiler wird statt bspw. int Integer verwendet - * d.h. 1+2 liefert ein Integer - * Deshalb benötigen wir hier eine Tabelle, mit der man die von - * der JRE gelieferten Base-Typen (int,char, etc) und die Objekt- - * Typen umwandeln können - */ - private Hashtable baseTypeTranslationTable; - /** * PL 2014-10-25 * schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind @@ -283,7 +186,6 @@ public class SourceFile ///////////////////////////////////////////////////////////////////////// // TypeReconstructionAlgorithmus ///////////////////////////////////////////////////////////////////////// - // ino.method.typeReconstruction.21406.defdescription type=javadoc /** * Tyrekonstruktionsalgorithmus: ruft f�r jede Klasse den Algorithmus TRProg auf. * Dessen Ergebnismenge A, die Menge aller Typannahmen, f�r eine Klasse dient als @@ -293,11 +195,7 @@ public class SourceFile * @return Liste aller m�glichen Typkombinationen * @throws CTypeReconstructionException Wenn was schief l�uft */ - // ino.end - // ino.method.typeReconstruction.21406.definition public Menge typeReconstruction(TypeAssumptions globalAssumptions) - // ino.end -// ino.method.typeReconstruction.21406.body { Menge ret = new Menge(); @@ -431,173 +329,7 @@ public class SourceFile // ino.end // ino.method.makeBasicAssumptionsFromJRE.21409.body { - //return null; - ///* - List doneImports=new Menge<>(); - - //TypeinferenceResultSet basicAssumptions = new TypeinferenceResultSet(null); - TypeAssumptions basicAssumptions = new TypeAssumptions(); - - Modifiers mod = new Modifiers(); - mod.addModifier(new Public()); - - //Für Object: - imports.add(new JavaClassName("java.lang.Object")); - - // Für jede einzelne Klasse - while (imports.size()>0) { - JavaClassName importDecl = imports.get(0); - - // Properties laden - java.lang.Class x; - try { - x = java.lang.Class.forName(importDecl.toString()); - } catch (ClassNotFoundException e) { - throw new TypeinferenceException("Fehlerhafte Import-Declaration: "+e.getMessage(),this); - } - - java.lang.reflect.Field[] fields=x.getDeclaredFields(); - java.lang.reflect.Method[] methods=x.getDeclaredMethods(); - java.lang.reflect.Constructor[] constructors=x.getConstructors(); - java.lang.reflect.TypeVariable[] tvs=x.getTypeParameters(); - //String className=x.getSimpleName(); - String className=x.getName(); - - //Ermittle die Superklasse: - //Class sClass = new Class("Object",0); - if(withSubtypes)sClass = getSuperClassOfJREClass(x, basicAssumptions); - - // Namen von Generische Typen erzeugen - Hashtable jreSpiderRegistry=new Hashtable(); - Menge typeGenPara = new Menge(); - for(int j=0;j0){ - //auskommentiert von Andreas Stadelmeier: - //basicAssumptions.addGenericTypeVars(className, typeGenPara); - //parentClass.set_ParaList((Menge)typeGenPara);//myCl.set_ParaList((Menge)typeGenPara); - } - - - if(x.getSuperclass()!=null){ - //boolean isObject=x.getSuperclass().getSimpleName().equalsIgnoreCase("Object"); - boolean isObject=x.getSuperclass().getName().equalsIgnoreCase("java.lang.Object"); - boolean isBaseType=isBaseType(className); - - //if((!isObject || READ_OBJECT_SUPERCLASSES_FROM_JRE) && (!isBaseType|| READ_BASE_TYPE_SUPERCLASSES_FROM_JRE)) - if (((!isObject || READ_OBJECT_SUPERCLASSES_FROM_JRE) && READ_IMPORTED_SUPERCLASSES_FROM_JRE) //eingefuegt 07-08-11 - || (isBaseType && READ_BASE_TYPE_SUPERCLASSES_FROM_JRE)) - { - String superclassFullyQualifiedName = x.getSuperclass().getCanonicalName(); - //Andere Methode, da Menge.contains bei Strings nicht richtig vergleicht. - if(!containsString(imports,superclassFullyQualifiedName) && !containsString(doneImports,superclassFullyQualifiedName)){ - imports.addElement(UsedId.createFromQualifiedName(superclassFullyQualifiedName,-1)); - } - //UsedId ui = new UsedId(); - //ui.set_Name(x.getSuperclass().getSimpleName()); - String ui= x.getSuperclass().getName(); - java.lang.Class superClass=x.getSuperclass(); - java.lang.reflect.TypeVariable[] superclassTVS=superClass.getTypeParameters(); - Menge supertypeGenPara = new Menge(); - for(int tvi=0;tvi(),null); - Method method = de.dhbwstuttgart.syntaxtree.Method.createEmptyMethod(methodName, parentClass); - method.setType(returnType); - ParameterList parameterList = new ParameterList(); - - for(int k=0;k())); - FormalParameter parameter = new FormalParameter(new DeclId(type.get_Name())); - parameter.setType(type); - parameterList.formalparameter.add(parameter); - } - method.setParameterList(parameterList); - //basicAssumptions.addMethodIntersectionType(new CIntersectionType(method)); - - parentClass.addField(method); - - //} - } - } - - for(int j=0;j getChildren(); - - /* - public Class getParentClass(){ - SyntaxTreeNode parent = this.getParent(); - if(parent instanceof Class)return (Class)parent; - if(parent == null) - throw new DebugException("Das Wurzelelement eines Syntaxbaumes muss Class sein"); - return parent.getParentClass(); - } - */ + /** * Eine Beschreibung/Name des SyntaxTree-Nodes * Hat nichts mit der Description im Bytecode zu tun, @@ -122,11 +113,6 @@ public abstract class SyntaxTreeNode implements IItemWithOffset{ } - public boolean seesType(Type tA2) { - //TODO: Implementieren. Hier sollte ein Lookup in die Assumptions dieses Knotens erfolgen - return false; - } - public SyntaxTreeNode getMatchingParentNode(SyntaxTreeNode inNode) { SyntaxTreeNode node = inNode; while(node!=null){ diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index 3975fd17..0e900c53 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java @@ -1,33 +1,14 @@ package de.dhbwstuttgart.syntaxtree.factory; -import java.lang.reflect.AnnotatedType; import java.lang.reflect.Parameter; -import java.lang.reflect.ParameterizedType; import java.lang.reflect.TypeVariable; import java.util.ArrayList; import java.util.List; -import javax.lang.model.element.Modifier; - -======= -import java.util.ArrayList; -import java.util.List; - ->>>>>>> refactoring -import de.dhbwstuttgart.bytecode.ClassGenerator; import de.dhbwstuttgart.parser.JavaClassName; +import de.dhbwstuttgart.parser.JavaClassRegistry; +import de.dhbwstuttgart.syntaxtree.*; import de.dhbwstuttgart.syntaxtree.Class; -import de.dhbwstuttgart.syntaxtree.Constructor; -import de.dhbwstuttgart.syntaxtree.Field; -<<<<<<< HEAD -import de.dhbwstuttgart.syntaxtree.FormalParameter; -======= ->>>>>>> refactoring -import de.dhbwstuttgart.syntaxtree.GenericDeclarationList; -import de.dhbwstuttgart.syntaxtree.Method; -import de.dhbwstuttgart.syntaxtree.ParameterList; -import de.dhbwstuttgart.syntaxtree.SourceFile; -import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.modifier.Modifiers; import de.dhbwstuttgart.syntaxtree.modifier.Public; import de.dhbwstuttgart.syntaxtree.statement.Block; @@ -36,25 +17,33 @@ import de.dhbwstuttgart.syntaxtree.statement.SuperCall; import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.Type; -import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.typeinference.Menge; -import de.dhbwstuttgart.typeinference.ResultSet; -import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; -public class ASTFactory { - +public class ASTFactory { + + /** + * Anmerkung: + * Die ASTFactory Methoden, welche ASTBäume aus java.lang.Class Objekten generieren, können davon ausgehen, + * dass alle Imports und Typnamen korrekt sind und müssen diese nicht überprüfen. + */ + //private JavaClassRegistry names; + + public ASTFactory(JavaClassRegistry scope){ + names = scope; + } + public static Method createEmptyMethod(String withSignature, Class parent) { return ASTFactory.createMethod(withSignature, new ParameterList(), new Block(), parent); } - + public static Constructor createEmptyConstructor(Class parent){ Block block = new Block(); block.setType(new de.dhbwstuttgart.syntaxtree.type.Void(block, 0)); block.statements.add(new SuperCall(block)); - + return ASTFactory.createConstructor(parent, new ParameterList(), block); } - + public static Constructor createConstructor(Class superClass, ParameterList paralist, Block block){ block.parserPostProcessing(superClass); @@ -78,32 +67,46 @@ public class ASTFactory { public static Class createObject(){ return createClass(java.lang.Object.class); } - - public static Class createClass(java.lang.Class jreClass){ - JavaClassName name = new JavaClassName(jreClass.getName()); + + /** + * + * @param jreClass + * @return + */ + public Class createClass(java.lang.Class jreClass){ + JavaClassName name = names.getName(jreClass.getName()); List methoden = new ArrayList<>(); for(java.lang.reflect.Constructor constructor : jreClass.getConstructors()){ } for(java.lang.reflect.Method method : jreClass.getMethods()){ - methoden.add(createMethod(method)); + methoden.add(createMethod(method, jreClass)); } List felder = new ArrayList<>(); Modifiers modifier = new Modifiers(); modifier.addModifier(new Public()); boolean isInterface = jreClass.isInterface(); java.lang.Class superjreClass = jreClass.getSuperclass(); - RefType superClass; + RefType superClass = null; if(superjreClass != null){ - superjreClass.getName() - }else{//Jede Klasse und jedes Interface erbt von Object: + superClass = createType(superjreClass); + }else{//Jede Klasse und jedes Interface erbt von Object: (auch Object selbst!) superClass = createType(java.lang.Object.class); } List implementedInterfaces = new ArrayList<>(); + for(java.lang.Class jreInterface : jreClass.getInterfaces()){ + implementedInterfaces.add(createType(jreInterface)); + } int offset = 0; //Braucht keinen Offset, da diese Klasse nicht aus einem Quellcode geparst wurde return new Class(name, methoden, felder, modifier, isInterface, superClass, implementedInterfaces, offset); } - + + /** + * Wandelt eine Methode aus der JRE in eine Methode für unseren AST um. + * @param jreMethod + * @param inClass + * @return + */ public static Method createMethod(java.lang.reflect.Method jreMethod, java.lang.Class inClass){ String name = jreMethod.getName(); Type returnType = createType(jreMethod.getReturnType()); @@ -126,7 +129,7 @@ public class ASTFactory { return new Method(name, returnType, parameterList, block, gtvDeclarations, offset); } - public static RefType createType(java.lang.Class jreClass){ + public RefType createType(java.lang.Class jreClass){ for(TypeVariable jreTV : jreClass.getTypeParameters()){ GenericTypeVar gtv = createGeneric(jreTV, jreClass); gtvs.add(gtv); @@ -138,10 +141,14 @@ public class ASTFactory { /** * Erstellt eine GenericTypeVar oder eine BoundedGenericTypeVar * Um die Variablen korrekt zu generieren, muss die Klasse inClass übergeben werden, in der dieser Generic auftaucht + * TODO: Warum? + * Wird der AST von JREClass erzeugt, so kann davon ausgegangen werden, dass die Generics korrekt sind. + * Unser AST ist immutable und nicht im Kreis verzeigert. Generics die gleich heißen und gleiche Bounds haben, sind auch gleich. Müssen nicht die selben Instanzen sein. * @param jreTypeVar * @param inClass Die Klasse in der der Typ auftritt * @return - public static GenericTypeVar createGeneric(TypeVariable jreTypeVar, java.lang.Class inClass){ + */ + public GenericTypeVar createGeneric(TypeVariable jreTypeVar, java.lang.Class inClass){ //TODO: Bei den Namen der Parameter des Generishen Typs nachschauen, ob er in der Klasse als Generic deklariert wurde String name = jreTypeVar.getTypeName(); java.lang.reflect.Type[] bounds = jreTypeVar.getBounds(); @@ -153,8 +160,7 @@ public class ASTFactory { } return new GenericTypeVar(); } - - */ + public static Class createInterface(String className, RefType superClass, Modifiers modifiers, Menge supertypeGenPara, SourceFile parent){ diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java index dabc6141..f2f48efe 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java @@ -3,29 +3,23 @@ package de.dhbwstuttgart.syntaxtree.factory; import java.util.ArrayList; import java.util.HashSet; import java.util.List; -import java.util.logging.Logger; + import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException; -import de.dhbwstuttgart.syntaxtree.NullSyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType; import de.dhbwstuttgart.syntaxtree.type.FunN; import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; -import de.dhbwstuttgart.syntaxtree.type.ObjectType; import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType; import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.syntaxtree.type.Void; -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; diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/SuperCall.java b/src/de/dhbwstuttgart/syntaxtree/statement/SuperCall.java index c40c6ad8..28cb0bb2 100644 --- a/src/de/dhbwstuttgart/syntaxtree/statement/SuperCall.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/SuperCall.java @@ -1,31 +1,22 @@ // ino.module.This.8654.package package de.dhbwstuttgart.syntaxtree.statement; // ino.end -// ino.module.This.8654.import -import java.util.Hashtable; +// ino.module.This.8654.import import org.apache.bcel.Constants; -import org.apache.bcel.generic.ClassGen; import org.apache.bcel.generic.InstructionFactory; import org.apache.bcel.generic.InstructionHandle; import org.apache.bcel.generic.InstructionList; -import de.dhbwstuttgart.typeinference.Menge; import de.dhbwstuttgart.bytecode.ClassGenerator; -import de.dhbwstuttgart.logger.Logger; -import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.Constructor; -import de.dhbwstuttgart.syntaxtree.ConstructorCall; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; -import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; -import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.Void; import de.dhbwstuttgart.typeinference.ConstraintsSet; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; import de.dhbwstuttgart.typeinference.TypeinferenceResultSet; -import de.dhbwstuttgart.typeinference.assumptions.ConstructorAssumption; import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions; import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/ThisCall.java b/src/de/dhbwstuttgart/syntaxtree/statement/ThisCall.java index c56b725d..c506386e 100644 --- a/src/de/dhbwstuttgart/syntaxtree/statement/ThisCall.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/ThisCall.java @@ -1,18 +1,10 @@ // ino.module.This.8654.package package de.dhbwstuttgart.syntaxtree.statement; // ino.end -// ino.module.This.8654.import -import java.util.Hashtable; -import de.dhbwstuttgart.typeinference.Menge; +// ino.module.This.8654.import -import de.dhbwstuttgart.logger.Logger; -import de.dhbwstuttgart.syntaxtree.Class; import de.dhbwstuttgart.syntaxtree.Constructor; -import de.dhbwstuttgart.syntaxtree.ConstructorCall; import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; -import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; -import de.dhbwstuttgart.syntaxtree.type.RefType; -import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.Void; import de.dhbwstuttgart.typeinference.ConstraintsSet; import de.dhbwstuttgart.typeinference.JavaCodeResult; @@ -25,14 +17,10 @@ import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; public class ThisCall extends MethodCall { - public ThisCall(int offset,int variableLength) + public ThisCall(Receiver receiver, ArgumentList arglist, int offset) { - super(offset,variableLength); - } + super(offset); - public ThisCall(SyntaxTreeNode parent){ - this(0,0); - this.parent = parent; } public ArgumentList arglist; @@ -56,8 +44,7 @@ public class ThisCall extends MethodCall * This kann auch als Konstruktoraufruf in einem Konstruktor-Block vorkommen. */ @Override - public ConstraintsSet TYPEStmt(TypeAssumptions assumptions) { - String className = this.getParentClass().getName().toString(); + public ConstraintsSet TYPEStmt(TypeAssumptions assumptions, Class parentClass) { ConstraintsSet ret = new ConstraintsSet(); this.setType(new Void(this,this.getOffset())); //Kontrollieren, dass sich this(...) in einem Konstruktor und dort als erstes Statement befindet: @@ -65,9 +52,7 @@ public class ThisCall extends MethodCall if(p instanceof Constructor && ((Constructor)p).get_Block().statements.firstElement().equals(this)){ //Constraints generieren: - - ConstructorCall constructorCall = new ConstructorCall(new Receiver(new This(this)), className, arglist, this.getOffset()); - ret.add(constructorCall.TYPEStmt(assumptions)); + ret.add(super.TYPEStmt(assumptions, parentClass)); return ret; }else{ //Ansonsten Fehler ausgeben: @@ -75,9 +60,18 @@ public class ThisCall extends MethodCall } } + @Override + public ConstraintsSet overloading(TypeAssumptions assumptions){ + ConstraintsSet ret = new ConstraintsSet(); + ConstructorAssumption cAss = assumptions.getConstructorAssumption(this.get_Name(), this.getArgumentList().size()); + if(cAss == null)throw new TypeinferenceException("Kein Konstruktor mit passender Parameteranzahl vorhanden",this); + + ret.add(constraintsFromMethodAssumption(cAss, assumptions)); + return ret; + } + public String toString() { - //return receiver/*.toString()*/ + " " + usedid.toString(); return "(" + "this" +"(" + this.getArgumentList() + "))"; } @@ -85,14 +79,6 @@ public class ThisCall extends MethodCall public JavaCodeResult printJavaCode(ResultSet resultSet) { return new JavaCodeResult("this("+this.getArgumentList().printJavaCode(resultSet)+")"); } - - @Override - public Menge getChildren() { - Menge ret = new Menge(); - if(arglist != null)ret.add(arglist); - return ret; - } - } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java b/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java index d92ee56b..3481ae89 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java @@ -1,9 +1,5 @@ - -// ino.module.BoundedGenericTypeVar.8669.package package de.dhbwstuttgart.syntaxtree.type; -// ino.end -// ino.module.BoundedGenericTypeVar.8669.import import de.dhbwstuttgart.typeinference.Menge; import de.dhbwstuttgart.syntaxtree.Class; @@ -12,7 +8,6 @@ import de.dhbwstuttgart.typeinference.ConstraintsSet; import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions; import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; -// ino.class.BoundedGenericTypeVar.26464.description type=javadoc /** * Entspricht einem GenericTypeVar, jedoch mit Bounds * (d.h. vorgaben, von welchem Typ die Typevar sein darf @@ -22,39 +17,16 @@ import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; * @author hoti 4.5.06 * */ -// ino.end -// ino.class.BoundedGenericTypeVar.26464.declaration public class BoundedGenericTypeVar extends GenericTypeVar -// ino.end -// ino.class.BoundedGenericTypeVar.26464.body { - // ino.attribute.bounds.26468.decldescription type=javadoc /** * Hier sind die Bounds in Form von Type-Objekten abgespeichert */ - // ino.end - // ino.attribute.bounds.26468.declaration Menge bounds=new Menge(); - // ino.end private int endOffset; - - /* - // ino.method.BoundedGenericTypeVar.26471.definition - public BoundedGenericTypeVar(String s, int offset, Menge t, int endOffset) - // ino.end - // ino.method.BoundedGenericTypeVar.26471.body - { - super(s, offset); - throw new NotImplementedException(); - } - // ino.end - */ - - // ino.method.BoundedGenericTypeVar.29409.definition + public BoundedGenericTypeVar(String s, Menge bounds, int offset, int endOffset) - // ino.end - // ino.method.BoundedGenericTypeVar.29409.body { super(s, offset); if(bounds != null)for(Type t : bounds){ @@ -64,7 +36,6 @@ public class BoundedGenericTypeVar extends GenericTypeVar this.bounds = bounds; this.endOffset = endOffset; } - // ino.end @Override public int getEndOffset(){ @@ -97,25 +68,16 @@ public class BoundedGenericTypeVar extends GenericTypeVar this.bounds = tempBounds; return ret; } - - // ino.method.clone.26483.definition + public BoundedGenericTypeVar clone() - // ino.end - // ino.method.clone.26483.body { return new BoundedGenericTypeVar(this.getName().toString(), this.getBounds(), getOffset(), this.getEndOffset()); } - // ino.end - // ino.method.toString.26486.definition public String toString() - // ino.end - // ino.method.toString.26486.body { return "BoGTV " + this.getName(); } - // ino.end - @Override public Menge getChildren() { @@ -125,4 +87,3 @@ public class BoundedGenericTypeVar extends GenericTypeVar } } -// ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java b/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java index d7934732..f4ed7c9b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java @@ -42,9 +42,7 @@ public class GenericTypeVar extends ObjectType * Ihre Superklasse ersetzt werden m�ssen. Siehe "Type Erasure" in Sun Spezifikation. *
Autor: J�rg B�uerle */ - // ino.method.GenericTypeVar.26509.defdescription type=line // private Hashtable> m_TypeErasureList; - // ino.end private static HashMap tph = new HashMap<>(); /** @@ -61,32 +59,23 @@ public class GenericTypeVar extends ObjectType this.name = genericTypeVar.toString(); } */ - - // ino.method.GenericTypeVar.26509.definition + public GenericTypeVar(String s, int offset) - // ino.end - // ino.method.GenericTypeVar.26509.body { super(s,offset); this.name = new JavaClassName(s); } - // ino.end - + /* public GenericTypeVar(Type tA1, int offset) { this(new Pair(tA1,null),offset); } */ - // ino.method.clone.26512.defdescription type=javadoc /** *
Author: J�rg B�uerle * @return */ - // ino.end - // ino.method.clone.26512.definition public GenericTypeVar clone() - // ino.end - // ino.method.clone.26512.body { return new GenericTypeVar(this.getName().toString(), getOffset()); } @@ -96,26 +85,15 @@ public class GenericTypeVar extends ObjectType * @param obj * @return */ - // ino.end - // ino.method.equals.26515.definition public boolean equals(Object obj) - // ino.end - // ino.method.equals.26515.body { return super.equals(obj) && (obj instanceof GenericTypeVar); } - // ino.end - - - - // ino.method.toString.26518.definition + public String toString() - // ino.end - // ino.method.toString.26518.body { return "GTV " + this.getName(); } - // ino.end @Override public int hashCode() { @@ -133,12 +111,9 @@ public class GenericTypeVar extends ObjectType } public String getSignatureType(Menge paralist) - // ino.end - // ino.method.getSignatureType.26524.body { return "T" + name + ";"; } - // ino.end @Override public JavaCodeResult printJavaCode(ResultSet resultSet) { @@ -237,5 +212,4 @@ public class GenericTypeVar extends ObjectType } } -// ino.end diff --git a/test/unify/UnifyTypeFactoryTest.java b/test/unify/UnifyTypeFactoryTest.java index 2cf5bc53..a7f984b8 100644 --- a/test/unify/UnifyTypeFactoryTest.java +++ b/test/unify/UnifyTypeFactoryTest.java @@ -6,8 +6,6 @@ import java.util.Set; import org.junit.Test; -import de.dhbwstuttgart.syntaxtree.NullSyntaxTreeNode; -import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory; import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType; import de.dhbwstuttgart.syntaxtree.type.FunN;