From 87e4f2fd3695e584adbae426567f079d23832a40 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Tue, 15 Apr 2014 14:56:20 +0200 Subject: [PATCH] =?UTF-8?q?TypeinferenceException=20=C3=BCberarbeitet?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/mycompiler/MyCompiler.java | 13 ++++---- src/mycompiler/MyCompilerAPI.java | 8 +++-- src/mycompiler/SourceFile.java | 5 +-- src/mycompiler/SyntaxTreeNode.java | 5 +-- src/mycompiler/myclass/Class.java | 4 +-- src/mycompiler/myclass/Constructor.java | 4 +-- src/mycompiler/myclass/FieldDeclaration.java | 14 +++++++-- src/mycompiler/myclass/FormalParameter.java | 13 ++++++-- src/mycompiler/myclass/Method.java | 24 +++++++++++--- src/mycompiler/myclass/UsedId.java | 4 +-- src/mycompiler/mystatement/Block.java | 4 +-- .../mystatement/LambdaExpression.java | 4 +-- .../mystatement/LocalOrFieldVar.java | 3 ++ src/mycompiler/mystatement/LocalVarDecl.java | 9 +++++- src/mycompiler/mystatement/StringLiteral.java | 3 ++ src/mycompiler/mytest/LambdaTest.java | 4 +-- .../TypeinferenceResultSet.java | 2 +- src/typinferenz/Overloading.java | 5 ++- src/typinferenz/SingleConstraint.java | 5 +-- src/typinferenz/TypeInsertable.java | 3 +- .../assumptions/TypeAssumptions.java | 30 +++++++++--------- src/typinferenz/exceptions/ParserError.java | 12 +++++++ .../exceptions/ParserException.java | 16 ---------- .../exceptions/TypeinferenceException.java | 31 +++++++++++++++++++ .../exceptions/TypinferenzException.java | 13 -------- src/userinterface/ConsoleInterface.java | 4 +-- test/plugindevelopment/TRMEqualTest.java | 6 ++++ 27 files changed, 163 insertions(+), 85 deletions(-) create mode 100644 src/typinferenz/exceptions/ParserError.java delete mode 100644 src/typinferenz/exceptions/ParserException.java create mode 100755 src/typinferenz/exceptions/TypeinferenceException.java delete mode 100755 src/typinferenz/exceptions/TypinferenzException.java diff --git a/src/mycompiler/MyCompiler.java b/src/mycompiler/MyCompiler.java index b1ed25a0..cd6c0368 100755 --- a/src/mycompiler/MyCompiler.java +++ b/src/mycompiler/MyCompiler.java @@ -46,8 +46,9 @@ import typinferenz.FunNInterface; import typinferenz.ResultSet; // ino.end import typinferenz.assumptions.TypeAssumptions; -import typinferenz.exceptions.ParserException; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.DebugException; +import typinferenz.exceptions.ParserError; +import typinferenz.exceptions.TypeinferenceException; @@ -756,7 +757,7 @@ public class MyCompiler implements MyCompilerAPI /** * Parst den Inhalt einer Datei zu einem Syntaxbaum. */ - private SourceFile parse2SyntaxTree(Reader fileContent){ + private SourceFile parse2SyntaxTree(Reader fileContent) throws ParserError{ //StringReader reader = new StringReader(fileContent); ////////////////////////////////////// @@ -773,7 +774,7 @@ public class MyCompiler implements MyCompilerAPI srcFile = (SourceFile) parser.yyparse( scanner ); } catch (IOException | yyException e) { e.printStackTrace(); - if(e instanceof yyException)throw new ParserException((yyException)e); + if(e instanceof yyException)throw new ParserError((yyException)e); } ////////////////////////////////////// // Postprocessing: @@ -786,7 +787,7 @@ public class MyCompiler implements MyCompilerAPI /** * Diese Funktion nimmt einen Vector von Dateinamen. Alle diese Dateien werden zu einem SyntaxBaum geparst. */ - public void parse(Vector filenames) { + public void parse(Vector filenames) throws ParserError { for(String filename : filenames){ StringBuffer fileData = new StringBuffer(); @@ -795,7 +796,7 @@ public class MyCompiler implements MyCompilerAPI reader = new BufferedReader( new FileReader(filename)); } catch (FileNotFoundException e) { - throw new TypinferenzException("Die Datei "+ filename+" konnte nicht gelesen werden."); + throw new DebugException("Die Datei "+ filename+" konnte nicht gelesen werden."); } char[] buf = new char[1024]; int numRead=0; diff --git a/src/mycompiler/MyCompilerAPI.java b/src/mycompiler/MyCompilerAPI.java index e990ba46..d75cbd4d 100755 --- a/src/mycompiler/MyCompilerAPI.java +++ b/src/mycompiler/MyCompilerAPI.java @@ -9,6 +9,8 @@ import java.io.IOException; import java.util.Vector; import typinferenz.ResultSet; +import typinferenz.exceptions.ParserError; +import typinferenz.exceptions.TypeinferenceException; import mycompiler.mybytecode.ClassFile; import mycompiler.myexception.CTypeReconstructionException; import mycompiler.myexception.JVMCodeException; @@ -84,7 +86,7 @@ public interface MyCompilerAPI // ino.end // ino.method.typeReconstruction.21340.declaration public Vector typeReconstruction() - throws NullPointerException, CTypeReconstructionException; + throws NullPointerException, TypeinferenceException; // ino.end // ino.method.codeGeneration.21346.decldescription type=javadoc @@ -125,14 +127,14 @@ public interface MyCompilerAPI * Parst zusammenhängende JavaKlassen in verschiedenen Dateien. * @param filenames - Eine Liste von Quellcodedateien, welche gseparst werden sollen */ - public void parse(Vector filenames); + public void parse(Vector filenames) throws ParserError; /** * Parst den SourceCode einer Datei. * @param sourceCode - SourceCode einer Java-Quellcodedatei * @return den aus dem sourceCode generierten Syntaxbaum */ - public SourceFile parse(String sourceCode); + public SourceFile parse(String sourceCode) throws ParserError; } // ino.end diff --git a/src/mycompiler/SourceFile.java b/src/mycompiler/SourceFile.java index 24b5c89d..8370cd50 100755 --- a/src/mycompiler/SourceFile.java +++ b/src/mycompiler/SourceFile.java @@ -58,7 +58,8 @@ import typinferenz.assumptions.ClassAssumption; import typinferenz.assumptions.MethodAssumption; import typinferenz.assumptions.ParameterAssumption; import typinferenz.assumptions.TypeAssumptions; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.DebugException; +import typinferenz.exceptions.TypeinferenceException; @@ -1584,7 +1585,7 @@ public class SourceFile @Override public void parserPostProcessing(SyntaxTreeNode parent) { - if(parent!=null)throw new TypinferenzException("Eine SourceFile hat keine Elternelement im Syntaxbaum"); + if(parent!=null)throw new DebugException("Eine SourceFile hat kein Elternelement im Syntaxbaum"); super.parserPostProcessing(parent); //for(SyntaxTreeNode node : this.getChildren())node.parserPostProcessing(this); } diff --git a/src/mycompiler/SyntaxTreeNode.java b/src/mycompiler/SyntaxTreeNode.java index e609d76e..f0110158 100644 --- a/src/mycompiler/SyntaxTreeNode.java +++ b/src/mycompiler/SyntaxTreeNode.java @@ -2,7 +2,8 @@ package mycompiler; import java.util.Vector; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.DebugException; +import typinferenz.exceptions.TypeinferenceException; import mycompiler.myclass.Class; import mycompiler.mytype.GenericTypeVar; @@ -33,7 +34,7 @@ public abstract class SyntaxTreeNode { public Class getParentClass(){ SyntaxTreeNode parent = this.getParent(); if(parent instanceof Class)return (Class)parent; - if(parent == null)throw new TypinferenzException("Das Wurzelelement eines Syntaxbaumes muss Class sein"); + if(parent == null)throw new DebugException("Das Wurzelelement eines Syntaxbaumes muss Class sein"); return parent.getParentClass(); } diff --git a/src/mycompiler/myclass/Class.java b/src/mycompiler/myclass/Class.java index cf07b8b6..95711284 100755 --- a/src/mycompiler/myclass/Class.java +++ b/src/mycompiler/myclass/Class.java @@ -70,7 +70,7 @@ import typinferenz.UndConstraint; import typinferenz.FunN; import typinferenz.assumptions.ClassAssumption; import typinferenz.assumptions.TypeAssumptions; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; import typinferenz.*; @@ -407,7 +407,7 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface * -Rückgabetyp der Methode/Konstruktors ist der Typ der Klasse * -Ein Konstruktor kann nicht aufgerufen werden (nur mit new) */ - if(m.get_Method_Name().equals(""))throw new TypinferenzException(" ist kein gültiger Methodenname"); + if(m.get_Method_Name().equals(""))throw new TypeinferenceException(" ist kein gültiger Methodenname", m); if((m.get_Method_Name().equals(this.getName()))) { Constructor constructor = new Constructor(m); tempFields.add(constructor); //Den Konstruktor anstatt der Methode anfügen diff --git a/src/mycompiler/myclass/Constructor.java b/src/mycompiler/myclass/Constructor.java index c811a1a2..0eb22ef3 100644 --- a/src/mycompiler/myclass/Constructor.java +++ b/src/mycompiler/myclass/Constructor.java @@ -18,7 +18,7 @@ import typinferenz.SingleConstraint; import typinferenz.assumptions.ConstructorAssumption; import typinferenz.assumptions.MethodAssumption; import typinferenz.assumptions.TypeAssumptions; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; public class Constructor extends Method { private Method methode; @@ -265,7 +265,7 @@ public class Constructor extends Method { @Override public void setType(Type t) { - throw new TypinferenzException("Einem Konstruktor kann kein Typ zugewiesen werden"); + throw new TypeinferenceException("Einem Konstruktor kann kein Typ zugewiesen werden", this); //this.methode.setType(t); } diff --git a/src/mycompiler/myclass/FieldDeclaration.java b/src/mycompiler/myclass/FieldDeclaration.java index 94803593..a878284a 100644 --- a/src/mycompiler/myclass/FieldDeclaration.java +++ b/src/mycompiler/myclass/FieldDeclaration.java @@ -9,7 +9,7 @@ import typinferenz.ResultSet; import typinferenz.SingleConstraint; import typinferenz.assumptions.FieldAssumption; import typinferenz.assumptions.TypeAssumptions; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; import mycompiler.SyntaxTreeNode; import mycompiler.mybytecode.ClassFile; import mycompiler.myexception.JVMCodeException; @@ -90,7 +90,7 @@ public class FieldDeclaration extends Field{ * Der Feld-Assumption muss ein TPH als Typ hinzugefügt werden, falls er Typlos initialisiert wurde. Dies kann auch der Type-Algorithmus der Inst/FieldVar - Klasse machen. * Wird das Feld mit einem Typ initialisiert so muss dieser auch in die Assumptions. */ - if(this.getType() == null)throw new TypinferenzException("Der Typ eines Feldes darf nicht null sein"); + if(this.getType() == null)throw new TypeinferenceException("Der Typ eines Feldes darf nicht null sein", this); //assumptions.add(TypeAssumptions.createFieldVarAssumption(classmember.getName(), this.getName(), this.getType())); assumptions.addAssumption(new FieldAssumption(this,classmember)); return assumptions; @@ -134,7 +134,15 @@ public class FieldDeclaration extends Field{ GenericTypeVar gtv = (GenericTypeVar) this.getType(); } */ - if(this.getType()!=null && (this.getType() instanceof RefType))this.setType(publicAssumptions.getTypeFor((RefType)this.getType())); + + //TypeCheck, falls es sich um einen RefType handelt: + if(this.getType()!=null && (this.getType() instanceof RefType)){ + Type replaceType = null; + replaceType = publicAssumptions.getTypeFor((RefType)this.getType()); + if(replaceType == null)throw new TypeinferenceException("Der Typ "+this.getType().getName()+" ist nicht korrekt",this); + this.setType(replaceType); + } + SingleConstraint c1 = new SingleConstraint(this.getType(), this.getType()); ret.add(c1); //Damit die TypVariable des Felds in den Constraints auftaucht diff --git a/src/mycompiler/myclass/FormalParameter.java b/src/mycompiler/myclass/FormalParameter.java index 3ac257cc..ee1d9d86 100755 --- a/src/mycompiler/myclass/FormalParameter.java +++ b/src/mycompiler/myclass/FormalParameter.java @@ -32,7 +32,7 @@ import typinferenz.ResultSet; import typinferenz.TypeInsertPoint; import typinferenz.Typeable; import typinferenz.TypeInsertable; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; // ino.class.FormalParameter.23391.declaration public class FormalParameter extends SyntaxTreeNode implements ITypeReplacementListener, Typeable, TypeInsertable @@ -127,7 +127,7 @@ public class FormalParameter extends SyntaxTreeNode implements ITypeReplacementL public String getTypeName() // ino.end // ino.method.getTypeName.23416.body - { + { if(this.getType() == null)return ""; return this.getType().getName(); } // ino.end @@ -263,5 +263,14 @@ public class FormalParameter extends SyntaxTreeNode implements ITypeReplacementL } + @Override + public int getVariableLength() { + int ret = 0; + ret += this.getTypeName().length(); + ret +=this.getIdentifier().length(); + return ret; + } + + } // ino.end diff --git a/src/mycompiler/myclass/Method.java b/src/mycompiler/myclass/Method.java index 23f0c553..0f8141ba 100755 --- a/src/mycompiler/myclass/Method.java +++ b/src/mycompiler/myclass/Method.java @@ -41,6 +41,7 @@ import typinferenz.TypeInsertable; import typinferenz.assumptions.MethodAssumption; import typinferenz.assumptions.ParameterAssumption; import typinferenz.assumptions.TypeAssumptions; +import typinferenz.exceptions.TypeinferenceException; @@ -541,15 +542,30 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable public ConstraintsSet TYPE(TypeAssumptions ass) { - if((this.returntype instanceof RefType) && - !(this.returntype instanceof mycompiler.mytype.Void))//Sonderfall der Methode: Ihr Typ darf Void definiert werden. - this.returntype = ass.getTypeFor((RefType)this.returntype); + //TypeCheck, falls es sich um einen RefType handelt: + if(this.returntype!=null && (this.returntype instanceof RefType)&& + !(this.returntype instanceof mycompiler.mytype.Void)){//Sonderfall der Methode: Ihr Typ darf Void definiert werden. + Type replaceType = null; + replaceType = ass.getTypeFor((RefType)this.returntype); + if(replaceType == null)throw new TypeinferenceException("Der Typ "+this.getType().getName()+" ist nicht korrekt",this); + this.returntype = replaceType; + } ConstraintsSet ret = new ConstraintsSet(); TypeAssumptions localAss = new TypeAssumptions(); localAss.add(ass); //Die globalen Assumptions anhängen //Die Parameter zu den Assumptions hinzufügen: if(this.parameterlist!=null)for(FormalParameter param : this.parameterlist){ - if(param.getType() instanceof RefType)param.setType(ass.getTypeFor((RefType)param.getType())); + + + if(param.getType() instanceof RefType) + { + Type replaceType = null; + replaceType = ass.getTypeFor((RefType)param.getType()); + if(replaceType == null)throw new TypeinferenceException("Der Typ "+this.getType().getName()+" ist nicht korrekt",param); + param.setType(replaceType); + } + + localAss.addAssumption(new ParameterAssumption(param)); } ret.add(this.block.TYPEStmt(localAss)); diff --git a/src/mycompiler/myclass/UsedId.java b/src/mycompiler/myclass/UsedId.java index b6f022da..b367580e 100755 --- a/src/mycompiler/myclass/UsedId.java +++ b/src/mycompiler/myclass/UsedId.java @@ -7,7 +7,7 @@ import java.util.Vector; import typinferenz.JavaCodeResult; import typinferenz.ResultSet; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; import mycompiler.IItemWithOffset; import mycompiler.mybytecode.JVMCode; import mycompiler.mytype.Type; @@ -312,7 +312,7 @@ public class UsedId implements IItemWithOffset // ino.end public JavaCodeResult printJavaCode(ResultSet resultSet) { - if(this.name.size()>1)throw new TypinferenzException("Es kann maximal nur eine Superklasse pro Klasse geben"); + if(this.name.size()>1)throw new TypeinferenceException("Es kann maximal nur eine Superklasse pro Klasse geben", this); JavaCodeResult ret = new JavaCodeResult(this.getQualifiedName()); if(this.paralist != null){ ret.attach( "<" ); diff --git a/src/mycompiler/mystatement/Block.java b/src/mycompiler/mystatement/Block.java index 9546246d..f0eeda9f 100755 --- a/src/mycompiler/mystatement/Block.java +++ b/src/mycompiler/mystatement/Block.java @@ -40,7 +40,7 @@ import typinferenz.ConstraintsSet; import typinferenz.FreshTypeVariable; import typinferenz.ResultSet; import typinferenz.assumptions.TypeAssumptions; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; @@ -236,7 +236,7 @@ public class Block extends Statement if (!(stmt.getType() instanceof Void)) if (this.getType() instanceof Void) { //this.setTypeVariable(stmt.getTypeVariable()); - throw new TypinferenzException("Falscher Return Type"); + throw new TypeinferenceException("Block besitzt falschen Rückgabetyp (fehlendes return-stmt)", this); } else { TypePlaceholder tph = TypePlaceholder.fresh(this); diff --git a/src/mycompiler/mystatement/LambdaExpression.java b/src/mycompiler/mystatement/LambdaExpression.java index 7a2adac5..1df56c08 100755 --- a/src/mycompiler/mystatement/LambdaExpression.java +++ b/src/mycompiler/mystatement/LambdaExpression.java @@ -12,7 +12,7 @@ import typinferenz.ResultSet; import typinferenz.Typeable; import typinferenz.assumptions.ParameterAssumption; import typinferenz.assumptions.TypeAssumptions; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; import mycompiler.SyntaxTreeNode; import mycompiler.mybytecode.ClassFile; import mycompiler.mybytecode.CodeAttribute; @@ -171,7 +171,7 @@ public class LambdaExpression extends Expr{ @Override public ConstraintsSet TYPEStmt(TypeAssumptions ass){ - throw new TypinferenzException("Eine LambdaExpression darf nicht als Statement verwendet werden."); + throw new TypeinferenceException("Eine LambdaExpression darf nicht als Statement verwendet werden.", this); } @Override diff --git a/src/mycompiler/mystatement/LocalOrFieldVar.java b/src/mycompiler/mystatement/LocalOrFieldVar.java index 4efc34d4..53958a98 100755 --- a/src/mycompiler/mystatement/LocalOrFieldVar.java +++ b/src/mycompiler/mystatement/LocalOrFieldVar.java @@ -34,6 +34,7 @@ import org.apache.log4j.Logger; + import sun.reflect.generics.reflectiveObjects.NotImplementedException; import typinferenz.JavaCodeResult; import typinferenz.SingleConstraint; @@ -41,6 +42,7 @@ import typinferenz.ConstraintsSet; import typinferenz.FreshTypeVariable; import typinferenz.ResultSet; import typinferenz.assumptions.TypeAssumptions; +import typinferenz.exceptions.TypeinferenceException; @@ -207,6 +209,7 @@ public class LocalOrFieldVar extends Expr ConstraintsSet ret = new ConstraintsSet(); //gibt es eine Assumption für den die LocalOrFieldVar-Variablen, dann folgendes ausführen: Type thisTypeAssumption = assumptions.getVarType(this.get_Name(), this.getParentClass()); + if(thisTypeAssumption == null)throw new TypeinferenceException("Eine Variable "+this.get_Name()+" ist in den Assumptions nicht vorhanden",this); this.setType(thisTypeAssumption); //ret.add(new Constraint(thisTypeAssumption, this.getTypeVariable())); return ret; diff --git a/src/mycompiler/mystatement/LocalVarDecl.java b/src/mycompiler/mystatement/LocalVarDecl.java index a5b8f537..370360d7 100755 --- a/src/mycompiler/mystatement/LocalVarDecl.java +++ b/src/mycompiler/mystatement/LocalVarDecl.java @@ -40,6 +40,7 @@ import org.apache.log4j.Logger; + import typinferenz.ConstraintsSet; import typinferenz.FreshTypeVariable; import typinferenz.JavaCodeResult; @@ -48,6 +49,7 @@ import typinferenz.TypeInsertPoint; import typinferenz.TypeInsertable; import typinferenz.assumptions.LocalVarAssumption; import typinferenz.assumptions.TypeAssumptions; +import typinferenz.exceptions.TypeinferenceException; @@ -463,7 +465,12 @@ public class LocalVarDecl extends Statement implements TypeInsertable @Override public ConstraintsSet TYPEStmt(TypeAssumptions assumptions) { ConstraintsSet ret = new ConstraintsSet(); - if((this.getType() instanceof RefType))this.setType(assumptions.getTypeFor((RefType)this.getType())); + if((this.getType() instanceof RefType)){ + Type replaceType = null; + replaceType = assumptions.getTypeFor((RefType)this.getType()); + if(replaceType == null)throw new TypeinferenceException("Der Typ "+this.getType().getName()+" ist nicht korrekt",this); + this.setType(replaceType); + } assumptions.addAssumption(new LocalVarAssumption(this)); //assumptions.remove(null); // falls Variable mit diesem Namen bereits vorhanden. this.setType(new Void(0)); //Return typ einer Variablendeklaration ist Void diff --git a/src/mycompiler/mystatement/StringLiteral.java b/src/mycompiler/mystatement/StringLiteral.java index fd9416a1..247f8483 100755 --- a/src/mycompiler/mystatement/StringLiteral.java +++ b/src/mycompiler/mystatement/StringLiteral.java @@ -27,10 +27,12 @@ import org.apache.log4j.Logger; + import typinferenz.ConstraintsSet; import typinferenz.JavaCodeResult; import typinferenz.ResultSet; import typinferenz.assumptions.TypeAssumptions; +import typinferenz.exceptions.TypeinferenceException; @@ -138,6 +140,7 @@ public class StringLiteral extends Literal @Override public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) { this.set_Type(assumptions.getTypeFor(new RefType("String",0))); + if(this.getType() == null)throw new TypeinferenceException("java.lang.String nicht importiert",this); return new ConstraintsSet(); } diff --git a/src/mycompiler/mytest/LambdaTest.java b/src/mycompiler/mytest/LambdaTest.java index 5b3424e9..a86bcf75 100755 --- a/src/mycompiler/mytest/LambdaTest.java +++ b/src/mycompiler/mytest/LambdaTest.java @@ -16,7 +16,7 @@ import org.apache.log4j.PatternLayout; import org.apache.log4j.SimpleLayout; import typinferenz.assumptions.TypeAssumptions; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; import mycompiler.MyCompiler; import mycompiler.MyCompilerAPI; import mycompiler.mytype.Type; @@ -145,7 +145,7 @@ public class LambdaTest { ///////////////////////// try{ resultSet = compiler.typeReconstruction(); - }catch(TypinferenzException texc){ + }catch(TypeinferenceException texc){ texc.printStackTrace(); fail("Fehler bei Typinferenzalgorithmus. Message: "+texc.getMessage()); } diff --git a/src/mycompiler/mytypereconstruction/TypeinferenceResultSet.java b/src/mycompiler/mytypereconstruction/TypeinferenceResultSet.java index a2815455..1eeef999 100755 --- a/src/mycompiler/mytypereconstruction/TypeinferenceResultSet.java +++ b/src/mycompiler/mytypereconstruction/TypeinferenceResultSet.java @@ -12,7 +12,7 @@ import typinferenz.ResultSet; import typinferenz.TypeInsertPoint; import typinferenz.TypeInsertSet; import typinferenz.assumptions.TypeAssumptions; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; import mycompiler.mytype.GenericTypeVar; import mycompiler.mytype.Pair; import mycompiler.mytype.RefType; diff --git a/src/typinferenz/Overloading.java b/src/typinferenz/Overloading.java index bcfd04b1..d371e2f7 100755 --- a/src/typinferenz/Overloading.java +++ b/src/typinferenz/Overloading.java @@ -4,6 +4,7 @@ import java.util.Vector; import typinferenz.assumptions.MethodAssumption; import typinferenz.assumptions.TypeAssumptions; +import typinferenz.exceptions.TypeinferenceException; import mycompiler.mystatement.Expr; import mycompiler.mystatement.MethodCall; import mycompiler.mytype.RefType; @@ -60,7 +61,9 @@ public class Overloading{ for(Expr argument : methodCall.getArgumentList().expr){ parameterList.add(argument.getType()); } - for(MethodAssumption methodAssumption : assumptions.getMethodAssumptions(methodCall.getName(), parameterList)){ + Vector methodAssumptions = assumptions.getMethodAssumptions(methodCall.getName(), parameterList); + if(methodAssumptions.size()==0)throw new TypeinferenceException("Eine Methode "+methodCall.get_Name()+" ist in den Assumptions nicht vorhanden", methodCall); + for(MethodAssumption methodAssumption : methodAssumptions){ if(!(this.type instanceof TypePlaceholder) && !this.type.equals(methodAssumption.getAssumedType()))break; UndConstraint methodConstraint = new UndConstraint(); //Ein Constraint für den ReturnType der Methode... diff --git a/src/typinferenz/SingleConstraint.java b/src/typinferenz/SingleConstraint.java index 650b6da9..5dc0f984 100755 --- a/src/typinferenz/SingleConstraint.java +++ b/src/typinferenz/SingleConstraint.java @@ -2,7 +2,8 @@ package typinferenz; import java.util.Vector; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.DebugException; +import typinferenz.exceptions.TypeinferenceException; import mycompiler.mytype.GenericTypeVar; import mycompiler.mytype.Pair; import mycompiler.mytype.RefType; @@ -43,7 +44,7 @@ public class SingleConstraint extends UndConstraint{ } public void addConstraint(Pair toAdd){ - if(constraintPair != null)throw new TypinferenzException("Ein Constraint darf nur aus einem ConstraintPair bestehen. Das hinzufügen von "+ toAdd + " ist nicht möglich."); + if(constraintPair != null)throw new DebugException("Ein Constraint darf nur aus einem ConstraintPair bestehen. Das hinzufügen von "+ toAdd + " ist nicht möglich."); Type p1 = toAdd.TA1; Type p2 = toAdd.TA2; diff --git a/src/typinferenz/TypeInsertable.java b/src/typinferenz/TypeInsertable.java index 369d4c47..c7d9fe08 100644 --- a/src/typinferenz/TypeInsertable.java +++ b/src/typinferenz/TypeInsertable.java @@ -1,9 +1,10 @@ package typinferenz; +import mycompiler.IItemWithOffset; import mycompiler.mytype.TypePlaceholder; import mycompiler.mytypereconstruction.replacementlistener.ITypeReplacementListener; -public interface TypeInsertable extends ITypeReplacementListener, Typeable { +public interface TypeInsertable extends ITypeReplacementListener, Typeable, IItemWithOffset { public int getOffset(); public void setOffset(int offset); diff --git a/src/typinferenz/assumptions/TypeAssumptions.java b/src/typinferenz/assumptions/TypeAssumptions.java index 447c987d..b171ff26 100755 --- a/src/typinferenz/assumptions/TypeAssumptions.java +++ b/src/typinferenz/assumptions/TypeAssumptions.java @@ -10,7 +10,7 @@ import sun.reflect.generics.reflectiveObjects.NotImplementedException; import typinferenz.FunN; import typinferenz.FunNInterface; import typinferenz.FunNMethod; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; import mycompiler.mytype.GenericTypeVar; import mycompiler.mytype.RefType; import mycompiler.mytype.Type; @@ -81,11 +81,18 @@ public class TypeAssumptions { return ret; } + /** + * Liefert den Typ einer Feldvariable der Klasse inClass + * @param withName + * @param inClass + * @return null, falls die Klasse kein zugängliches Feld enthält + */ public Type getTypeOfFieldVar(String withName, Class inClass){ for(FieldAssumption fa : this.getFieldVars(withName)){ if(fa.getParentClass().equals(inClass))return fa.getAssumedType(); } - throw new TypinferenzException("Das Feld "+withName+" ist in der Klasse "+inClass.getName()+" nicht vorhanden."); + //throw new TypeinferenceException("Das Feld "+withName+" ist in der Klasse "+inClass.getName()+" nicht vorhanden."); + return null; } /** @@ -137,7 +144,7 @@ public class TypeAssumptions { // MethodAssumption funNAssumption = new MethodAssumption(new FunNMethod(parameterCount), new FunNInterface(parameter)); // ret.add(funNAssumption); //} - if(ret.size()==0)throw new TypinferenzException("Eine Methode "+methodName+" ist in den Assumptions nicht vorhanden"); + //if(ret.size()==0)throw new TypeinferenceException("Eine Methode "+methodName+" ist in den Assumptions nicht vorhanden"); return ret; } @@ -147,7 +154,7 @@ public class TypeAssumptions { * In den Assumptions wird dann in der Reihenfolge LocalVarAssumptions, FieldAssumption nach dem übergebenen Variablennamen gesucht. * @param variableName - der Identifier der gesuchten Variablen * @param inScope - Sucht auch die Felder der übergebenen Klasse ab. Hier kann auch null übergeben werden, dann werden nur die Lokalen Variablen dieser TypeAssumption durchsucht. - * @return - Der Typ für diesen Identifier + * @return - Der Typ für diesen Identifier, oder null, falls kein Typ vorliegt. */ public Type getVarType(String variableName, Class inScope){ //Zuerst die Parameter durchsuchen @@ -166,7 +173,8 @@ public class TypeAssumptions { } } //Wird keine Assumption gefunden, muss ein Fehler vorliegen: - throw new TypinferenzException("Eine Variable "+variableName+" ist in den Assumptions nicht vorhanden"); + //throw new TypeinferenceException("Eine Variable "+variableName+" ist in den Assumptions nicht vorhanden"); + return null; } /** @@ -271,20 +279,14 @@ public class TypeAssumptions { return ret; } - @Deprecated - public Type getThisValue2() { - if(thisClassName == null)throw new TypinferenzException("Kein Wert für this vorhanden, in diesem Kontext"); - return new RefType(thisClassName, 0); - } /** * Kontrolliert den vom Parser gesetzten Typ. * Erweitert dessen Bezeichnung, wenn nötig. * @param t - * @return - * @throws TypinferenzException + * @return null, falls der Typ nicht vorhanden ist. */ - public Type getTypeFor(RefType t) throws TypinferenzException{ + public Type getTypeFor(RefType t){ //TODO: Die Parameterliste noch kontrollieren: (hier könnte es Constraints geben: "? extends String") //Alle bekannten Klassen nach diesem Typ durchsuchen: String typName = t.getName(); @@ -306,7 +308,7 @@ public class TypeAssumptions { return ret; } } - throw new TypinferenzException("Der Typ "+t.getName()+" ist nicht korrekt"); + return null; } /** diff --git a/src/typinferenz/exceptions/ParserError.java b/src/typinferenz/exceptions/ParserError.java new file mode 100644 index 00000000..0a35447a --- /dev/null +++ b/src/typinferenz/exceptions/ParserError.java @@ -0,0 +1,12 @@ +package typinferenz.exceptions; + +import mycompiler.myparser.JavaParser.yyException; + + +public class ParserError extends TypeinferenceException{ + + public ParserError(yyException exc){ + super(exc.getMessage(), exc.token.getOffset()); + } + +} diff --git a/src/typinferenz/exceptions/ParserException.java b/src/typinferenz/exceptions/ParserException.java deleted file mode 100644 index 70102c11..00000000 --- a/src/typinferenz/exceptions/ParserException.java +++ /dev/null @@ -1,16 +0,0 @@ -package typinferenz.exceptions; - -import mycompiler.myparser.JavaParser.yyException; - - -public class ParserException extends TypinferenzException { - - public ParserException(String message) { - super(message); - } - - public ParserException(yyException exc){ - super("Parserfehler"); - } - -} diff --git a/src/typinferenz/exceptions/TypeinferenceException.java b/src/typinferenz/exceptions/TypeinferenceException.java new file mode 100755 index 00000000..67649600 --- /dev/null +++ b/src/typinferenz/exceptions/TypeinferenceException.java @@ -0,0 +1,31 @@ +package typinferenz.exceptions; + +import mycompiler.IItemWithOffset; + +/** + * Eine RuntimeException, welche bei einem Fehler während des Typinferenzalgorithmus ausgelöst wird. + * Dies wird zum Beispiel durch Programmierfehler in der Java-Eingabedatei ausgelöst. + * @author Andreas Stadelmeier, a10023 + * + */ +//TODO: Diese Klasse muss von Exception erben +public class TypeinferenceException extends RuntimeException { + + /** + * Das Offset im Quelltext bei dem das Problem aufgetaucht ist + */ + private int offset; + private String message; + + public TypeinferenceException(String message, IItemWithOffset problemSource) + { + super(message); + this.message=message; + this.offset=problemSource.getOffset(); + } + + public TypeinferenceException(String message, int offset){ + this.message=message; + } + +} diff --git a/src/typinferenz/exceptions/TypinferenzException.java b/src/typinferenz/exceptions/TypinferenzException.java deleted file mode 100755 index 0146c4be..00000000 --- a/src/typinferenz/exceptions/TypinferenzException.java +++ /dev/null @@ -1,13 +0,0 @@ -package typinferenz.exceptions; - -/** - * Eine RuntimeException, welche bei einem Fehler während des Typinferenzalgorithmus ausgelöst wird. - * Dies wird zum Beispiel durch Programmierfehler in der Java-Eingabedatei ausgelöst. - * @author Andreas Stadelmeier, a10023 - * - */ -public class TypinferenzException extends RuntimeException { - public TypinferenzException(String message){ - super(message); - } -} diff --git a/src/userinterface/ConsoleInterface.java b/src/userinterface/ConsoleInterface.java index 4e1c4360..b009508d 100755 --- a/src/userinterface/ConsoleInterface.java +++ b/src/userinterface/ConsoleInterface.java @@ -8,7 +8,7 @@ import java.util.Vector; import mycompiler.MyCompiler; import mycompiler.MyCompilerAPI; import mycompiler.mytypereconstruction.TypeinferenceResultSet; -import typinferenz.exceptions.TypinferenzException; +import typinferenz.exceptions.TypeinferenceException; import java.util.*; @@ -45,7 +45,7 @@ public class ConsoleInterface { ///////////////////////// try{ resultSet = compiler.typeReconstruction(); - }catch(TypinferenzException texc){ + }catch(TypeinferenceException texc){ texc.printStackTrace(); fail("Fehler bei Typinferenzalgorithmus. Message: "+texc.getMessage()); } diff --git a/test/plugindevelopment/TRMEqualTest.java b/test/plugindevelopment/TRMEqualTest.java index 4c173310..73ade1a3 100644 --- a/test/plugindevelopment/TRMEqualTest.java +++ b/test/plugindevelopment/TRMEqualTest.java @@ -110,6 +110,12 @@ class TestNode implements TypeInsertable{ ResultSet resultSet) { return new TypeInsertPoint(tph, this, resultSet.getTypeEqualTo(tph), resultSet); } + + @Override + public int getVariableLength() { + // TODO Auto-generated method stub + return 0; + } }