From 5d7f7ef546192453f60a09d07db5b6b09704065d Mon Sep 17 00:00:00 2001 From: ahmad Date: Sat, 11 May 2024 21:41:01 +0200 Subject: [PATCH 01/14] Update TypedClass --- .../typedast/typedclass/TypedClass.java | 34 ++++++++++++------- .../typedast/typedclass/TypedMethodCall.java | 2 +- 2 files changed, 22 insertions(+), 14 deletions(-) diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java index 626818b..832f135 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java @@ -32,16 +32,16 @@ public class TypedClass implements TypedNode { public TypedClass(Map localVar, Class c) { convertToTypedClass(localVar, c); } - public void enterMethod(TypedMethod method) { + public void enterCurrentMethod(TypedMethod method) { currentMethod = method; } - public void exitMethod() { + public void exitCurrentMethod() { currentMethod = null; } - public void enterConstructor(TypedConstructor constructor) { + public void enterCurrentConstructor(TypedConstructor constructor) { currentConstructor = constructor; } - public void exitConstructor() { + public void exitCurrentConstructor() { currentConstructor = null; } public boolean isCurrentMethodPresent() { @@ -80,19 +80,27 @@ public class TypedClass implements TypedNode { for (Declaration field : c.fieldDeclarations()) { typedFields.add(new TypedField(localVar, this, field)); } - - for (Constructor constructor : c.constructors()) { + for (Constructor constructor : c.constructors()){ typedConstructors.add(new TypedConstructor(localVar, this, constructor)); - enterConstructor(typedConstructors.get(typedConstructors.size() - 1)); - typedConstructors.get(typedConstructors.size() - 1).convertToBlock(localVar, this, constructor); - exitConstructor(); } - for (Method method : c.methods()) { typedMethods.add(new TypedMethod(localVar, this, method)); - enterMethod(typedMethods.get(typedMethods.size() - 1)); - typedMethods.get(typedMethods.size() - 1).convertToTypedBlock(localVar, this, method); - exitMethod(); + } + + int i = 0; + for (Constructor constructor : c.constructors()) { + enterCurrentConstructor(typedConstructors.get(i)); + typedConstructors.get(i).convertToBlock(localVar, this, constructor); + exitCurrentConstructor(); + i++; + } + + int j = 0; + for (Method method : c.methods()) { + enterCurrentMethod(typedMethods.get(j)); + typedMethods.get(j).convertToTypedBlock(localVar, this, method); + exitCurrentMethod(); + j++; } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java index 96dbf18..2bae2f9 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java @@ -32,7 +32,7 @@ public class TypedMethodCall implements TypedExpression, TypedStatement { @Override public Type typeCheck(Map localVar, TypedClass clas) { - //TODO: Implement typeCheck + return null; } From a05a4c8744f277210b791273d014fc783a95680f Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 11:19:31 +0200 Subject: [PATCH 02/14] renamed and refactored --- .../typedast/Help/TypedExpressionHelp.java | 2 +- .../typedast/typedclass/TypedAssignment.java | 19 ++++---- .../typedast/typedclass/TypedBinary.java | 28 ++++++----- .../typedast/typedclass/TypedBlock.java | 24 +++++----- .../typedast/typedclass/TypedBoolLiteral.java | 5 +- .../typedast/typedclass/TypedBreak.java | 2 +- .../typedast/typedclass/TypedCharLiteral.java | 7 ++- .../typedast/typedclass/TypedClass.java | 47 +++++++++---------- .../typedast/typedclass/TypedConstructor.java | 12 +++-- ...calVariable.java => TypedDeclaration.java} | 25 +++++----- .../typedast/typedclass/TypedDoWhile.java | 5 +- .../typedast/typedclass/TypedField.java | 12 ++--- .../typedclass/TypedFieldVarAccess.java | 23 +++++---- .../maishai/typedast/typedclass/TypedFor.java | 13 +++-- .../typedast/typedclass/TypedIfElse.java | 14 ++++-- .../typedast/typedclass/TypedIntLiteral.java | 2 + .../typedast/typedclass/TypedMethod.java | 30 ++++++------ .../typedast/typedclass/TypedMethodCall.java | 6 +-- .../maishai/typedast/typedclass/TypedNew.java | 8 +--- .../typedast/typedclass/TypedParameter.java | 25 ++++++---- .../typedast/typedclass/TypedReturn.java | 9 ++-- .../typedast/typedclass/TypedUnary.java | 20 ++++---- .../typedast/typedclass/TypedWhile.java | 12 ++--- 23 files changed, 193 insertions(+), 157 deletions(-) rename src/main/java/de/maishai/typedast/typedclass/{TypedLocalVariable.java => TypedDeclaration.java} (66%) diff --git a/src/main/java/de/maishai/typedast/Help/TypedExpressionHelp.java b/src/main/java/de/maishai/typedast/Help/TypedExpressionHelp.java index 8dad9b2..368c513 100644 --- a/src/main/java/de/maishai/typedast/Help/TypedExpressionHelp.java +++ b/src/main/java/de/maishai/typedast/Help/TypedExpressionHelp.java @@ -9,7 +9,7 @@ import java.util.Map; public class TypedExpressionHelp { - public static TypedExpression getKindOfExpression(Map localVar, TypedClass clas, Expression expression) { + public static TypedExpression convertExpression(Map localVar, TypedClass clas, Expression expression) { if (expression instanceof BoolLiteral boolLiteral) { TypedBoolLiteral typedBoolLiteral = new TypedBoolLiteral(localVar, clas, boolLiteral); typedBoolLiteral.typeCheck(localVar, clas); diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java index 3c5bfa1..6960010 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java @@ -1,6 +1,7 @@ package de.maishai.typedast.typedclass; import de.maishai.ast.records.Assignment; +import de.maishai.ast.records.Expression; import de.maishai.typedast.MethodContext; import de.maishai.typedast.TypedExpression; import de.maishai.typedast.TypedStatement; @@ -11,12 +12,13 @@ import org.objectweb.asm.Opcodes; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data public class TypedAssignment implements TypedStatement { private String varName; private TypedExpression value; + // private TypedExpression recursiveOwnerChain; private Type type; public TypedAssignment(Map localVar, TypedClass clas, Assignment untyped) { @@ -25,21 +27,22 @@ public class TypedAssignment implements TypedStatement { public void convertToTypedAssignment(Map localVar, TypedClass clas, Assignment untyped) { varName = untyped.location().id(); - value = getKindOfExpression(localVar, clas, untyped.value()); + value = convertExpression(localVar, clas, untyped.value()); + // recursiveOwnerChain = convertExpression(localVar, clas, untyped.location().recursiveOwnerChain()); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(Map localVar, TypedClass clas) { Type typeLeft = null; + if (!localVar.containsKey(varName)) { - if(clas.isThereField(varName)){ + if (clas.isThereField(varName)) { typeLeft = clas.getFieldType(varName); - }else if(clas.isParameterWitNameInMethod(varName)) { + } else if (clas.isParameterWitNameInMethod(varName)) { typeLeft = clas.getParameterTypeInCurrentMethod(varName); - }else if(clas.isParameterNameInCurrentConstructor(varName)) { + } else if (clas.isParameterNameInCurrentConstructor(varName)) { typeLeft = clas.getParameterTypeInCurrentConstructor(varName); - } - else{ + } else { throw new RuntimeException("Variable not declared"); } } else { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java b/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java index d8b493c..e882eea 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java @@ -11,7 +11,7 @@ import org.objectweb.asm.MethodVisitor; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data @NoArgsConstructor @@ -26,40 +26,44 @@ public class TypedBinary implements TypedExpression { } public void convertToTypedBinary(Map localVar, TypedClass clas, Binary unTypedBinary) { - left = getKindOfExpression(localVar, clas, unTypedBinary.left()); - right = getKindOfExpression(localVar, clas, unTypedBinary.right()); + left = convertExpression(localVar, clas, unTypedBinary.left()); + right = convertExpression(localVar, clas, unTypedBinary.right()); op = unTypedBinary.op(); } + @Override public Type typeCheck(Map localVar, TypedClass clas) { + Type leftType = left.typeCheck(localVar, clas); + Type rightType = right.typeCheck(localVar, clas); + if (op == Operator.ADD || op == Operator.SUB || op == Operator.MUL) { - if (left.typeCheck(localVar, clas) == Type.INT && - right.typeCheck(localVar, clas) == Type.INT) { + if (leftType == Type.INT && rightType == Type.INT) { type = Type.INT; return Type.INT; } else { throw new RuntimeException("Type mismatch in " + op); } - } else if (op == Operator.GT || op == Operator.LT || op == Operator.GE || op == Operator.LE || op == Operator.EQ || op == Operator.NE ) { - if (left.typeCheck(localVar, clas) == Type.INT && - right.typeCheck(localVar, clas) == Type.INT) { + } else if (op == Operator.GT || op == Operator.LT || op == Operator.GE || op == Operator.LE) { + if (leftType == Type.INT && rightType == Type.INT) { type = Type.BOOL; return Type.BOOL; } else { throw new RuntimeException("Type mismatch in " + op); } } else if (op == Operator.AND || op == Operator.OR) { - if (left.typeCheck(localVar, clas) == Type.BOOL && - right.typeCheck(localVar, clas) == Type.BOOL) { + if (leftType == Type.BOOL && rightType == Type.BOOL) { type = Type.BOOL; return Type.BOOL; } else { throw new RuntimeException("Type mismatch in " + op); } - } else { - throw new RuntimeException("Invalid operator"); } + if (leftType == rightType && leftType != Type.VOID) { + type = rightType; + return type; + } + throw new RuntimeException("Void can not be compared with Void"); } @Override diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java index 76708d1..24aee1a 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java @@ -1,7 +1,10 @@ package de.maishai.typedast.typedclass; import de.maishai.ast.records.*; -import de.maishai.typedast.*; +import de.maishai.typedast.MethodContext; +import de.maishai.typedast.Type; +import de.maishai.typedast.TypedNode; +import de.maishai.typedast.TypedStatement; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; @@ -15,28 +18,28 @@ import java.util.Map; @AllArgsConstructor @Data public class TypedBlock implements TypedNode { - private List vars = new ArrayList<>(); + private List vars = new ArrayList<>(); private List stmts = new ArrayList<>(); private Type type; - public TypedBlock(Map localVar, TypedClass clas, Block unTypedBlock) { convertToTypedBlock(localVar, clas, unTypedBlock); } - public TypedBlock(List vars, List stmts) { + + public TypedBlock(List vars, List stmts) { this.vars = vars; this.stmts = stmts; } public void convertToTypedBlock(Map localVar, TypedClass clas, Block unTypedBlock) { - if(unTypedBlock == null) { + if (unTypedBlock == null) { return; } for (Declaration var : unTypedBlock.localVariables()) { - TypedLocalVariable typedVar = new TypedLocalVariable(localVar, clas, var); + TypedDeclaration typedVar = new TypedDeclaration(localVar, clas, var); vars.add(typedVar); } @@ -85,9 +88,7 @@ public class TypedBlock implements TypedNode { } if (stmt instanceof Break) { - TypedBreak typedBreak = new TypedBreak(); - typedBreak.typeCheck(localVar, clas); - stmts.add(typedBreak); + stmts.add(new TypedBreak()); continue; } @@ -104,7 +105,7 @@ public class TypedBlock implements TypedNode { @Override public Type typeCheck(Map localVar, TypedClass clas) { - for (TypedLocalVariable var : vars) { + for (TypedDeclaration var : vars) { var.typeCheck(localVar, clas); } @@ -112,12 +113,13 @@ public class TypedBlock implements TypedNode { stmt.typeCheck(localVar, clas); } + //TODO: Type von Return zurückgeben type = Type.VOID; return type; } public void codeGen(MethodVisitor mv, MethodContext ctx) { - for (TypedLocalVariable var : vars) { + for (TypedDeclaration var : vars) { //var.codeGen(mv, ctx); } for (TypedStatement stmt : stmts) { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java b/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java index ae6a978..027a362 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java @@ -12,6 +12,7 @@ import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import java.util.Map; + @Data @NoArgsConstructor public class TypedBoolLiteral implements TypedExpression { @@ -36,9 +37,9 @@ public class TypedBoolLiteral implements TypedExpression { @Override public void codeGen(MethodVisitor mv, MethodContext ctx) { - if(value){ + if (value) { mv.visitInsn(Opcodes.ICONST_1); - }else{ + } else { mv.visitInsn(Opcodes.ICONST_0); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java b/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java index 64b6045..8e22ca0 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java @@ -10,6 +10,7 @@ import lombok.Data; import org.objectweb.asm.MethodVisitor; import java.util.Map; + @Data public class TypedBreak implements TypedStatement { private Type type = Type.VOID; @@ -19,7 +20,6 @@ public class TypedBreak implements TypedStatement { } @Override public Type typeCheck(Map localVar, TypedClass clas) { - type = Type.VOID; return type; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java b/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java index d4683d8..42e64c5 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java @@ -10,6 +10,7 @@ import lombok.Data; import org.objectweb.asm.MethodVisitor; import java.util.Map; + @Data public class TypedCharLiteral implements TypedExpression { private char value; @@ -18,10 +19,12 @@ public class TypedCharLiteral implements TypedExpression { public TypedCharLiteral(Map localVar, TypedClass clas, CharLiteral unTypedCharLiteral) { convertToCharLiteral(localVar, clas, unTypedCharLiteral); } + public void convertToCharLiteral(Map localVar, TypedClass clas, CharLiteral unTypedCharLiteral) { - value = unTypedCharLiteral.value(); - type = Type.CHAR; + value = unTypedCharLiteral.value(); + type = Type.CHAR; } + @Override public Type typeCheck(Map localVar, TypedClass clas) { return type; diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java index 832f135..060e819 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java @@ -32,24 +32,31 @@ public class TypedClass implements TypedNode { public TypedClass(Map localVar, Class c) { convertToTypedClass(localVar, c); } + public void enterCurrentMethod(TypedMethod method) { currentMethod = method; } + public void exitCurrentMethod() { currentMethod = null; } + public void enterCurrentConstructor(TypedConstructor constructor) { currentConstructor = constructor; } + public void exitCurrentConstructor() { currentConstructor = null; } + public boolean isCurrentMethodPresent() { return currentMethod != null; } + public boolean isCurrentConstructorPresent() { return currentConstructor != null; } + public boolean isParameterNameInCurrentMethod(String parameterName) { if (currentMethod == null) { return false; @@ -61,6 +68,7 @@ public class TypedClass implements TypedNode { } return false; } + public boolean isParameterNameInCurrentConstructor(String parameterName) { if (currentConstructor == null) { return false; @@ -80,13 +88,17 @@ public class TypedClass implements TypedNode { for (Declaration field : c.fieldDeclarations()) { typedFields.add(new TypedField(localVar, this, field)); } - for (Constructor constructor : c.constructors()){ + // Am Anfang werden die Konstruktoren und Methoden in die Listen eingefügt + // Methoden können verwendet werden, bevor deren Blöcke ausgeführt werden + for (Constructor constructor : c.constructors()) { typedConstructors.add(new TypedConstructor(localVar, this, constructor)); } + for (Method method : c.methods()) { typedMethods.add(new TypedMethod(localVar, this, method)); } + // Hier werden die Blöcke der Konstruktoren und Methoden ausgeführt int i = 0; for (Constructor constructor : c.constructors()) { enterCurrentConstructor(typedConstructors.get(i)); @@ -102,25 +114,13 @@ public class TypedClass implements TypedNode { exitCurrentMethod(); j++; } + + System.out.println("TypedClass: " + this.toString()); } @Override public Type typeCheck(Map localVar, TypedClass clas) { - - if (clas == null) { - throw new RuntimeException("Class not found"); - } - - for (TypedField field : typedFields) { - field.typeCheck(localVar, clas); - } - for (TypedConstructor constructor : typedConstructors) { - constructor.typeCheck(localVar, clas); - } - for (TypedMethod typedMethod : typedMethods) { - typedMethod.typeCheck(localVar, clas); - } - return Type.REFERENCE(className); + return type; } public TypedNode startConversion(Class c) { @@ -139,6 +139,7 @@ public class TypedClass implements TypedNode { } return false; } + public boolean isParameterWitNameInConstructor(String parameterName) { for (TypedConstructor c : typedConstructors) { for (TypedParameter p : c.getTypedParameters()) { @@ -160,6 +161,7 @@ public class TypedClass implements TypedNode { } return null; } + public Type getParameterTypeInCurrentConstructor(String parameterName) { for (TypedParameter p : currentConstructor.getTypedParameters()) { if (p.getParaName().equals(parameterName)) { @@ -170,28 +172,23 @@ public class TypedClass implements TypedNode { } public boolean isThereField(String fieldName) { - for (TypedField f : typedFields) { - if (f.getVarName().equals(getFieldNameWithOutThis(fieldName))) { + if (f.getVarName().equals(fieldName)) { return true; } } return false; } - private String getFieldNameWithOutThis(String fieldName) { - if(fieldName.startsWith("this.")){ - fieldName = fieldName.substring(5); - } - return fieldName; - } + public Type getFieldType(String fieldName) { for (TypedField f : typedFields) { - if (f.getVarName().equals(getFieldNameWithOutThis(fieldName))) { + if (f.getVarName().equals(fieldName)) { return f.getType(); } } return null; } + public Type getMethodType(String methodName) { for (TypedMethod m : typedMethods) { if (m.getName().equals(methodName)) { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java index 0634ec5..cb2c140 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java @@ -26,11 +26,13 @@ public class TypedConstructor implements TypedNode { private List typedParameters = new ArrayList<>(); private TypedBlock typedBlock; private Type type; + public TypedConstructor(String name, List typedParameters, TypedBlock typedBlock) { this.name = name; this.typedParameters = typedParameters; this.typedBlock = typedBlock; } + public TypedConstructor(Map localVar, TypedClass clas, Constructor unTypedConstructor) { convertToTypedConstructor(localVar, clas, unTypedConstructor); } @@ -41,16 +43,16 @@ public class TypedConstructor implements TypedNode { for (Parameter param : unTypedConstructor.params()) { typedParameters.add(new TypedParameter(localVar, clas, param)); } - // Konstrukteur hat den Rückgabetyp wie der Klassenname, obwohl es keinen expliziten Rückgabetyp gibt - type = clas.getType(); - + type = Type.VOID; } + public void convertToBlock(Map localVar, TypedClass clas, Constructor unTypedConstructor) { - this.typedBlock = new TypedBlock(localVar, clas ,unTypedConstructor.block()); + this.typedBlock = new TypedBlock(localVar, clas, unTypedConstructor.block()); } @Override public Type typeCheck(Map localVar, TypedClass clas) { + //TODO: check if return is there return type; } @@ -69,6 +71,6 @@ public class TypedConstructor implements TypedNode { mv.visitInsn(Opcodes.RETURN); - context.wrapUp(0,0); + context.wrapUp(0, 0); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java b/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java similarity index 66% rename from src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java rename to src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java index 1a8af9c..8ba500b 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java @@ -1,7 +1,6 @@ package de.maishai.typedast.typedclass; import de.maishai.ast.records.Declaration; -import de.maishai.ast.records.Node; import de.maishai.typedast.MethodContext; import de.maishai.typedast.TypedNode; import de.maishai.typedast.Type; @@ -11,32 +10,34 @@ import lombok.NoArgsConstructor; import org.objectweb.asm.MethodVisitor; import java.util.Map; + @Data @AllArgsConstructor @NoArgsConstructor -public final class TypedLocalVariable implements TypedNode { +public final class TypedDeclaration implements TypedNode { private String name; private Type type; - public TypedLocalVariable(Map localVar, TypedClass clas, Declaration declaration){ + public TypedDeclaration(Map localVar, TypedClass clas, Declaration declaration) { convertToTypedLocalVariable(localVar, clas, declaration); } - public void convertToTypedLocalVariable(Map localVar, TypedClass clas, Declaration declaration){ - if(localVar.containsKey(declaration.name())){ + + public void convertToTypedLocalVariable(Map localVar, TypedClass clas, Declaration declaration) { + if (localVar.containsKey(declaration.name())) { throw new RuntimeException("Variable " + declaration.name() + " already declared"); } - this.setName(declaration.name()); - this.setType(declaration.type()); + name = declaration.name(); + type = declaration.type(); localVar.put(this.name, this.type); } @Override public Type typeCheck(Map localVar, TypedClass clas) { - Type type = localVar.get(name); - if(type == this.type) { - return type; - } - throw new RuntimeException("type of left not equals with type of right"); + Type type = localVar.get(name); + if (type == this.type) { + return type; + } + throw new RuntimeException("type of left not equals with type of right"); } public void codeGen(MethodVisitor mv, MethodContext ctx) { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java b/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java index d04f5fe..5590261 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java @@ -7,7 +7,7 @@ import org.objectweb.asm.MethodVisitor; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data public class TypedDoWhile implements TypedStatement { @@ -18,9 +18,10 @@ public class TypedDoWhile implements TypedStatement { public TypedDoWhile(Map localVar, TypedClass clas, DoWhile unTypedDoWhile) { convertToTypedDoWhile(localVar, clas, unTypedDoWhile); } + public void convertToTypedDoWhile(Map localVar, TypedClass clas, DoWhile unTypedDoWhile) { typedBlock = new TypedBlock(localVar, clas, unTypedDoWhile.block()); - cond = getKindOfExpression(localVar, clas, unTypedDoWhile.cond()); + cond = convertExpression(localVar, clas, unTypedDoWhile.cond()); } @Override diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedField.java b/src/main/java/de/maishai/typedast/typedclass/TypedField.java index 7ff2ce0..b607f23 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedField.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedField.java @@ -21,12 +21,12 @@ public class TypedField implements TypedNode { private String varName; private Type type; - public TypedField(Map localVar, TypedClass clas, Declaration declaration){ + //TODO: remove TypedField + public TypedField(Map localVar, TypedClass clas, Declaration declaration) { convertToTypedField(localVar, clas, declaration); } - public void convertToTypedField(Map localVar, TypedClass clas, Declaration declaration){ - + public void convertToTypedField(Map localVar, TypedClass clas, Declaration declaration) { this.type = declaration.type(); varName = declaration.name(); this.typeCheck(localVar, clas); @@ -35,11 +35,11 @@ public class TypedField implements TypedNode { @Override public Type typeCheck(Map localVar, TypedClass clas) { - if(clas.isThereField(varName)){ + if (clas.isThereField(varName)) { throw new RuntimeException("Field " + varName + " already declared"); } - if(type.getKind() == REFERENCE){ - if(!type.getReference().equals(clas.getClassName())){ + if (type.getKind() == REFERENCE) { + if (!type.getReference().equals(clas.getClassName())) { throw new RuntimeException("Field " + varName + " has wrong type"); } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java b/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java index 0b2d9fe..fa04377 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java @@ -10,7 +10,7 @@ import org.objectweb.asm.MethodVisitor; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data @NoArgsConstructor @@ -23,40 +23,43 @@ public class TypedFieldVarAccess implements TypedExpression { public TypedFieldVarAccess(Map localVar, TypedClass clas, FieldVarAccess unTypedFieldVarAccess) { convertToTypedFieldVarAccess(localVar, clas, unTypedFieldVarAccess); } + public void convertToTypedFieldVarAccess(Map localVar, TypedClass clas, FieldVarAccess unTypedFieldVarAccess) { field = unTypedFieldVarAccess.field(); - recursiveOwnerChain = getKindOfExpression(localVar, clas, unTypedFieldVarAccess.recursiveOwnerChain()); + recursiveOwnerChain = convertExpression(localVar, clas, unTypedFieldVarAccess.recursiveOwnerChain()); name = unTypedFieldVarAccess.id(); } @Override public Type typeCheck(Map localVar, TypedClass clas) { - if(field){ + if (field) { if (clas.isThereField(name)) { type = clas.getFieldType(name); return clas.getFieldType(name); } - }else{ + } else { + if (clas.isThereField(name)) { type = clas.getFieldType(name); return clas.getFieldType(name); - }else if(clas.isCurrentConstructorPresent()){ - if(clas.isParameterNameInCurrentConstructor(name)){ + } else if (clas.isCurrentConstructorPresent()) { + if (clas.isParameterNameInCurrentConstructor(name)) { type = clas.getParameterTypeInCurrentConstructor(name); return clas.getParameterTypeInCurrentConstructor(name); } - }else if(clas.isCurrentMethodPresent()){ - if(clas.isParameterWitNameInMethod(name)){ + } else if (clas.isCurrentMethodPresent()) { + if (clas.isParameterWitNameInMethod(name)) { type = clas.getParameterTypeInCurrentMethod(name); return clas.getParameterTypeInCurrentMethod(name); } } - if(localVar.containsKey(name)) { + if (localVar.containsKey(name)) { type = localVar.get(name); return localVar.get(name); } } - throw new RuntimeException("Variable "+name+" not declared "); + + throw new RuntimeException("Variable " + name + " not declared "); } @Override diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedFor.java b/src/main/java/de/maishai/typedast/typedclass/TypedFor.java index f474b1f..0d6957c 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedFor.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedFor.java @@ -9,7 +9,7 @@ import org.objectweb.asm.MethodVisitor; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data @AllArgsConstructor @@ -19,14 +19,16 @@ public class TypedFor implements TypedStatement { private TypedExpression cond; private TypedAssignment inc; private TypedBlock typedBlock; - //TODO: add Type + //TODO: type of block in for loop + private Type type; public TypedFor(Map localVar, TypedClass clas, For unTypedFor) { convertToTypedFor(localVar, clas, unTypedFor); } - public void convertToTypedFor(Map localVar,TypedClass clas, For unTypedFor) { + + public void convertToTypedFor(Map localVar, TypedClass clas, For unTypedFor) { assign = new TypedAssignment(localVar, clas, unTypedFor.assign()); - cond = getKindOfExpression(localVar, clas, unTypedFor.cond()); + cond = convertExpression(localVar, clas, unTypedFor.cond()); inc = new TypedAssignment(localVar, clas, unTypedFor.inc()); typedBlock = new TypedBlock(localVar, clas, unTypedFor.block()); } @@ -38,7 +40,8 @@ public class TypedFor implements TypedStatement { throw new RuntimeException("Condition must be a boolean"); } inc.typeCheck(localVar, clas); - return typedBlock.typeCheck(localVar, clas); + type = typedBlock.typeCheck(localVar, clas); + return type; } @Override diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java b/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java index 793c629..d17867b 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java @@ -10,7 +10,7 @@ import org.objectweb.asm.Opcodes; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data @NoArgsConstructor @@ -19,14 +19,16 @@ public class TypedIfElse implements TypedStatement { private TypedBlock ifTypedBlock; private TypedBlock elseTypedBlock; //TODO: add Type + private Type type; public TypedIfElse(Map localVar, TypedClass clas, IfElse unTypedIfElse) { convertToTypedIfElse(localVar, clas, unTypedIfElse); } + public void convertToTypedIfElse(Map localVar, TypedClass clas, IfElse unTypedIfElse) { ifTypedBlock = new TypedBlock(localVar, clas, unTypedIfElse.ifBlock()); elseTypedBlock = new TypedBlock(localVar, clas, unTypedIfElse.elseBlock()); - typedCon = getKindOfExpression(localVar, clas, unTypedIfElse.cond()); + typedCon = convertExpression(localVar, clas, unTypedIfElse.cond()); } @Override @@ -38,7 +40,13 @@ public class TypedIfElse implements TypedStatement { if (ifTypedBlock.typeCheck(localVar, clas) != Type.VOID) { throw new RuntimeException("If block must be of type void"); } - return Type.VOID; + + //TODO: catch all cases of return when one method has a return type + if (ifTypedBlock.typeCheck(localVar, clas) == elseTypedBlock.typeCheck(localVar, clas)) { + type = ifTypedBlock.typeCheck(localVar, clas); + } + + return type; } @Override diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java b/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java index 8b19937..33bf693 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java @@ -23,6 +23,7 @@ public class TypedIntLiteral implements TypedExpression { public TypedIntLiteral(Map localVar, TypedClass clas, IntLiteral unTypedIntLiteral) { convertToTypedIntLiteral(localVar, clas, unTypedIntLiteral); } + public void convertToTypedIntLiteral(Map localVar, TypedClass clas, IntLiteral unTypedIntLiteral) { value = unTypedIntLiteral.value(); type = Type.INT; @@ -32,6 +33,7 @@ public class TypedIntLiteral implements TypedExpression { public Type typeCheck(Map localVar, TypedClass clas) { return type; } + public TypedIntLiteral(Integer value) { this.value = value; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java index 16fa165..50fba3c 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java @@ -21,33 +21,35 @@ public class TypedMethod implements TypedNode { private Type returnType; private List typedParameters = new ArrayList<>(); private TypedBlock typedBlock; + //private List localVariables = new ArrayList<>(); public TypedMethod(Map localVar, TypedClass clas, Method unTypedMethod) { convertToTypedMethod(localVar, clas, unTypedMethod); } + @Override + public boolean equals(Object obj) { + if (obj instanceof TypedMethod) { + TypedMethod other = (TypedMethod) obj; + return name.equals(other.name) && returnType.equals(other.returnType) && typedParameters.equals(other.typedParameters); + } + return false; + } + public void convertToTypedMethod(Map localVar, TypedClass clas, Method unTypedMethod) { name = unTypedMethod.methodName(); returnType = unTypedMethod.type(); - for (Parameter parameter : unTypedMethod.params()) { + for (var parameter : unTypedMethod.params()) { typedParameters.add(new TypedParameter(localVar, clas, parameter)); } - for (var method : clas.getTypedMethods()) { - if (method.getName().equals(name) && method.getTypedParameters().size() == typedParameters.size() - && method.getReturnType().equals(returnType)) { - for (int i = 0; i < method.getTypedParameters().size(); i++){ - if(method.getTypedParameters().get(i).getType().equals(typedParameters.get(i).getType())){ - throw new RuntimeException("Method " + name + " already exists"); - } - } - - if (method.getTypedParameters().isEmpty() && typedParameters.isEmpty()) { + clas.getTypedMethods().stream().filter(method -> method.equals(this)).findFirst().ifPresentOrElse( + method -> { throw new RuntimeException("Method " + name + " already exists"); - } - } - } + }, () -> { + }); + localVar.put(name, returnType); } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java index 2bae2f9..3969a2f 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java @@ -10,7 +10,7 @@ import org.objectweb.asm.MethodVisitor; import java.util.List; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data @NoArgsConstructor @@ -26,13 +26,13 @@ public class TypedMethodCall implements TypedExpression, TypedStatement { public void convertToTypedMethodCall(Map localVar, TypedClass clas, MethodCall unTypedMethodCall) { recipient = new TypedFieldVarAccess(localVar, clas, unTypedMethodCall.recipient()); for (Expression arg : unTypedMethodCall.args()) { - args.add(getKindOfExpression(localVar, clas, arg)); + args.add(convertExpression(localVar, clas, arg)); } } @Override public Type typeCheck(Map localVar, TypedClass clas) { - + //TODO: implement this return null; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedNew.java b/src/main/java/de/maishai/typedast/typedclass/TypedNew.java index 8ace078..d60509e 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedNew.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedNew.java @@ -10,7 +10,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data public class TypedNew implements TypedExpression, TypedStatement { @@ -23,16 +23,12 @@ public class TypedNew implements TypedExpression, TypedStatement { public void convertToTypedNew(Map localVar, TypedClass clas, New unTypedNew) { type = unTypedNew.type(); for (Expression arg : unTypedNew.args()) { - args.add(getKindOfExpression(localVar, clas, arg)); + args.add(convertExpression(localVar, clas, arg)); } } @Override public Type typeCheck(Map localVar, TypedClass clas) { - if(clas == null){ - throw new RuntimeException("Class not found"); - } - for(var constructor : clas.getTypedConstructors()){ if(constructor.getTypedParameters().size() == args.size()){ boolean valid = true; diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedParameter.java b/src/main/java/de/maishai/typedast/typedclass/TypedParameter.java index 58350d4..d5fbbfb 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedParameter.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedParameter.java @@ -1,17 +1,14 @@ package de.maishai.typedast.typedclass; -import de.maishai.ast.records.Node; import de.maishai.ast.records.Parameter; -import de.maishai.typedast.TypedNode; import de.maishai.typedast.Type; +import de.maishai.typedast.TypedNode; import lombok.AllArgsConstructor; import lombok.Data; -import lombok.RequiredArgsConstructor; import java.util.Map; @AllArgsConstructor -@RequiredArgsConstructor @Data public class TypedParameter implements TypedNode { private String paraName; @@ -20,22 +17,31 @@ public class TypedParameter implements TypedNode { public TypedParameter(Map localVar, TypedClass clas, Parameter unTypedParameter) { convertToTypedParameter(localVar, clas, unTypedParameter); } + public void convertToTypedParameter(Map localVar, TypedClass clas, Parameter unTypedParameter) { paraName = unTypedParameter.name(); type = unTypedParameter.type(); - //localVar.put(paraName, type); + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof TypedParameter) { + TypedParameter other = (TypedParameter) obj; + return paraName.equals(other.paraName) && type.equals(other.type); + } + return false; } @Override public Type typeCheck(Map localVar, TypedClass clas) { - if(clas.isCurrentMethodPresent()){ - if(clas.isParameterWitNameInMethod(paraName)) { + if (clas.isCurrentMethodPresent()) { + if (clas.isParameterWitNameInMethod(paraName)) { throw new RuntimeException("Parameter " + paraName + " already exists"); } - }else if(clas.isCurrentConstructorPresent()){ - if(clas.isParameterWitNameInConstructor(paraName)) { + } else if (clas.isCurrentConstructorPresent()) { + if (clas.isParameterWitNameInConstructor(paraName)) { throw new RuntimeException("Parameter " + paraName + " already exists"); } } @@ -44,5 +50,4 @@ public class TypedParameter implements TypedNode { } - } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java b/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java index e960d99..053c3e5 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java @@ -10,7 +10,7 @@ import org.objectweb.asm.Opcodes; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data @NoArgsConstructor @@ -21,15 +21,16 @@ public class TypedReturn implements TypedStatement { public TypedReturn(Map localVar, TypedClass clas, Return unTypedReturn) { convertToTypedReturn(localVar, clas, unTypedReturn); } + public void convertToTypedReturn(Map localVar, TypedClass clas, Return unTypedReturn) { - ret = getKindOfExpression(localVar, clas, unTypedReturn.ret()); + ret = convertExpression(localVar, clas, unTypedReturn.ret()); type = ret.getType(); } @Override public Type typeCheck(Map localVar, TypedClass clas) { - if(clas.isCurrentMethodPresent()){ - if(clas.getCurrentMethod().getReturnType().getKind() != this.type.getKind()){ + if (clas.isCurrentMethodPresent()) { + if (clas.getCurrentMethod().getReturnType().getKind() != this.type.getKind()) { StringBuilder exp = new StringBuilder(); exp.append("\nMismatched return type: "); exp.append("\nExpected: ").append(clas.getCurrentMethod().getReturnType().getKind()); diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java b/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java index 4f82630..f69d043 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java @@ -11,7 +11,7 @@ import org.objectweb.asm.Opcodes; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data public class TypedUnary implements TypedExpression { @@ -19,25 +19,27 @@ public class TypedUnary implements TypedExpression { private TypedExpression right; private Type type; - public TypedUnary(Map localVar, TypedClass clas, Unary unTypedUnary){ + public TypedUnary(Map localVar, TypedClass clas, Unary unTypedUnary) { convertToTypedUnary(localVar, clas, unTypedUnary); } + public void convertToTypedUnary(Map localVar, TypedClass clas, Unary unTypedUnary) { op = unTypedUnary.op(); - right = getKindOfExpression(localVar, clas, unTypedUnary.right()); + right = convertExpression(localVar, clas, unTypedUnary.right()); } + @Override public Type typeCheck(Map localVar, TypedClass clas) { - if(op == UnaryOperator.NOT){ - if(right.typeCheck(localVar, clas) != Type.BOOL){ + if (op == UnaryOperator.NOT) { + if (right.typeCheck(localVar, clas) != Type.BOOL) { throw new RuntimeException("Not operator must be applied to boolean"); } return Type.BOOL; } - if(op == UnaryOperator.SUB){ - if(right.typeCheck(localVar, clas) != Type.INT){ + if (op == UnaryOperator.SUB) { + if (right.typeCheck(localVar, clas) != Type.INT) { throw new RuntimeException("Minus operator must be applied to int"); } return Type.INT; @@ -48,11 +50,11 @@ public class TypedUnary implements TypedExpression { @Override public void codeGen(MethodVisitor mv, MethodContext ctx) { right.codeGen(mv, ctx); - if(op == UnaryOperator.NOT){ + if (op == UnaryOperator.NOT) { mv.visitInsn(Opcodes.ICONST_1); mv.visitInsn(Opcodes.IXOR); } - if(op == UnaryOperator.SUB){ + if (op == UnaryOperator.SUB) { mv.visitInsn(Opcodes.INEG); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java b/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java index 291445d..4fcd915 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java @@ -7,7 +7,7 @@ import org.objectweb.asm.MethodVisitor; import java.util.Map; -import static de.maishai.typedast.Help.TypedExpressionHelp.getKindOfExpression; +import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data public class TypedWhile implements TypedStatement { @@ -20,17 +20,17 @@ public class TypedWhile implements TypedStatement { } public void convertToTypedWhile(Map localVar, TypedClass clas, While unTypedWhile) { - cond = getKindOfExpression(localVar, clas, unTypedWhile.cond()); + cond = convertExpression(localVar, clas, unTypedWhile.cond()); typedBlock = new TypedBlock(localVar, clas, unTypedWhile.block()); } + @Override public Type typeCheck(Map localVar, TypedClass clas) { - if(cond.typeCheck(localVar, clas) != Type.BOOL){ + if (cond.typeCheck(localVar, clas) != Type.BOOL) { throw new RuntimeException("While condition must be a boolean"); } - typedBlock.typeCheck(localVar, clas); - this.type = Type.VOID; - return Type.BOOL; + type = typedBlock.typeCheck(localVar, clas); + return type; } From 938e92f679ebf436295dfbc1de6471b8de598bed Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 11:33:15 +0200 Subject: [PATCH 03/14] Removed the TypedField class and use instand of that teh TypedDeclaration --- .../typedast/typedclass/TypedBlock.java | 4 +- .../typedast/typedclass/TypedClass.java | 25 ++++----- .../typedast/typedclass/TypedConstructor.java | 1 + .../typedast/typedclass/TypedDeclaration.java | 28 ++++++++-- .../typedast/typedclass/TypedField.java | 55 ------------------- 5 files changed, 37 insertions(+), 76 deletions(-) delete mode 100644 src/main/java/de/maishai/typedast/typedclass/TypedField.java diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java index 24aee1a..e77c7e4 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java @@ -37,11 +37,11 @@ public class TypedBlock implements TypedNode { if (unTypedBlock == null) { return; } - + /* for (Declaration var : unTypedBlock.localVariables()) { TypedDeclaration typedVar = new TypedDeclaration(localVar, clas, var); vars.add(typedVar); - } + } */ for (var stmt : unTypedBlock.stmts()) { if (stmt instanceof Assignment assignment) { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java index 060e819..247fd15 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java @@ -22,7 +22,7 @@ import java.util.Map; @NoArgsConstructor public class TypedClass implements TypedNode { private String className; - private List typedFields = new ArrayList<>(); + private List typedDeclarations = new ArrayList<>(); private List typedMethods = new ArrayList<>(); private List typedConstructors = new ArrayList<>(); private TypedMethod currentMethod; @@ -85,8 +85,8 @@ public class TypedClass implements TypedNode { className = c.classname(); type = Type.REFERENCE(className); - for (Declaration field : c.fieldDeclarations()) { - typedFields.add(new TypedField(localVar, this, field)); + for (Declaration declaration : c.fieldDeclarations()) { + typedDeclarations.add(new TypedDeclaration(localVar, this, declaration)); } // Am Anfang werden die Konstruktoren und Methoden in die Listen eingefügt // Methoden können verwendet werden, bevor deren Blöcke ausgeführt werden @@ -115,7 +115,6 @@ public class TypedClass implements TypedNode { j++; } - System.out.println("TypedClass: " + this.toString()); } @Override @@ -172,8 +171,8 @@ public class TypedClass implements TypedNode { } public boolean isThereField(String fieldName) { - for (TypedField f : typedFields) { - if (f.getVarName().equals(fieldName)) { + for (TypedDeclaration f : typedDeclarations) { + if (f.getName().equals(fieldName)) { return true; } } @@ -181,8 +180,8 @@ public class TypedClass implements TypedNode { } public Type getFieldType(String fieldName) { - for (TypedField f : typedFields) { - if (f.getVarName().equals(fieldName)) { + for (TypedDeclaration f : typedDeclarations) { + if (f.getName().equals(fieldName)) { return f.getType(); } } @@ -202,8 +201,8 @@ public class TypedClass implements TypedNode { public byte[] codeGen() { ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS); cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", null); - for (TypedField field : typedFields) { - field.codeGen(cw); + for (TypedDeclaration declaration : typedDeclarations) { + declaration.codeGen(cw); } for (TypedConstructor constructor : typedConstructors) { @@ -223,9 +222,9 @@ public class TypedClass implements TypedNode { c.setClassName("SomeClass"); //Fields - TypedField f1 = new TypedField("someNumber", Type.INT); - TypedField f2 = new TypedField("someChar", Type.CHAR); - c.typedFields = List.of(f1, f2); + TypedDeclaration f1 = new TypedDeclaration("someNumber", Type.INT); + TypedDeclaration f2 = new TypedDeclaration("someChar", Type.CHAR); + c.typedDeclarations = List.of(f1, f2); //Constructors TypedConstructor constructor = new TypedConstructor("SomeClass", List.of(new TypedParameter("test", Type.INT)), new TypedBlock(new ArrayList<>(), new ArrayList<>())); diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java index cb2c140..fbf868f 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java @@ -73,4 +73,5 @@ public class TypedConstructor implements TypedNode { context.wrapUp(0, 0); } + } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java b/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java index 8ba500b..b33175e 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java @@ -7,10 +7,14 @@ import de.maishai.typedast.Type; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; +import org.objectweb.asm.ClassWriter; import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; import java.util.Map; +import static de.maishai.typedast.Type.Kind.REFERENCE; + @Data @AllArgsConstructor @NoArgsConstructor @@ -28,22 +32,34 @@ public final class TypedDeclaration implements TypedNode { } name = declaration.name(); type = declaration.type(); - localVar.put(this.name, this.type); + //localVar.put(this.name, this.type); } @Override public Type typeCheck(Map localVar, TypedClass clas) { - Type type = localVar.get(name); - if (type == this.type) { - return type; + if (clas.isThereField(name)) { + throw new RuntimeException("Field " + name + " already declared"); } - throw new RuntimeException("type of left not equals with type of right"); + + if (type.getKind() == REFERENCE) { + if (!type.getReference().equals(clas.getClassName())) { + throw new RuntimeException("Field " + name + " has wrong type"); + } + + } + + return type; } + /* public void codeGen(MethodVisitor mv, MethodContext ctx) { System.out.println("Generating code for local variable " + name); int index = ctx.addVariable(name); mv.visitLocalVariable(name, type.getDescriptor(), null, ctx.getStartLabel(), ctx.getEndLabel(), index); - + } + */ + public void codeGen(ClassWriter cw) { + int access = Opcodes.ACC_PUBLIC; // laut Andi ist es ok, dass alle Felder public sind + cw.visitField(access, name, type.getDescriptor(), null, null).visitEnd(); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedField.java b/src/main/java/de/maishai/typedast/typedclass/TypedField.java deleted file mode 100644 index b607f23..0000000 --- a/src/main/java/de/maishai/typedast/typedclass/TypedField.java +++ /dev/null @@ -1,55 +0,0 @@ -package de.maishai.typedast.typedclass; - -import de.maishai.ast.records.Declaration; -import de.maishai.ast.records.Node; -import de.maishai.typedast.TypedNode; -import de.maishai.typedast.Type; -import lombok.AllArgsConstructor; -import lombok.Data; -import lombok.RequiredArgsConstructor; -import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.Opcodes; - -import java.util.Map; - -import static de.maishai.typedast.Type.Kind.REFERENCE; - -@AllArgsConstructor -@RequiredArgsConstructor -@Data -public class TypedField implements TypedNode { - private String varName; - private Type type; - - //TODO: remove TypedField - public TypedField(Map localVar, TypedClass clas, Declaration declaration) { - convertToTypedField(localVar, clas, declaration); - } - - public void convertToTypedField(Map localVar, TypedClass clas, Declaration declaration) { - this.type = declaration.type(); - varName = declaration.name(); - this.typeCheck(localVar, clas); - } - - @Override - public Type typeCheck(Map localVar, TypedClass clas) { - - if (clas.isThereField(varName)) { - throw new RuntimeException("Field " + varName + " already declared"); - } - if (type.getKind() == REFERENCE) { - if (!type.getReference().equals(clas.getClassName())) { - throw new RuntimeException("Field " + varName + " has wrong type"); - } - - } - - return type; - } - - public void codeGen(ClassWriter cw) { - int access = Opcodes.ACC_PUBLIC; // laut Andi ist es ok, dass alle Felder public sind - cw.visitField(access, varName, type.getDescriptor(), null, null).visitEnd(); - } -} From 827b5551f411572509b7454e7ed8d0c66f5f1374 Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 12:45:22 +0200 Subject: [PATCH 04/14] Add TypedLocalVariable and integrate it to Constractur and Methods --- .../typedast/typedclass/TypedAssignment.java | 31 +++++---- .../typedast/typedclass/TypedBlock.java | 17 ++--- .../typedast/typedclass/TypedConstructor.java | 16 +++++ .../typedast/typedclass/TypedDeclaration.java | 6 +- .../typedclass/TypedLocalVariable.java | 63 +++++++++++++++++++ .../typedast/typedclass/TypedMethod.java | 33 +++++++--- 6 files changed, 129 insertions(+), 37 deletions(-) create mode 100644 src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java index 6960010..fed0d27 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java @@ -18,7 +18,7 @@ import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; public class TypedAssignment implements TypedStatement { private String varName; private TypedExpression value; - // private TypedExpression recursiveOwnerChain; + // private TypedExpression recursiveOwnerChain; private Type type; public TypedAssignment(Map localVar, TypedClass clas, Assignment untyped) { @@ -28,25 +28,30 @@ public class TypedAssignment implements TypedStatement { public void convertToTypedAssignment(Map localVar, TypedClass clas, Assignment untyped) { varName = untyped.location().id(); value = convertExpression(localVar, clas, untyped.value()); - // recursiveOwnerChain = convertExpression(localVar, clas, untyped.location().recursiveOwnerChain()); + // recursiveOwnerChain = convertExpression(localVar, clas, untyped.location().recursiveOwnerChain()); } @Override public Type typeCheck(Map localVar, TypedClass clas) { Type typeLeft = null; - if (!localVar.containsKey(varName)) { - if (clas.isThereField(varName)) { - typeLeft = clas.getFieldType(varName); - } else if (clas.isParameterWitNameInMethod(varName)) { - typeLeft = clas.getParameterTypeInCurrentMethod(varName); - } else if (clas.isParameterNameInCurrentConstructor(varName)) { - typeLeft = clas.getParameterTypeInCurrentConstructor(varName); - } else { - throw new RuntimeException("Variable not declared"); - } + if (clas.isThereField(varName)) { + typeLeft = clas.getFieldType(varName); } else { - typeLeft = localVar.get(varName); + if (clas.isCurrentMethodPresent() && !clas.isCurrentConstructorPresent()) { + if (clas.getCurrentMethod().isLocalVariableInMethod(varName)) { + typeLeft = clas.getCurrentMethod().getLocalVariableType(varName); + } else { + throw new RuntimeException("Variable " + varName + " not declared in method"); + } + } + if (!clas.isCurrentMethodPresent() && clas.isCurrentConstructorPresent()) { + if (clas.getCurrentConstructor().isLocalVariableInConstructor(varName)) { + typeLeft = clas.getCurrentConstructor().getLocalVariableType(varName); + } else { + throw new RuntimeException("Variable " + varName + " not declared in constructor"); + } + } } Type typeRight = value.typeCheck(localVar, clas); diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java index e77c7e4..c1eeaf3 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java @@ -18,7 +18,7 @@ import java.util.Map; @AllArgsConstructor @Data public class TypedBlock implements TypedNode { - private List vars = new ArrayList<>(); + private List vars = new ArrayList<>(); private List stmts = new ArrayList<>(); private Type type; @@ -27,7 +27,7 @@ public class TypedBlock implements TypedNode { convertToTypedBlock(localVar, clas, unTypedBlock); } - public TypedBlock(List vars, List stmts) { + public TypedBlock(List vars, List stmts) { this.vars = vars; this.stmts = stmts; } @@ -37,11 +37,10 @@ public class TypedBlock implements TypedNode { if (unTypedBlock == null) { return; } - /* + for (Declaration var : unTypedBlock.localVariables()) { - TypedDeclaration typedVar = new TypedDeclaration(localVar, clas, var); - vars.add(typedVar); - } */ + vars.add(new TypedLocalVariable(localVar, clas, var)); + } for (var stmt : unTypedBlock.stmts()) { if (stmt instanceof Assignment assignment) { @@ -105,10 +104,6 @@ public class TypedBlock implements TypedNode { @Override public Type typeCheck(Map localVar, TypedClass clas) { - for (TypedDeclaration var : vars) { - var.typeCheck(localVar, clas); - } - for (TypedStatement stmt : stmts) { stmt.typeCheck(localVar, clas); } @@ -119,7 +114,7 @@ public class TypedBlock implements TypedNode { } public void codeGen(MethodVisitor mv, MethodContext ctx) { - for (TypedDeclaration var : vars) { + for (TypedLocalVariable var : vars) { //var.codeGen(mv, ctx); } for (TypedStatement stmt : stmts) { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java index fbf868f..4ef748d 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java @@ -26,6 +26,7 @@ public class TypedConstructor implements TypedNode { private List typedParameters = new ArrayList<>(); private TypedBlock typedBlock; private Type type; + private List localVariables = new ArrayList<>(); public TypedConstructor(String name, List typedParameters, TypedBlock typedBlock) { this.name = name; @@ -37,6 +38,21 @@ public class TypedConstructor implements TypedNode { convertToTypedConstructor(localVar, clas, unTypedConstructor); } + public boolean isLocalVariablePresent(String localVarName) { + return localVariables.stream().anyMatch(localVariable -> localVariable.getName().equals(localVarName)); + } + + public boolean isParameterPresent(String parameterName) { + return typedParameters.stream().anyMatch(parameter -> parameter.getParaName().equals(parameterName)); + } + + public boolean isLocalVariableInConstructor(String localVarName) { + return isLocalVariablePresent(localVarName) || isParameterPresent(localVarName); + } + public Type getLocalVariableType(String localVarName) { + return localVariables.stream().filter(localVariable -> localVariable.getName().equals(localVarName)).findFirst().get().getType(); + } + public void convertToTypedConstructor(Map localVar, TypedClass clas, Constructor unTypedConstructor) { name = unTypedConstructor.className(); diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java b/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java index b33175e..31948ff 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java @@ -23,16 +23,16 @@ public final class TypedDeclaration implements TypedNode { private Type type; public TypedDeclaration(Map localVar, TypedClass clas, Declaration declaration) { - convertToTypedLocalVariable(localVar, clas, declaration); + convertToTypedDeclaration(localVar, clas, declaration); } - public void convertToTypedLocalVariable(Map localVar, TypedClass clas, Declaration declaration) { + public void convertToTypedDeclaration(Map localVar, TypedClass clas, Declaration declaration) { if (localVar.containsKey(declaration.name())) { throw new RuntimeException("Variable " + declaration.name() + " already declared"); } name = declaration.name(); type = declaration.type(); - //localVar.put(this.name, this.type); + typeCheck(localVar, clas); } @Override diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java b/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java new file mode 100644 index 0000000..0c301a6 --- /dev/null +++ b/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java @@ -0,0 +1,63 @@ + +package de.maishai.typedast.typedclass; + +import de.maishai.ast.records.Declaration; +import de.maishai.typedast.MethodContext; +import de.maishai.typedast.TypedNode; +import de.maishai.typedast.Type; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; + +import java.util.Map; + +import static de.maishai.typedast.Type.Kind.REFERENCE; + +@Data +@AllArgsConstructor +@NoArgsConstructor +public final class TypedLocalVariable implements TypedNode { + private String name; + private Type type; + + public TypedLocalVariable(Map localVar, TypedClass clas, Declaration declaration) { + convertToTypedLocalVariable(localVar, clas, declaration); + } + + public void convertToTypedLocalVariable(Map localVar, TypedClass clas, Declaration declaration) { + if (localVar.containsKey(declaration.name())) { + throw new RuntimeException("Variable " + declaration.name() + " already declared"); + } + name = declaration.name(); + type = declaration.type(); + typeCheck(localVar, clas); + } + + @Override + public Type typeCheck(Map localVar, TypedClass clas) { + if (clas.isCurrentMethodPresent() && !clas.isCurrentConstructorPresent()){ + if(clas.getCurrentMethod().isLocalVariableInMethod(name)){ + throw new RuntimeException("Variable " + name + " already declared"); + } + clas.getCurrentMethod().getLocalVariables().add(this); + return type; + } + if (!clas.isCurrentMethodPresent() && clas.isCurrentConstructorPresent()){ + if(clas.getCurrentConstructor().isLocalVariableInConstructor(name)){ + throw new RuntimeException("Variable " + name + " already declared"); + } + clas.getCurrentConstructor().getLocalVariables().add(this); + return type; + } + + throw new RuntimeException("not found method or constructor in class"); + } + + public void codeGen(ClassWriter cw) { + int access = Opcodes.ACC_PUBLIC; // laut Andi ist es ok, dass alle Felder public sind + cw.visitField(access, name, type.getDescriptor(), null, null).visitEnd(); + } +} diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java index 50fba3c..cdee9cf 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java @@ -21,21 +21,12 @@ public class TypedMethod implements TypedNode { private Type returnType; private List typedParameters = new ArrayList<>(); private TypedBlock typedBlock; - //private List localVariables = new ArrayList<>(); + private List localVariables = new ArrayList<>(); public TypedMethod(Map localVar, TypedClass clas, Method unTypedMethod) { convertToTypedMethod(localVar, clas, unTypedMethod); } - @Override - public boolean equals(Object obj) { - if (obj instanceof TypedMethod) { - TypedMethod other = (TypedMethod) obj; - return name.equals(other.name) && returnType.equals(other.returnType) && typedParameters.equals(other.typedParameters); - } - return false; - } - public void convertToTypedMethod(Map localVar, TypedClass clas, Method unTypedMethod) { name = unTypedMethod.methodName(); @@ -56,6 +47,19 @@ public class TypedMethod implements TypedNode { public void convertToTypedBlock(Map localVar, TypedClass clas, Method unTypedMethod) { typedBlock = new TypedBlock(localVar, clas, unTypedMethod.block()); } + public boolean isLocalVariablePresent(String localVarName) { + return localVariables.stream().anyMatch(localVariable -> localVariable.getName().equals(localVarName)); + } + public boolean isParameterPresent(String parameterName) { + return typedParameters.stream().anyMatch(parameter -> parameter.getParaName().equals(parameterName)); + } + + public boolean isLocalVariableInMethod(String localVarName) { + return isLocalVariablePresent(localVarName) || isParameterPresent(localVarName); + } + public Type getLocalVariableType(String localVarName) { + return localVariables.stream().filter(localVariable -> localVariable.getName().equals(localVarName)).findFirst().get().getType(); + } @Override @@ -70,6 +74,15 @@ public class TypedMethod implements TypedNode { return returnType; } + @Override + public boolean equals(Object obj) { + if (obj instanceof TypedMethod) { + TypedMethod other = (TypedMethod) obj; + return name.equals(other.name) && returnType.equals(other.returnType) && typedParameters.equals(other.typedParameters); + } + return false; + } + public void codeGen(ClassWriter cw) { int accessModifier = Opcodes.ACC_PUBLIC; // ist laut Andi ok From 048aff5996771df988afd8b615d80d483c83ab0e Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 13:07:39 +0200 Subject: [PATCH 05/14] Removed the parameter localvariable in typeCheck --- .../typedast/Help/TypedExpressionHelp.java | 34 +++++++------- .../java/de/maishai/typedast/TypedNode.java | 5 +- .../typedast/typedclass/TypedAssignment.java | 14 +++--- .../typedast/typedclass/TypedBinary.java | 16 +++---- .../typedast/typedclass/TypedBlock.java | 46 +++++++++---------- .../typedast/typedclass/TypedBoolLiteral.java | 8 ++-- .../typedast/typedclass/TypedBreak.java | 5 +- .../typedast/typedclass/TypedCharLiteral.java | 8 ++-- .../typedast/typedclass/TypedClass.java | 20 ++++---- .../typedast/typedclass/TypedConstructor.java | 17 +++---- .../typedast/typedclass/TypedDeclaration.java | 13 ++---- .../typedast/typedclass/TypedDoWhile.java | 16 +++---- .../typedclass/TypedFieldVarAccess.java | 14 +++--- .../maishai/typedast/typedclass/TypedFor.java | 24 +++++----- .../typedast/typedclass/TypedIfElse.java | 22 ++++----- .../typedast/typedclass/TypedIntLiteral.java | 8 ++-- .../typedclass/TypedLocalVariable.java | 39 ++++++++-------- .../typedast/typedclass/TypedMethod.java | 25 +++++----- .../typedast/typedclass/TypedMethodCall.java | 12 ++--- .../maishai/typedast/typedclass/TypedNew.java | 21 +++++---- .../typedast/typedclass/TypedParameter.java | 8 ++-- .../typedast/typedclass/TypedReturn.java | 10 ++-- .../typedast/typedclass/TypedUnary.java | 14 +++--- .../typedast/typedclass/TypedWhile.java | 16 +++---- 24 files changed, 206 insertions(+), 209 deletions(-) diff --git a/src/main/java/de/maishai/typedast/Help/TypedExpressionHelp.java b/src/main/java/de/maishai/typedast/Help/TypedExpressionHelp.java index 368c513..2f664e0 100644 --- a/src/main/java/de/maishai/typedast/Help/TypedExpressionHelp.java +++ b/src/main/java/de/maishai/typedast/Help/TypedExpressionHelp.java @@ -9,45 +9,45 @@ import java.util.Map; public class TypedExpressionHelp { - public static TypedExpression convertExpression(Map localVar, TypedClass clas, Expression expression) { + public static TypedExpression convertExpression( TypedClass clas, Expression expression) { if (expression instanceof BoolLiteral boolLiteral) { - TypedBoolLiteral typedBoolLiteral = new TypedBoolLiteral(localVar, clas, boolLiteral); - typedBoolLiteral.typeCheck(localVar, clas); + TypedBoolLiteral typedBoolLiteral = new TypedBoolLiteral( clas, boolLiteral); + typedBoolLiteral.typeCheck( clas); return typedBoolLiteral; } else if (expression instanceof CharLiteral charLiteral) { - TypedCharLiteral typedCharLiteral = new TypedCharLiteral(localVar, clas, charLiteral); - typedCharLiteral.typeCheck(localVar, clas); + TypedCharLiteral typedCharLiteral = new TypedCharLiteral( clas, charLiteral); + typedCharLiteral.typeCheck( clas); return typedCharLiteral; } else if (expression instanceof IntLiteral intLiteral) { - TypedIntLiteral typedIntLiteral = new TypedIntLiteral(localVar, clas, intLiteral); - typedIntLiteral.typeCheck(localVar, clas); + TypedIntLiteral typedIntLiteral = new TypedIntLiteral( clas, intLiteral); + typedIntLiteral.typeCheck( clas); return typedIntLiteral; } else if (expression instanceof Binary binary) { - TypedBinary typedBinary = new TypedBinary(localVar, clas, binary); - typedBinary.typeCheck(localVar, clas); + TypedBinary typedBinary = new TypedBinary( clas, binary); + typedBinary.typeCheck( clas); return typedBinary; } else if (expression instanceof FieldVarAccess fieldVarAccess) { - TypedFieldVarAccess typedFieldVarAccess = new TypedFieldVarAccess(localVar, clas, fieldVarAccess); - typedFieldVarAccess.typeCheck(localVar, clas); + TypedFieldVarAccess typedFieldVarAccess = new TypedFieldVarAccess( clas, fieldVarAccess); + typedFieldVarAccess.typeCheck( clas); return typedFieldVarAccess; } else if (expression instanceof MethodCall methodCall) { - TypedMethodCall typedMethodCall = new TypedMethodCall(localVar, clas, methodCall); - typedMethodCall.typeCheck(localVar, clas); + TypedMethodCall typedMethodCall = new TypedMethodCall( clas, methodCall); + typedMethodCall.typeCheck( clas); return typedMethodCall; } else if (expression instanceof New newStmt) { - TypedNew typedNew = new TypedNew(localVar, clas, newStmt); - typedNew.typeCheck(localVar, clas); + TypedNew typedNew = new TypedNew( clas, newStmt); + typedNew.typeCheck( clas); return typedNew; } else if (expression instanceof Unary unary) { - TypedUnary typedUnary = new TypedUnary(localVar, clas, unary); - typedUnary.typeCheck(localVar, clas); + TypedUnary typedUnary = new TypedUnary( clas, unary); + typedUnary.typeCheck( clas); return typedUnary; } else { return null; diff --git a/src/main/java/de/maishai/typedast/TypedNode.java b/src/main/java/de/maishai/typedast/TypedNode.java index fe3f653..a608e77 100644 --- a/src/main/java/de/maishai/typedast/TypedNode.java +++ b/src/main/java/de/maishai/typedast/TypedNode.java @@ -1,10 +1,7 @@ package de.maishai.typedast; -import de.maishai.ast.records.Node; import de.maishai.typedast.typedclass.TypedClass; -import java.util.Map; - public interface TypedNode { - Type typeCheck(Map localVar, TypedClass clas); + Type typeCheck(TypedClass clas); } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java index fed0d27..b7313bc 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java @@ -21,18 +21,18 @@ public class TypedAssignment implements TypedStatement { // private TypedExpression recursiveOwnerChain; private Type type; - public TypedAssignment(Map localVar, TypedClass clas, Assignment untyped) { - convertToTypedAssignment(localVar, clas, untyped); + public TypedAssignment(TypedClass clas, Assignment untyped) { + convertToTypedAssignment(clas, untyped); } - public void convertToTypedAssignment(Map localVar, TypedClass clas, Assignment untyped) { + public void convertToTypedAssignment(TypedClass clas, Assignment untyped) { varName = untyped.location().id(); - value = convertExpression(localVar, clas, untyped.value()); - // recursiveOwnerChain = convertExpression(localVar, clas, untyped.location().recursiveOwnerChain()); + value = convertExpression(clas, untyped.value()); + // recursiveOwnerChain = convertExpression( clas, untyped.location().recursiveOwnerChain()); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { Type typeLeft = null; if (clas.isThereField(varName)) { @@ -54,7 +54,7 @@ public class TypedAssignment implements TypedStatement { } } - Type typeRight = value.typeCheck(localVar, clas); + Type typeRight = value.typeCheck(clas); if (typeLeft.equals(typeRight)) { type = typeLeft; diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java b/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java index e882eea..1b5572b 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBinary.java @@ -21,20 +21,20 @@ public class TypedBinary implements TypedExpression { private TypedExpression right; private Type type; - public TypedBinary(Map localVar, TypedClass clas, Binary unTypedBinary) { - convertToTypedBinary(localVar, clas, unTypedBinary); + public TypedBinary(TypedClass clas, Binary unTypedBinary) { + convertToTypedBinary(clas, unTypedBinary); } - public void convertToTypedBinary(Map localVar, TypedClass clas, Binary unTypedBinary) { - left = convertExpression(localVar, clas, unTypedBinary.left()); - right = convertExpression(localVar, clas, unTypedBinary.right()); + public void convertToTypedBinary(TypedClass clas, Binary unTypedBinary) { + left = convertExpression(clas, unTypedBinary.left()); + right = convertExpression(clas, unTypedBinary.right()); op = unTypedBinary.op(); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { - Type leftType = left.typeCheck(localVar, clas); - Type rightType = right.typeCheck(localVar, clas); + public Type typeCheck(TypedClass clas) { + Type leftType = left.typeCheck(clas); + Type rightType = right.typeCheck(clas); if (op == Operator.ADD || op == Operator.SUB || op == Operator.MUL) { if (leftType == Type.INT && rightType == Type.INT) { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java index c1eeaf3..d1e3449 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java @@ -23,8 +23,8 @@ public class TypedBlock implements TypedNode { private Type type; - public TypedBlock(Map localVar, TypedClass clas, Block unTypedBlock) { - convertToTypedBlock(localVar, clas, unTypedBlock); + public TypedBlock(TypedClass clas, Block unTypedBlock) { + convertToTypedBlock(clas, unTypedBlock); } public TypedBlock(List vars, List stmts) { @@ -32,56 +32,56 @@ public class TypedBlock implements TypedNode { this.stmts = stmts; } - public void convertToTypedBlock(Map localVar, TypedClass clas, Block unTypedBlock) { + public void convertToTypedBlock(TypedClass clas, Block unTypedBlock) { if (unTypedBlock == null) { return; } for (Declaration var : unTypedBlock.localVariables()) { - vars.add(new TypedLocalVariable(localVar, clas, var)); + vars.add(new TypedLocalVariable(clas, var)); } for (var stmt : unTypedBlock.stmts()) { if (stmt instanceof Assignment assignment) { - TypedAssignment typedAssignment = new TypedAssignment(localVar, clas, assignment); - typedAssignment.typeCheck(localVar, clas); + TypedAssignment typedAssignment = new TypedAssignment(clas, assignment); + typedAssignment.typeCheck(clas); stmts.add(typedAssignment); continue; } if (stmt instanceof For forStmt) { - TypedFor typedFor = new TypedFor(localVar, clas, forStmt); - typedFor.typeCheck(localVar, clas); + TypedFor typedFor = new TypedFor(clas, forStmt); + typedFor.typeCheck(clas); stmts.add(typedFor); continue; } if (stmt instanceof IfElse ifElse) { - TypedIfElse typedIfElse = new TypedIfElse(localVar, clas, ifElse); - typedIfElse.typeCheck(localVar, clas); + TypedIfElse typedIfElse = new TypedIfElse(clas, ifElse); + typedIfElse.typeCheck(clas); stmts.add(typedIfElse); continue; } if (stmt instanceof While whileStmt) { - TypedWhile typedWhile = new TypedWhile(localVar, clas, whileStmt); - typedWhile.typeCheck(localVar, clas); + TypedWhile typedWhile = new TypedWhile(clas, whileStmt); + typedWhile.typeCheck(clas); stmts.add(typedWhile); continue; } if (stmt instanceof DoWhile doWhile) { - TypedDoWhile typedDoWhile = new TypedDoWhile(localVar, clas, doWhile); - typedDoWhile.typeCheck(localVar, clas); + TypedDoWhile typedDoWhile = new TypedDoWhile(clas, doWhile); + typedDoWhile.typeCheck(clas); stmts.add(typedDoWhile); continue; } if (stmt instanceof Return returnStmt) { - TypedReturn typedReturn = new TypedReturn(localVar, clas, returnStmt); - typedReturn.typeCheck(localVar, clas); + TypedReturn typedReturn = new TypedReturn(clas, returnStmt); + typedReturn.typeCheck(clas); stmts.add(typedReturn); continue; } if (stmt instanceof New newStmt) { - TypedNew typedNew = new TypedNew(localVar, clas, newStmt); - typedNew.typeCheck(localVar, clas); + TypedNew typedNew = new TypedNew(clas, newStmt); + typedNew.typeCheck(clas); stmts.add(typedNew); continue; } @@ -92,20 +92,20 @@ public class TypedBlock implements TypedNode { } if (stmt instanceof MethodCall methodCall) { - TypedMethodCall typedMethodCall = new TypedMethodCall(localVar, clas, methodCall); - typedMethodCall.typeCheck(localVar, clas); + TypedMethodCall typedMethodCall = new TypedMethodCall(clas, methodCall); + typedMethodCall.typeCheck(clas); stmts.add(typedMethodCall); } } - this.typeCheck(localVar, clas); + this.typeCheck(clas); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { for (TypedStatement stmt : stmts) { - stmt.typeCheck(localVar, clas); + stmt.typeCheck(clas); } //TODO: Type von Return zurückgeben diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java b/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java index 027a362..a9ed546 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBoolLiteral.java @@ -21,17 +21,17 @@ public class TypedBoolLiteral implements TypedExpression { private Type type; - public TypedBoolLiteral(Map localVar, TypedClass clas, BoolLiteral unTypedBoolLiteral) { - convertToTypedBoolLiteral(localVar, clas, unTypedBoolLiteral); + public TypedBoolLiteral(TypedClass clas, BoolLiteral unTypedBoolLiteral) { + convertToTypedBoolLiteral(clas, unTypedBoolLiteral); } - public void convertToTypedBoolLiteral(Map localVar, TypedClass clas, BoolLiteral unTypedBoolLiteral) { + public void convertToTypedBoolLiteral(TypedClass clas, BoolLiteral unTypedBoolLiteral) { value = unTypedBoolLiteral.value(); type = Type.BOOL; } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { return type; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java b/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java index 8e22ca0..b61c1e4 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBreak.java @@ -15,11 +15,12 @@ import java.util.Map; public class TypedBreak implements TypedStatement { private Type type = Type.VOID; - public TypedBreak convertToTypedBreak(Map localVar, TypedClass clas, Break unTypedBreak) { + public TypedBreak convertToTypedBreak(TypedClass clas, Break unTypedBreak) { return this; } + @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { return type; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java b/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java index 42e64c5..83486d2 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedCharLiteral.java @@ -16,17 +16,17 @@ public class TypedCharLiteral implements TypedExpression { private char value; private Type type; - public TypedCharLiteral(Map localVar, TypedClass clas, CharLiteral unTypedCharLiteral) { - convertToCharLiteral(localVar, clas, unTypedCharLiteral); + public TypedCharLiteral(TypedClass clas, CharLiteral unTypedCharLiteral) { + convertToCharLiteral(clas, unTypedCharLiteral); } - public void convertToCharLiteral(Map localVar, TypedClass clas, CharLiteral unTypedCharLiteral) { + public void convertToCharLiteral(TypedClass clas, CharLiteral unTypedCharLiteral) { value = unTypedCharLiteral.value(); type = Type.CHAR; } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { return type; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java index 247fd15..08bebcf 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java @@ -29,8 +29,8 @@ public class TypedClass implements TypedNode { private TypedConstructor currentConstructor; private Type type; - public TypedClass(Map localVar, Class c) { - convertToTypedClass(localVar, c); + public TypedClass(Class c) { + convertToTypedClass(c); } public void enterCurrentMethod(TypedMethod method) { @@ -81,28 +81,28 @@ public class TypedClass implements TypedNode { return false; } - public void convertToTypedClass(Map localVar, Class c) { + public void convertToTypedClass(Class c) { className = c.classname(); type = Type.REFERENCE(className); for (Declaration declaration : c.fieldDeclarations()) { - typedDeclarations.add(new TypedDeclaration(localVar, this, declaration)); + typedDeclarations.add(new TypedDeclaration(this, declaration)); } // Am Anfang werden die Konstruktoren und Methoden in die Listen eingefügt // Methoden können verwendet werden, bevor deren Blöcke ausgeführt werden for (Constructor constructor : c.constructors()) { - typedConstructors.add(new TypedConstructor(localVar, this, constructor)); + typedConstructors.add(new TypedConstructor(this, constructor)); } for (Method method : c.methods()) { - typedMethods.add(new TypedMethod(localVar, this, method)); + typedMethods.add(new TypedMethod(this, method)); } // Hier werden die Blöcke der Konstruktoren und Methoden ausgeführt int i = 0; for (Constructor constructor : c.constructors()) { enterCurrentConstructor(typedConstructors.get(i)); - typedConstructors.get(i).convertToBlock(localVar, this, constructor); + typedConstructors.get(i).convertToBlock(this, constructor); exitCurrentConstructor(); i++; } @@ -110,7 +110,7 @@ public class TypedClass implements TypedNode { int j = 0; for (Method method : c.methods()) { enterCurrentMethod(typedMethods.get(j)); - typedMethods.get(j).convertToTypedBlock(localVar, this, method); + typedMethods.get(j).convertToTypedBlock(this, method); exitCurrentMethod(); j++; } @@ -118,14 +118,14 @@ public class TypedClass implements TypedNode { } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { return type; } public TypedNode startConversion(Class c) { Map local = new HashMap<>(); - return new TypedClass(local, c); + return new TypedClass(c); } public boolean isParameterWitNameInMethod(String parameterName) { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java index 4ef748d..8942e3b 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java @@ -34,11 +34,11 @@ public class TypedConstructor implements TypedNode { this.typedBlock = typedBlock; } - public TypedConstructor(Map localVar, TypedClass clas, Constructor unTypedConstructor) { - convertToTypedConstructor(localVar, clas, unTypedConstructor); + public TypedConstructor(TypedClass clas, Constructor unTypedConstructor) { + convertToTypedConstructor(clas, unTypedConstructor); } - public boolean isLocalVariablePresent(String localVarName) { + public boolean isLocalVariablePresent(String localVarName) { return localVariables.stream().anyMatch(localVariable -> localVariable.getName().equals(localVarName)); } @@ -49,25 +49,26 @@ public class TypedConstructor implements TypedNode { public boolean isLocalVariableInConstructor(String localVarName) { return isLocalVariablePresent(localVarName) || isParameterPresent(localVarName); } + public Type getLocalVariableType(String localVarName) { return localVariables.stream().filter(localVariable -> localVariable.getName().equals(localVarName)).findFirst().get().getType(); } - public void convertToTypedConstructor(Map localVar, TypedClass clas, Constructor unTypedConstructor) { + public void convertToTypedConstructor(TypedClass clas, Constructor unTypedConstructor) { name = unTypedConstructor.className(); for (Parameter param : unTypedConstructor.params()) { - typedParameters.add(new TypedParameter(localVar, clas, param)); + typedParameters.add(new TypedParameter(clas, param)); } type = Type.VOID; } - public void convertToBlock(Map localVar, TypedClass clas, Constructor unTypedConstructor) { - this.typedBlock = new TypedBlock(localVar, clas, unTypedConstructor.block()); + public void convertToBlock(TypedClass clas, Constructor unTypedConstructor) { + this.typedBlock = new TypedBlock(clas, unTypedConstructor.block()); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { //TODO: check if return is there return type; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java b/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java index 31948ff..e8939c6 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedDeclaration.java @@ -22,21 +22,18 @@ public final class TypedDeclaration implements TypedNode { private String name; private Type type; - public TypedDeclaration(Map localVar, TypedClass clas, Declaration declaration) { - convertToTypedDeclaration(localVar, clas, declaration); + public TypedDeclaration(TypedClass clas, Declaration declaration) { + convertToTypedDeclaration(clas, declaration); } - public void convertToTypedDeclaration(Map localVar, TypedClass clas, Declaration declaration) { - if (localVar.containsKey(declaration.name())) { - throw new RuntimeException("Variable " + declaration.name() + " already declared"); - } + public void convertToTypedDeclaration(TypedClass clas, Declaration declaration) { name = declaration.name(); type = declaration.type(); - typeCheck(localVar, clas); + typeCheck(clas); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { if (clas.isThereField(name)) { throw new RuntimeException("Field " + name + " already declared"); } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java b/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java index 5590261..25f2990 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedDoWhile.java @@ -15,21 +15,21 @@ public class TypedDoWhile implements TypedStatement { private TypedExpression cond; private Type type; - public TypedDoWhile(Map localVar, TypedClass clas, DoWhile unTypedDoWhile) { - convertToTypedDoWhile(localVar, clas, unTypedDoWhile); + public TypedDoWhile(TypedClass clas, DoWhile unTypedDoWhile) { + convertToTypedDoWhile(clas, unTypedDoWhile); } - public void convertToTypedDoWhile(Map localVar, TypedClass clas, DoWhile unTypedDoWhile) { - typedBlock = new TypedBlock(localVar, clas, unTypedDoWhile.block()); - cond = convertExpression(localVar, clas, unTypedDoWhile.cond()); + public void convertToTypedDoWhile(TypedClass clas, DoWhile unTypedDoWhile) { + typedBlock = new TypedBlock(clas, unTypedDoWhile.block()); + cond = convertExpression(clas, unTypedDoWhile.cond()); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { - if (cond.typeCheck(localVar, clas) != Type.BOOL) { + public Type typeCheck(TypedClass clas) { + if (cond.typeCheck(clas) != Type.BOOL) { throw new RuntimeException("Condition must be boolean"); } - typedBlock.typeCheck(localVar, clas); + typedBlock.typeCheck(clas); this.type = Type.VOID; return Type.VOID; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java b/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java index fa04377..fad4f23 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java @@ -20,18 +20,18 @@ public class TypedFieldVarAccess implements TypedExpression { private String name; private Type type; - public TypedFieldVarAccess(Map localVar, TypedClass clas, FieldVarAccess unTypedFieldVarAccess) { - convertToTypedFieldVarAccess(localVar, clas, unTypedFieldVarAccess); + public TypedFieldVarAccess(TypedClass clas, FieldVarAccess unTypedFieldVarAccess) { + convertToTypedFieldVarAccess(clas, unTypedFieldVarAccess); } - public void convertToTypedFieldVarAccess(Map localVar, TypedClass clas, FieldVarAccess unTypedFieldVarAccess) { + public void convertToTypedFieldVarAccess(TypedClass clas, FieldVarAccess unTypedFieldVarAccess) { field = unTypedFieldVarAccess.field(); - recursiveOwnerChain = convertExpression(localVar, clas, unTypedFieldVarAccess.recursiveOwnerChain()); + recursiveOwnerChain = convertExpression(clas, unTypedFieldVarAccess.recursiveOwnerChain()); name = unTypedFieldVarAccess.id(); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { if (field) { if (clas.isThereField(name)) { type = clas.getFieldType(name); @@ -52,11 +52,11 @@ public class TypedFieldVarAccess implements TypedExpression { type = clas.getParameterTypeInCurrentMethod(name); return clas.getParameterTypeInCurrentMethod(name); } - } + }/* if (localVar.containsKey(name)) { type = localVar.get(name); return localVar.get(name); - } + }*/ } throw new RuntimeException("Variable " + name + " not declared "); diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedFor.java b/src/main/java/de/maishai/typedast/typedclass/TypedFor.java index 0d6957c..8f8f4cd 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedFor.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedFor.java @@ -22,25 +22,25 @@ public class TypedFor implements TypedStatement { //TODO: type of block in for loop private Type type; - public TypedFor(Map localVar, TypedClass clas, For unTypedFor) { - convertToTypedFor(localVar, clas, unTypedFor); + public TypedFor(TypedClass clas, For unTypedFor) { + convertToTypedFor(clas, unTypedFor); } - public void convertToTypedFor(Map localVar, TypedClass clas, For unTypedFor) { - assign = new TypedAssignment(localVar, clas, unTypedFor.assign()); - cond = convertExpression(localVar, clas, unTypedFor.cond()); - inc = new TypedAssignment(localVar, clas, unTypedFor.inc()); - typedBlock = new TypedBlock(localVar, clas, unTypedFor.block()); + public void convertToTypedFor(TypedClass clas, For unTypedFor) { + assign = new TypedAssignment(clas, unTypedFor.assign()); + cond = convertExpression(clas, unTypedFor.cond()); + inc = new TypedAssignment(clas, unTypedFor.inc()); + typedBlock = new TypedBlock(clas, unTypedFor.block()); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { - assign.typeCheck(localVar, clas); - if (!cond.typeCheck(localVar, clas).equals(Type.BOOL)) { + public Type typeCheck(TypedClass clas) { + assign.typeCheck(clas); + if (!cond.typeCheck(clas).equals(Type.BOOL)) { throw new RuntimeException("Condition must be a boolean"); } - inc.typeCheck(localVar, clas); - type = typedBlock.typeCheck(localVar, clas); + inc.typeCheck(clas); + type = typedBlock.typeCheck(clas); return type; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java b/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java index d17867b..ea06146 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java @@ -21,29 +21,29 @@ public class TypedIfElse implements TypedStatement { //TODO: add Type private Type type; - public TypedIfElse(Map localVar, TypedClass clas, IfElse unTypedIfElse) { - convertToTypedIfElse(localVar, clas, unTypedIfElse); + public TypedIfElse(TypedClass clas, IfElse unTypedIfElse) { + convertToTypedIfElse(clas, unTypedIfElse); } - public void convertToTypedIfElse(Map localVar, TypedClass clas, IfElse unTypedIfElse) { - ifTypedBlock = new TypedBlock(localVar, clas, unTypedIfElse.ifBlock()); - elseTypedBlock = new TypedBlock(localVar, clas, unTypedIfElse.elseBlock()); - typedCon = convertExpression(localVar, clas, unTypedIfElse.cond()); + public void convertToTypedIfElse(TypedClass clas, IfElse unTypedIfElse) { + ifTypedBlock = new TypedBlock(clas, unTypedIfElse.ifBlock()); + elseTypedBlock = new TypedBlock(clas, unTypedIfElse.elseBlock()); + typedCon = convertExpression(clas, unTypedIfElse.cond()); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { - if (typedCon.typeCheck(localVar, clas) != Type.BOOL) { + if (typedCon.typeCheck(clas) != Type.BOOL) { throw new RuntimeException("If condition must be a boolean"); } - if (ifTypedBlock.typeCheck(localVar, clas) != Type.VOID) { + if (ifTypedBlock.typeCheck(clas) != Type.VOID) { throw new RuntimeException("If block must be of type void"); } //TODO: catch all cases of return when one method has a return type - if (ifTypedBlock.typeCheck(localVar, clas) == elseTypedBlock.typeCheck(localVar, clas)) { - type = ifTypedBlock.typeCheck(localVar, clas); + if (ifTypedBlock.typeCheck(clas) == elseTypedBlock.typeCheck(clas)) { + type = ifTypedBlock.typeCheck(clas); } return type; diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java b/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java index 33bf693..9e1f51b 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedIntLiteral.java @@ -20,17 +20,17 @@ public class TypedIntLiteral implements TypedExpression { private Type type; - public TypedIntLiteral(Map localVar, TypedClass clas, IntLiteral unTypedIntLiteral) { - convertToTypedIntLiteral(localVar, clas, unTypedIntLiteral); + public TypedIntLiteral(TypedClass clas, IntLiteral unTypedIntLiteral) { + convertToTypedIntLiteral(clas, unTypedIntLiteral); } - public void convertToTypedIntLiteral(Map localVar, TypedClass clas, IntLiteral unTypedIntLiteral) { + public void convertToTypedIntLiteral(TypedClass clas, IntLiteral unTypedIntLiteral) { value = unTypedIntLiteral.value(); type = Type.INT; } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { return type; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java b/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java index 0c301a6..1a282e4 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedLocalVariable.java @@ -23,34 +23,31 @@ public final class TypedLocalVariable implements TypedNode { private String name; private Type type; - public TypedLocalVariable(Map localVar, TypedClass clas, Declaration declaration) { - convertToTypedLocalVariable(localVar, clas, declaration); + public TypedLocalVariable(TypedClass clas, Declaration declaration) { + convertToTypedLocalVariable(clas, declaration); } - public void convertToTypedLocalVariable(Map localVar, TypedClass clas, Declaration declaration) { - if (localVar.containsKey(declaration.name())) { - throw new RuntimeException("Variable " + declaration.name() + " already declared"); - } + public void convertToTypedLocalVariable(TypedClass clas, Declaration declaration) { name = declaration.name(); type = declaration.type(); - typeCheck(localVar, clas); + typeCheck(clas); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { - if (clas.isCurrentMethodPresent() && !clas.isCurrentConstructorPresent()){ - if(clas.getCurrentMethod().isLocalVariableInMethod(name)){ - throw new RuntimeException("Variable " + name + " already declared"); - } - clas.getCurrentMethod().getLocalVariables().add(this); - return type; - } - if (!clas.isCurrentMethodPresent() && clas.isCurrentConstructorPresent()){ - if(clas.getCurrentConstructor().isLocalVariableInConstructor(name)){ - throw new RuntimeException("Variable " + name + " already declared"); - } - clas.getCurrentConstructor().getLocalVariables().add(this); - return type; + public Type typeCheck(TypedClass clas) { + if (clas.isCurrentMethodPresent() && !clas.isCurrentConstructorPresent()) { + if (clas.getCurrentMethod().isLocalVariableInMethod(name)) { + throw new RuntimeException("Variable " + name + " already declared"); + } + clas.getCurrentMethod().getLocalVariables().add(this); + return type; + } + if (!clas.isCurrentMethodPresent() && clas.isCurrentConstructorPresent()) { + if (clas.getCurrentConstructor().isLocalVariableInConstructor(name)) { + throw new RuntimeException("Variable " + name + " already declared"); + } + clas.getCurrentConstructor().getLocalVariables().add(this); + return type; } throw new RuntimeException("not found method or constructor in class"); diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java index cdee9cf..e9c4f38 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java @@ -23,16 +23,16 @@ public class TypedMethod implements TypedNode { private TypedBlock typedBlock; private List localVariables = new ArrayList<>(); - public TypedMethod(Map localVar, TypedClass clas, Method unTypedMethod) { - convertToTypedMethod(localVar, clas, unTypedMethod); + public TypedMethod(TypedClass clas, Method unTypedMethod) { + convertToTypedMethod(clas, unTypedMethod); } - public void convertToTypedMethod(Map localVar, TypedClass clas, Method unTypedMethod) { + public void convertToTypedMethod(TypedClass clas, Method unTypedMethod) { name = unTypedMethod.methodName(); returnType = unTypedMethod.type(); for (var parameter : unTypedMethod.params()) { - typedParameters.add(new TypedParameter(localVar, clas, parameter)); + typedParameters.add(new TypedParameter(clas, parameter)); } clas.getTypedMethods().stream().filter(method -> method.equals(this)).findFirst().ifPresentOrElse( @@ -41,15 +41,17 @@ public class TypedMethod implements TypedNode { }, () -> { }); - localVar.put(name, returnType); + //localVar.put(name, returnType); } - public void convertToTypedBlock(Map localVar, TypedClass clas, Method unTypedMethod) { - typedBlock = new TypedBlock(localVar, clas, unTypedMethod.block()); + public void convertToTypedBlock(TypedClass clas, Method unTypedMethod) { + typedBlock = new TypedBlock(clas, unTypedMethod.block()); } + public boolean isLocalVariablePresent(String localVarName) { return localVariables.stream().anyMatch(localVariable -> localVariable.getName().equals(localVarName)); } + public boolean isParameterPresent(String parameterName) { return typedParameters.stream().anyMatch(parameter -> parameter.getParaName().equals(parameterName)); } @@ -57,20 +59,21 @@ public class TypedMethod implements TypedNode { public boolean isLocalVariableInMethod(String localVarName) { return isLocalVariablePresent(localVarName) || isParameterPresent(localVarName); } + public Type getLocalVariableType(String localVarName) { return localVariables.stream().filter(localVariable -> localVariable.getName().equals(localVarName)).findFirst().get().getType(); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { - if (localVar.containsKey(name)) { + public Type typeCheck(TypedClass clas) { + /* if (localVar.containsKey(name)) { throw new RuntimeException("Method " + name + " already exists"); } localVar.put(name, returnType); for (TypedParameter typedParameter : typedParameters) { - typedParameter.typeCheck(localVar, clas); - } + typedParameter.typeCheck( clas); + }*/ return returnType; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java index 3969a2f..f7e5a87 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java @@ -19,19 +19,19 @@ public class TypedMethodCall implements TypedExpression, TypedStatement { private List args; private Type type; - public TypedMethodCall(Map localVar, TypedClass clas, MethodCall unTypedMethodCall) { - convertToTypedMethodCall(localVar, clas, unTypedMethodCall); + public TypedMethodCall(TypedClass clas, MethodCall unTypedMethodCall) { + convertToTypedMethodCall(clas, unTypedMethodCall); } - public void convertToTypedMethodCall(Map localVar, TypedClass clas, MethodCall unTypedMethodCall) { - recipient = new TypedFieldVarAccess(localVar, clas, unTypedMethodCall.recipient()); + public void convertToTypedMethodCall(TypedClass clas, MethodCall unTypedMethodCall) { + recipient = new TypedFieldVarAccess(clas, unTypedMethodCall.recipient()); for (Expression arg : unTypedMethodCall.args()) { - args.add(convertExpression(localVar, clas, arg)); + args.add(convertExpression(clas, arg)); } } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { //TODO: implement this return null; } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedNew.java b/src/main/java/de/maishai/typedast/typedclass/TypedNew.java index d60509e..b5b885b 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedNew.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedNew.java @@ -17,28 +17,29 @@ public class TypedNew implements TypedExpression, TypedStatement { private Type type; private List args = new ArrayList<>(); - public TypedNew(Map localVar, TypedClass clas, New unTypedNew) { - convertToTypedNew(localVar, clas, unTypedNew); + public TypedNew(TypedClass clas, New unTypedNew) { + convertToTypedNew(clas, unTypedNew); } - public void convertToTypedNew(Map localVar, TypedClass clas, New unTypedNew) { + + public void convertToTypedNew(TypedClass clas, New unTypedNew) { type = unTypedNew.type(); for (Expression arg : unTypedNew.args()) { - args.add(convertExpression(localVar, clas, arg)); + args.add(convertExpression(clas, arg)); } } @Override - public Type typeCheck(Map localVar, TypedClass clas) { - for(var constructor : clas.getTypedConstructors()){ - if(constructor.getTypedParameters().size() == args.size()){ + public Type typeCheck(TypedClass clas) { + for (var constructor : clas.getTypedConstructors()) { + if (constructor.getTypedParameters().size() == args.size()) { boolean valid = true; - for(int i = 0; i < args.size(); i++){ - if(!constructor.getTypedParameters().get(i).getType().equals(args.get(i).typeCheck(localVar, clas))){ + for (int i = 0; i < args.size(); i++) { + if (!constructor.getTypedParameters().get(i).getType().equals(args.get(i).typeCheck(clas))) { valid = false; break; } } - if(valid){ + if (valid) { return Type.REFERENCE(clas.getClassName()); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedParameter.java b/src/main/java/de/maishai/typedast/typedclass/TypedParameter.java index d5fbbfb..e58662e 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedParameter.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedParameter.java @@ -14,11 +14,11 @@ public class TypedParameter implements TypedNode { private String paraName; private Type type; - public TypedParameter(Map localVar, TypedClass clas, Parameter unTypedParameter) { - convertToTypedParameter(localVar, clas, unTypedParameter); + public TypedParameter(TypedClass clas, Parameter unTypedParameter) { + convertToTypedParameter(clas, unTypedParameter); } - public void convertToTypedParameter(Map localVar, TypedClass clas, Parameter unTypedParameter) { + public void convertToTypedParameter(TypedClass clas, Parameter unTypedParameter) { paraName = unTypedParameter.name(); type = unTypedParameter.type(); } @@ -34,7 +34,7 @@ public class TypedParameter implements TypedNode { @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { if (clas.isCurrentMethodPresent()) { if (clas.isParameterWitNameInMethod(paraName)) { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java b/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java index 053c3e5..afcac8f 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java @@ -18,17 +18,17 @@ public class TypedReturn implements TypedStatement { private TypedExpression ret; private Type type; - public TypedReturn(Map localVar, TypedClass clas, Return unTypedReturn) { - convertToTypedReturn(localVar, clas, unTypedReturn); + public TypedReturn(TypedClass clas, Return unTypedReturn) { + convertToTypedReturn(clas, unTypedReturn); } - public void convertToTypedReturn(Map localVar, TypedClass clas, Return unTypedReturn) { - ret = convertExpression(localVar, clas, unTypedReturn.ret()); + public void convertToTypedReturn(TypedClass clas, Return unTypedReturn) { + ret = convertExpression(clas, unTypedReturn.ret()); type = ret.getType(); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { if (clas.isCurrentMethodPresent()) { if (clas.getCurrentMethod().getReturnType().getKind() != this.type.getKind()) { StringBuilder exp = new StringBuilder(); diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java b/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java index f69d043..5c06c00 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedUnary.java @@ -19,27 +19,27 @@ public class TypedUnary implements TypedExpression { private TypedExpression right; private Type type; - public TypedUnary(Map localVar, TypedClass clas, Unary unTypedUnary) { - convertToTypedUnary(localVar, clas, unTypedUnary); + public TypedUnary(TypedClass clas, Unary unTypedUnary) { + convertToTypedUnary(clas, unTypedUnary); } - public void convertToTypedUnary(Map localVar, TypedClass clas, Unary unTypedUnary) { + public void convertToTypedUnary(TypedClass clas, Unary unTypedUnary) { op = unTypedUnary.op(); - right = convertExpression(localVar, clas, unTypedUnary.right()); + right = convertExpression(clas, unTypedUnary.right()); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { + public Type typeCheck(TypedClass clas) { if (op == UnaryOperator.NOT) { - if (right.typeCheck(localVar, clas) != Type.BOOL) { + if (right.typeCheck(clas) != Type.BOOL) { throw new RuntimeException("Not operator must be applied to boolean"); } return Type.BOOL; } if (op == UnaryOperator.SUB) { - if (right.typeCheck(localVar, clas) != Type.INT) { + if (right.typeCheck(clas) != Type.INT) { throw new RuntimeException("Minus operator must be applied to int"); } return Type.INT; diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java b/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java index 4fcd915..7bf1f10 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedWhile.java @@ -15,21 +15,21 @@ public class TypedWhile implements TypedStatement { private TypedBlock typedBlock; private Type type; - public TypedWhile(Map localVar, TypedClass clas, While unTypedWhile) { - convertToTypedWhile(localVar, clas, unTypedWhile); + public TypedWhile(TypedClass clas, While unTypedWhile) { + convertToTypedWhile(clas, unTypedWhile); } - public void convertToTypedWhile(Map localVar, TypedClass clas, While unTypedWhile) { - cond = convertExpression(localVar, clas, unTypedWhile.cond()); - typedBlock = new TypedBlock(localVar, clas, unTypedWhile.block()); + public void convertToTypedWhile(TypedClass clas, While unTypedWhile) { + cond = convertExpression(clas, unTypedWhile.cond()); + typedBlock = new TypedBlock(clas, unTypedWhile.block()); } @Override - public Type typeCheck(Map localVar, TypedClass clas) { - if (cond.typeCheck(localVar, clas) != Type.BOOL) { + public Type typeCheck(TypedClass clas) { + if (cond.typeCheck(clas) != Type.BOOL) { throw new RuntimeException("While condition must be a boolean"); } - type = typedBlock.typeCheck(localVar, clas); + type = typedBlock.typeCheck(clas); return type; } From 8e9ce8caa4a5b8a575c9bcdd082de626a4bfb0c6 Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 14:39:28 +0200 Subject: [PATCH 06/14] updated the checkType in TypedFieldVarAccess --- .../typedclass/TypedFieldVarAccess.java | 26 ++++++++++++------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java b/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java index fad4f23..284cda0 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java @@ -36,30 +36,36 @@ public class TypedFieldVarAccess implements TypedExpression { if (clas.isThereField(name)) { type = clas.getFieldType(name); return clas.getFieldType(name); + }else{ + throw new RuntimeException("Field " + name + " not declared "); } } else { - if (clas.isThereField(name)) { type = clas.getFieldType(name); - return clas.getFieldType(name); + return type; } else if (clas.isCurrentConstructorPresent()) { if (clas.isParameterNameInCurrentConstructor(name)) { type = clas.getParameterTypeInCurrentConstructor(name); - return clas.getParameterTypeInCurrentConstructor(name); + return type; + } else if (clas.getCurrentConstructor().isLocalVariablePresent(name)) { + type = clas.getCurrentConstructor().getLocalVariableType(name); + return type; + } else { + throw new RuntimeException("Variable " + name + " not declared "); } } else if (clas.isCurrentMethodPresent()) { if (clas.isParameterWitNameInMethod(name)) { type = clas.getParameterTypeInCurrentMethod(name); return clas.getParameterTypeInCurrentMethod(name); + } else if (clas.getCurrentMethod().isLocalVariablePresent(name)) { + type = clas.getCurrentMethod().getLocalVariableType(name); + return type; + } else { + throw new RuntimeException("Variable " + name + " not declared "); } - }/* - if (localVar.containsKey(name)) { - type = localVar.get(name); - return localVar.get(name); - }*/ + } + throw new RuntimeException("Variable " + name + " not declared "); } - - throw new RuntimeException("Variable " + name + " not declared "); } @Override From 3b1161e97a4e3b7418d28a6fedff61d4ca5ace0a Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 14:44:17 +0200 Subject: [PATCH 07/14] Add recursiveOwnerChain to TypedAssignment --- .../java/de/maishai/typedast/typedclass/TypedAssignment.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java index b7313bc..6ae0a71 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java @@ -18,7 +18,7 @@ import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; public class TypedAssignment implements TypedStatement { private String varName; private TypedExpression value; - // private TypedExpression recursiveOwnerChain; + private TypedExpression recursiveOwnerChain; private Type type; public TypedAssignment(TypedClass clas, Assignment untyped) { @@ -28,7 +28,7 @@ public class TypedAssignment implements TypedStatement { public void convertToTypedAssignment(TypedClass clas, Assignment untyped) { varName = untyped.location().id(); value = convertExpression(clas, untyped.value()); - // recursiveOwnerChain = convertExpression( clas, untyped.location().recursiveOwnerChain()); + recursiveOwnerChain = convertExpression( clas, untyped.location().recursiveOwnerChain()); } @Override From 2322d161e66dbee7246132f5582d5fd01566a608 Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 14:55:03 +0200 Subject: [PATCH 08/14] Update the typeCheck of TypedBlock --- .../de/maishai/typedast/typedclass/TypedBlock.java | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java index d1e3449..532c449 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedBlock.java @@ -98,18 +98,24 @@ public class TypedBlock implements TypedNode { } } this.typeCheck(clas); + System.out.println("TypedBlock: " + this.toString()); } @Override public Type typeCheck(TypedClass clas) { - + Type chekType = null; for (TypedStatement stmt : stmts) { stmt.typeCheck(clas); + if(stmt instanceof TypedReturn returnStmt) { + chekType = returnStmt.getType(); + } } - //TODO: Type von Return zurückgeben - type = Type.VOID; + if(chekType == null) { + chekType = Type.VOID; + } + type = chekType; return type; } From 092cbb5af9b0a988992736330d044d6d192bcf9a Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 15:45:18 +0200 Subject: [PATCH 09/14] Updated the typeCheck of TypedIfElse --- .../de/maishai/typedast/typedclass/TypedFor.java | 1 - .../de/maishai/typedast/typedclass/TypedIfElse.java | 13 +++++++++---- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedFor.java b/src/main/java/de/maishai/typedast/typedclass/TypedFor.java index 8f8f4cd..ee1bc5a 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedFor.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedFor.java @@ -19,7 +19,6 @@ public class TypedFor implements TypedStatement { private TypedExpression cond; private TypedAssignment inc; private TypedBlock typedBlock; - //TODO: type of block in for loop private Type type; public TypedFor(TypedClass clas, For unTypedFor) { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java b/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java index ea06146..0073862 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedIfElse.java @@ -18,7 +18,6 @@ public class TypedIfElse implements TypedStatement { private TypedExpression typedCon; private TypedBlock ifTypedBlock; private TypedBlock elseTypedBlock; - //TODO: add Type private Type type; public TypedIfElse(TypedClass clas, IfElse unTypedIfElse) { @@ -33,18 +32,24 @@ public class TypedIfElse implements TypedStatement { @Override public Type typeCheck(TypedClass clas) { - +/* if (typedCon.typeCheck(clas) != Type.BOOL) { throw new RuntimeException("If condition must be a boolean"); } if (ifTypedBlock.typeCheck(clas) != Type.VOID) { throw new RuntimeException("If block must be of type void"); } - - //TODO: catch all cases of return when one method has a return type +*/ + //TODO: it still not catching the all cases when return is used if (ifTypedBlock.typeCheck(clas) == elseTypedBlock.typeCheck(clas)) { type = ifTypedBlock.typeCheck(clas); } + if (elseTypedBlock.typeCheck(clas) == Type.VOID) { + type = ifTypedBlock.typeCheck(clas); + } + if (ifTypedBlock.typeCheck(clas) == Type.VOID) { + type = elseTypedBlock.typeCheck(clas); + } return type; } From ede0b389878d222a19968de7dbf643bb28678928 Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 15:46:14 +0200 Subject: [PATCH 10/14] Add the list of TypedLocalVariable to TypedMethod and implemented the typeCheck --- .../maishai/typedast/typedclass/TypedMethod.java | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java index e9c4f38..26fcf00 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java @@ -20,8 +20,8 @@ public class TypedMethod implements TypedNode { private String name; private Type returnType; private List typedParameters = new ArrayList<>(); - private TypedBlock typedBlock; private List localVariables = new ArrayList<>(); + private TypedBlock typedBlock; public TypedMethod(TypedClass clas, Method unTypedMethod) { convertToTypedMethod(clas, unTypedMethod); @@ -40,12 +40,11 @@ public class TypedMethod implements TypedNode { throw new RuntimeException("Method " + name + " already exists"); }, () -> { }); - - //localVar.put(name, returnType); } public void convertToTypedBlock(TypedClass clas, Method unTypedMethod) { typedBlock = new TypedBlock(clas, unTypedMethod.block()); + typeCheck(clas); } public boolean isLocalVariablePresent(String localVarName) { @@ -67,13 +66,11 @@ public class TypedMethod implements TypedNode { @Override public Type typeCheck(TypedClass clas) { - /* if (localVar.containsKey(name)) { - throw new RuntimeException("Method " + name + " already exists"); + if(returnType != Type.VOID){ + if(typedBlock.typeCheck(clas) != returnType){ + throw new RuntimeException("Method " + name + " must return " + returnType); + } } - localVar.put(name, returnType); - for (TypedParameter typedParameter : typedParameters) { - typedParameter.typeCheck( clas); - }*/ return returnType; } From 7c4ea4b7e20afbabc775591ebaf6bc90f681189c Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 15:54:44 +0200 Subject: [PATCH 11/14] Implemented the typeCheck in TypedConstructor --- .../de/maishai/typedast/typedclass/TypedConstructor.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java index 8942e3b..0abb847 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedConstructor.java @@ -65,11 +65,16 @@ public class TypedConstructor implements TypedNode { public void convertToBlock(TypedClass clas, Constructor unTypedConstructor) { this.typedBlock = new TypedBlock(clas, unTypedConstructor.block()); + typeCheck(clas); } @Override public Type typeCheck(TypedClass clas) { - //TODO: check if return is there + type = typedBlock.typeCheck(clas); + if(type != Type.VOID){ + throw new RuntimeException("Constructor must not habe a return statement"); + } + return type; } From de51bcd8255f69b66f0517ddb4002fd9ba78b850 Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 19:56:00 +0200 Subject: [PATCH 12/14] Updated TypedAssignment and add TODO --- .../typedast/typedclass/TypedAssignment.java | 22 +++++++--------- .../typedast/typedclass/TypedMethodCall.java | 26 ++++++++++++++++++- 2 files changed, 35 insertions(+), 13 deletions(-) diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java index 197db8c..cc8992e 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedAssignment.java @@ -16,9 +16,8 @@ import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; @Data public class TypedAssignment implements TypedStatement { - private String varName; private TypedExpression value; - private TypedExpression recursiveOwnerChain; + private TypedFieldVarAccess location; private Type type; public TypedAssignment(TypedClass clas, Assignment untyped) { @@ -26,30 +25,29 @@ public class TypedAssignment implements TypedStatement { } public void convertToTypedAssignment(TypedClass clas, Assignment untyped) { - varName = untyped.location().id(); value = convertExpression(clas, untyped.value()); - recursiveOwnerChain = convertExpression( clas, untyped.location().recursiveOwnerChain()); + location = new TypedFieldVarAccess(clas, untyped.location()); } @Override public Type typeCheck(TypedClass clas) { Type typeLeft = null; - if (clas.isThereField(varName)) { - typeLeft = clas.getFieldType(varName); + if (clas.isThereField(location.getName())) { + typeLeft = clas.getFieldType(location.getName()); } else { if (clas.isCurrentMethodPresent() && !clas.isCurrentConstructorPresent()) { - if (clas.getCurrentMethod().isLocalVariableInMethod(varName)) { - typeLeft = clas.getCurrentMethod().getLocalVariableType(varName); + if (clas.getCurrentMethod().isLocalVariableInMethod(location.getName())) { + typeLeft = clas.getCurrentMethod().getLocalVariableType(location.getName()); } else { - throw new RuntimeException("Variable " + varName + " not declared in method"); + throw new RuntimeException("Variable " + location.getName() + " not declared in method"); } } if (!clas.isCurrentMethodPresent() && clas.isCurrentConstructorPresent()) { - if (clas.getCurrentConstructor().isLocalVariableInConstructor(varName)) { - typeLeft = clas.getCurrentConstructor().getLocalVariableType(varName); + if (clas.getCurrentConstructor().isLocalVariableInConstructor(location.getName())) { + typeLeft = clas.getCurrentConstructor().getLocalVariableType(location.getName()); } else { - throw new RuntimeException("Variable " + varName + " not declared in constructor"); + throw new RuntimeException("Variable " + location.getName() + " not declared in constructor"); } } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java index a2bdfb9..d3962af 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethodCall.java @@ -12,6 +12,8 @@ import java.util.Map; import static de.maishai.typedast.Help.TypedExpressionHelp.convertExpression; +//TODO: test this after fixing error from parser + @Data @NoArgsConstructor public class TypedMethodCall implements TypedExpression, TypedStatement { @@ -28,11 +30,33 @@ public class TypedMethodCall implements TypedExpression, TypedStatement { for (Expression arg : unTypedMethodCall.args()) { args.add(convertExpression(clas, arg)); } + recipient.getName(); } @Override public Type typeCheck(TypedClass clas) { - //TODO: implement this + /* if (clas.isCurrentMethodPresent()) { + + List methods = clas.getTypedMethods().stream() + .filter(method -> method.getName().equals(name)) + .toList(); + + for (TypedMethod method : methods) { + if (method.getTypedParameters().size() == args.size()) { + boolean allMatch = true; + for (int i = 0; i < args.size(); i++) { + if (!args.get(i).typeCheck(clas).equals(method.getTypedParameters().get(i).getType())) { + allMatch = false; + break; + } + } + if (allMatch) { + return method.getReturnType(); + } + } + } + + } */ return null; } From 8b5ec63e4b4af1f789ebc96182f74ac36824be6e Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 20:28:43 +0200 Subject: [PATCH 13/14] Update the typeCheck in TypedFieldVarAccess --- .../typedclass/TypedFieldVarAccess.java | 24 ++++++++++++------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java b/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java index 12a2eb9..621ec43 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java @@ -40,28 +40,34 @@ public class TypedFieldVarAccess implements TypedExpression { throw new RuntimeException("Field " + name + " not declared "); } } else { - if (clas.isThereField(name)) { - type = clas.getFieldType(name); - return type; - } else if (clas.isCurrentConstructorPresent()) { + if (clas.isCurrentConstructorPresent()) { if (clas.isParameterNameInCurrentConstructor(name)) { type = clas.getParameterTypeInCurrentConstructor(name); return type; } else if (clas.getCurrentConstructor().isLocalVariablePresent(name)) { type = clas.getCurrentConstructor().getLocalVariableType(name); return type; - } else { - throw new RuntimeException("Variable " + name + " not declared "); + } else if(clas.isThereField(name)){ + type = clas.getFieldType(name); + return type; } + else { + throw new RuntimeException("Variable " + name + " not declared in constructor"); + } + } else if (clas.isCurrentMethodPresent()) { if (clas.isParameterWitNameInMethod(name)) { type = clas.getParameterTypeInCurrentMethod(name); - return clas.getParameterTypeInCurrentMethod(name); + return type; } else if (clas.getCurrentMethod().isLocalVariablePresent(name)) { type = clas.getCurrentMethod().getLocalVariableType(name); return type; - } else { - throw new RuntimeException("Variable " + name + " not declared "); + } else if(clas.isThereField(name)){ + type = clas.getFieldType(name); + return type; + } + else { + throw new RuntimeException("Variable " + name + " not declared in method"); } } throw new RuntimeException("Variable " + name + " not declared "); From 6b89cd09584c10b68172f763c811049cefe5024c Mon Sep 17 00:00:00 2001 From: ahmad Date: Sun, 12 May 2024 20:59:35 +0200 Subject: [PATCH 14/14] Update TypedMethod and TypedReturn and ClassCanBeTyped --- .../java/de/maishai/typedast/typedclass/TypedMethod.java | 2 +- .../java/de/maishai/typedast/typedclass/TypedReturn.java | 6 +++++- src/main/resources/JavaTestfiles/ClassCanBeTyped.java | 3 +++ 3 files changed, 9 insertions(+), 2 deletions(-) diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java index 33f4217..219d41e 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedMethod.java @@ -67,7 +67,7 @@ public class TypedMethod implements TypedNode { @Override public Type typeCheck(TypedClass clas) { if(returnType != Type.VOID){ - if(typedBlock.typeCheck(clas) != returnType){ + if(typedBlock.typeCheck(clas).getKind() != returnType.getKind()){ throw new RuntimeException("Method " + name + " must return " + returnType); } } diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java b/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java index c03da3e..7da3e43 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedReturn.java @@ -24,7 +24,11 @@ public class TypedReturn implements TypedStatement { public void convertToTypedReturn(TypedClass clas, Return unTypedReturn) { ret = convertExpression(clas, unTypedReturn.ret()); - type = ret.getType(); + if(ret == null){ + type = Type.VOID; + }else{ + type = ret.getType(); + } } @Override diff --git a/src/main/resources/JavaTestfiles/ClassCanBeTyped.java b/src/main/resources/JavaTestfiles/ClassCanBeTyped.java index 52e58ca..d85451e 100644 --- a/src/main/resources/JavaTestfiles/ClassCanBeTyped.java +++ b/src/main/resources/JavaTestfiles/ClassCanBeTyped.java @@ -3,6 +3,7 @@ public class ClassCanBeTyped { int x; int y; ClassCanBeTyped b; + ClassCanBeTyped c; public ClassCanBeTyped(int x) { this.x = x; } @@ -16,6 +17,8 @@ public class ClassCanBeTyped { b = new ClassCanBeTyped(x); b.x = 10 + a; b.y = 20; + b.c.x = 20 + a; + b.c.b.y = b.x; return b; }