Update Makefile

Other tests and make refactored

readme.md

@@ -43,10 +43,21 @@ src/
     └── resources/
 test/
 └── java/
-│   ├── main/                 -> MainTest, E2ETests, UtilityTests
+│   ├── main/
 │   ├── parser/               -> Performs tests on the parser
-│   └── semantic/             -> Performs tests on the semantic check
-└── resources/                -> Ressources for running the Tests
+│   └── semantic/
+└── resources/            -> Ressources for running the Tests
+    ├──input
+    │  ├── combinedFeatureTests
+    │  ├── endabgabeTests
+    │  ├── failureTests
+    │  ├── singleFeatureSemanticTests
+    │  ├── singleFeatureTests
+    │  ├── typedAstExceptionsTests
+    │  └── typedAstFeatureTests
+    └──output
+        ├── javac
+        └── raupenpiler
 ```
 
 ## Class-Diagramm AST
@@ -62,7 +73,5 @@ test/
 
 
 ## How to run the compiler
-
 ## Download
-
 ```bash

src/main/java/ast/statementexpressions/crementexpressions/DecrementNode.java

@@ -7,7 +7,7 @@ import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
-public class DecrementNode implements IStatementExpressionNode, Visitable {
+public class DecrementNode implements IStatementExpressionNode {
     public CrementType crementType;
     public AssignableNode assignableExpression;
 
@@ -20,9 +20,4 @@ public class DecrementNode implements IStatementExpressionNode, Visitable {
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
     }
-
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
 }

src/main/java/ast/statementexpressions/crementexpressions/IncrementNode.java

@@ -5,9 +5,8 @@ import ast.statementexpressions.IStatementExpressionNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
-import visitor.Visitable;
 
-public class IncrementNode implements IStatementExpressionNode, Visitable {
+public class IncrementNode implements IStatementExpressionNode {
     public CrementType crementType;
     public AssignableNode assignableExpression;
 
@@ -20,9 +19,4 @@ public class IncrementNode implements IStatementExpressionNode, Visitable {
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
     }
-
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
 }

src/main/java/ast/statementexpressions/methodcallstatementnexpressions/ChainedMethodNode.java

@@ -22,6 +22,11 @@ public class ChainedMethodNode implements ASTNode, Visitable {
         expressions.add(expression);
     }
 
+    @Override
+    public void accept(MethodVisitor methodVisitor) {
+        methodVisitor.visit(this);
+    }
+
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return null;

src/main/java/bytecode/ClassCodeGen.java

@@ -27,7 +27,7 @@ public class ClassCodeGen implements ClassVisitor {
     private boolean generateClassFiles;
 
     public ClassCodeGen(JarOutputStream jarOutputStream, String outputDirectory, boolean generateJar, boolean generateClassFiles) {
-        this.mapper = new Mapper();
+        mapper = new Mapper();
         this.jarOutputStream = jarOutputStream;
         this.outputDirectory = outputDirectory;
         this.generateJar = generateJar;

src/main/java/bytecode/Mapper.java

@@ -3,7 +3,6 @@ package bytecode;
 import ast.parameters.ParameterNode;
 import ast.type.*;
 import ast.type.type.BaseType;
-import ast.type.type.ITypeNode;
 import ast.type.type.ReferenceType;
 import ast.type.type.TypeEnum;
 import org.objectweb.asm.Opcodes;
@@ -25,7 +24,7 @@ public class Mapper {
         return 0;
     }
 
-    public String generateMethodDescriptor(ITypeNode type, List<ParameterNode> parameters) {
+    public String generateMethodDescriptor(BaseType type, List<ParameterNode> parameters) {
         String descriptor = "(";
         for (ParameterNode parameterNode : parameters) {
             if(parameterNode.type instanceof BaseType) {
@@ -36,11 +35,7 @@ public class Mapper {
             }
         }
         descriptor += ")";
-        if(type instanceof BaseType) {
-            descriptor += getTypeChar((BaseType) type);
-        } else if(type instanceof ReferenceType) {
-            descriptor += "L" + ((ReferenceType) type).getIdentifier() +";";
-        }
+        descriptor += getTypeChar(type);
         return descriptor;
     }
 

src/main/java/bytecode/MethodCodeGen.java

@@ -14,7 +14,9 @@ import ast.statementexpressions.NewDeclarationNode;
 import ast.statementexpressions.crementexpressions.CrementType;
 import ast.statementexpressions.crementexpressions.DecrementNode;
 import ast.statementexpressions.crementexpressions.IncrementNode;
+import ast.statementexpressions.methodcallstatementnexpressions.ChainedMethodNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
+import ast.statementexpressions.methodcallstatementnexpressions.TargetNode;
 import ast.statements.*;
 import ast.type.ValueNode;
 import ast.type.type.BaseType;
@@ -69,7 +71,9 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
         // Visit all statements
         for (IStatementNode statementNode : constructorNode.block.statements) {
-            statementNode.accept(this);
+            if (statementNode != null) {
+                statementNode.accept(this);
+            }
         }
 
         methodVisitor.visitMaxs(0, 0);
@@ -101,7 +105,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     public void visit(MethodNode methodNode) {
         methodVisitor = classWriter.visitMethod(mapper.mapAccessTypeToOpcode(methodNode.accesModifier),
                 methodNode.getIdentifier(),
-                mapper.generateMethodDescriptor(methodNode.getType(), methodNode.parameters),
+                mapper.generateMethodDescriptor((BaseType) methodNode.getType(), methodNode.parameters),
                 null,
                 null);
 
@@ -237,7 +241,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
                 nonCalculationNode.unaryExpression.accept(this);
                 nonCalculationNode.expression.accept(this);
                 if (nonCalculationNode.unaryExpression.getType() instanceof BaseType && nonCalculationNode.expression.getType() instanceof BaseType) {
-                    methodVisitor.visitJumpInsn(IF_ICMPEQ, labelFalse);
+                    methodVisitor.visitJumpInsn(IF_ACMPEQ, labelFalse);
                 } else {
                     methodVisitor.visitJumpInsn(IF_ACMPEQ, labelFalse);
                 }
@@ -262,17 +266,9 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     @Override
     public void visit(MemberAccessNode memberAccessNode) {
         // Only used to get, not to put
-        int localVarIndex = localVariables.indexOf("memberAccessNode.identifier"); // TODO
-        if (localVarIndex >= 0) { // local var object
-            methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-        } else { // this field
-            methodVisitor.visitVarInsn(ALOAD, 0);
-        }
-
-        if (memberAccessNode.getTypeNode() instanceof BaseType) {
-            methodVisitor.visitFieldInsn(GETFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), mapper.getTypeChar((BaseType) memberAccessNode.getTypeNode()));
-        } else if (memberAccessNode.getTypeNode() instanceof ReferenceType) {
-            methodVisitor.visitFieldInsn(GETFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), "L" + ((ReferenceType) memberAccessNode.getTypeNode()).getIdentifier() + ";");
+        if (memberAccessNode.thisExpr) { // Field
+            // methodVisitor.visitFieldInsn(GETFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), );
+        } else { // Object Attribut
         }
     }
 
@@ -335,7 +331,6 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
             // else if statements
             methodVisitor.visitJumpInsn(IFEQ, elseIfLabels[0]);
         }
-
         ifElseNode.ifStatement.block.accept(this); // accept if block
 
         Label endLabel = new Label();
@@ -367,17 +362,22 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (localVariableDeclarationNode.expression != null) {
             // Process expression
             localVariableDeclarationNode.expression.accept(this);
-            // add local var to list if not in list
-            if (!localVariables.contains(localVariableDeclarationNode.identifier)) {
+            // Store result of expression in variable
+            if (localVariables.contains(localVariableDeclarationNode.identifier)) {
+                if (localVariableDeclarationNode.type instanceof BaseType) {
+                    methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
+                } else if (localVariableDeclarationNode.type instanceof ReferenceType) {
+                    methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
+                }
+            } else {
                 localVariables.add(localVariableDeclarationNode.identifier);
-            }
-            if (localVariableDeclarationNode.type instanceof BaseType) {
-                methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
-            } else if (localVariableDeclarationNode.type instanceof ReferenceType) {
-                methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
+                if (localVariableDeclarationNode.type instanceof BaseType) {
+                    methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
+                } else if (localVariableDeclarationNode.type instanceof ReferenceType) {
+                    methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
+                }
             }
         } else {
-            // Local var declaration
             if (!localVariables.contains(localVariableDeclarationNode.identifier)) {
                 localVariables.add(localVariableDeclarationNode.identifier);
             }
@@ -386,106 +386,40 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     @Override
     public void visit(AssignNode assignNode) {
-        if (assignNode.assignable.memberAccess != null) { // this / object
-            if (assignNode.expression instanceof IncrementNode) {
-                if (((IncrementNode) assignNode.expression).crementType.equals(CrementType.PREFIX)) { // ++i
-                    fieldOrObjectVarPrefixCrementAssign(assignNode);
-                } else { // i++
-                    fieldOrObjectVarSuffixCrementAssign(assignNode);
-                }
-            } else if (assignNode.expression instanceof DecrementNode) {
-                if (((DecrementNode) assignNode.expression).crementType.equals(CrementType.PREFIX)) {
-                    fieldOrObjectVarPrefixCrementAssign(assignNode);
-                } else {
-                    fieldOrObjectVarSuffixCrementAssign(assignNode);
-                }
-            } else {
-                assignFieldOrObjectVar(assignNode);
-            }
-        } else { // local var
-            if (assignNode.expression instanceof IncrementNode || assignNode.expression instanceof DecrementNode) {
-                localVarCrementAssign(assignNode);
-            } else {
-                assignNode.expression.accept(this);
-                assignLocalVar(assignNode);
-            }
-        }
-    }
-
-    private void localVarCrementAssign(AssignNode assignNode) {
+        // Process expression
         if (assignNode.expression instanceof IncrementNode) {
             IncrementNode incrementNode = (IncrementNode) assignNode.expression;
             if (incrementNode.crementType.equals(CrementType.PREFIX)) { // ++i
-                incrementNode.accept(this);
-                assignLocalVar(assignNode);
-            } else { // i++
-                loadBeforeCrement(assignNode);
-                assignLocalVar(assignNode);
-                incrementNode.accept(this);
+                methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
+                assign(assignNode);
+            } else if (incrementNode.crementType.equals(CrementType.SUFFIX)) { // Suffix: i++
+                assign(assignNode);
+                methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
             }
         } else if (assignNode.expression instanceof DecrementNode) {
             DecrementNode decrementNode = (DecrementNode) assignNode.expression;
             if (decrementNode.crementType.equals(CrementType.PREFIX)) {
-                decrementNode.accept(this);
-                assignLocalVar(assignNode);
-            } else {
-                loadBeforeCrement(assignNode);
-                assignLocalVar(assignNode);
-                decrementNode.accept(this);
+                methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), -1);
+                assign(assignNode);
+            } else if (decrementNode.crementType.equals(CrementType.SUFFIX)) {
+                assign(assignNode);
+                methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), 1);
             }
+        } else {
+            assignNode.expression.accept(this);
+            assign(assignNode);
         }
     }
 
-    private void fieldOrObjectVarPrefixCrementAssign(AssignNode assignNode) {
-        int localVarIndex = localVariables.indexOf(assignNode.assignable.identifier);
-        if(localVarIndex >= 0) { // object
-            methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-        } else if(assignNode.assignable.memberAccess.thisExpr) { // field
-            methodVisitor.visitVarInsn(ALOAD, 0);
+    private void assign(AssignNode assignNode) {
+        if (assignNode.assignable.memberAccess.thisExpr) {
+            assignField(assignNode);
         } else {
-            localVariables.add(assignNode.assignable.identifier);
-            methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
+            assignLocalVar(assignNode);
         }
-
-        assignNode.expression.accept(this);
-        methodVisitor.visitInsn(DUP_X1);
-
-        if (assignNode.expression instanceof BaseType) {
-            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) assignNode.expression.getType()));
-        } else if (assignNode.expression instanceof ReferenceType) {
-            ReferenceType referenceType = (ReferenceType) assignNode.expression.getType();
-            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), "L" + referenceType.getIdentifier() + ";");
-        }
-    }
-
-    private void fieldOrObjectVarSuffixCrementAssign(AssignNode assignNode) {
-        int localVarIndex = localVariables.indexOf(assignNode.assignable.identifier);
-        if(localVarIndex >= 0) { // object
-            methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-        } else if(assignNode.assignable.memberAccess.thisExpr) { // field
-            methodVisitor.visitVarInsn(ALOAD, 0);
-        } else {
-            localVariables.add(assignNode.assignable.identifier);
-            methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
-        }
-
-        loadBeforeCrement(assignNode);
-        
-        if (assignNode.expression instanceof BaseType) {
-            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) assignNode.expression.getType()));
-        } else if (assignNode.expression instanceof ReferenceType) {
-            ReferenceType referenceType = (ReferenceType) assignNode.expression.getType();
-            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), "L" + referenceType.getIdentifier() + ";");
-        }
-
-        assignNode.expression.accept(this);
     }
 
     private void assignLocalVar(AssignNode assignNode) {
-        methodVisitor.visitInsn(DUP);
-        if (!localVariables.contains(assignNode.assignable.identifier)) {
-            localVariables.add(assignNode.assignable.identifier);
-        }
         if (assignNode.expression instanceof BaseType) {
             methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(assignNode.assignable.identifier));
         } else if (assignNode.expression instanceof ReferenceType) {
@@ -493,105 +427,12 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         }
     }
 
-    private void assignFieldOrObjectVar(AssignNode assignNode) {
-        int localVarIndex = localVariables.indexOf(assignNode.assignable.identifier);
-        if (localVarIndex >= 0) { // object
-            methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-        } else if (assignNode.assignable.memberAccess.thisExpr) { // this
-            methodVisitor.visitVarInsn(ALOAD, 0);
-        } else {
-            localVariables.add(assignNode.assignable.identifier);
-            methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
-        }
-
-        assignNode.expression.accept(this);
-        methodVisitor.visitInsn(DUP_X1);
-
+    private void assignField(AssignNode assignNode) {
         if (assignNode.expression instanceof BaseType) {
             methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) assignNode.expression.getType()));
         } else if (assignNode.expression instanceof ReferenceType) {
             ReferenceType referenceType = (ReferenceType) assignNode.expression.getType();
-            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), "L" + referenceType.getIdentifier() + ";");
-        }
-    }
-
-    private void loadBeforeCrement(AssignNode assignNode) {
-        if(assignNode.expression instanceof IncrementNode) {
-            IncrementNode incrementNode = (IncrementNode) assignNode.expression;
-            if(incrementNode.assignableExpression.memberAccess != null) {
-                incrementNode.assignableExpression.memberAccess.accept(this);
-            } else {
-                if(assignNode.assignable.getTypeNode() instanceof BaseType) {
-                    methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(assignNode.assignable.identifier));
-                } else if(assignNode.assignable.getTypeNode() instanceof ReferenceType) {
-                    methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
-                }
-            }
-        } else if(assignNode.expression instanceof DecrementNode) {
-            DecrementNode decrementNode = (DecrementNode) assignNode.expression;
-            if(decrementNode.assignableExpression.memberAccess != null) {
-                decrementNode.assignableExpression.memberAccess.accept(this);
-            } else {
-                if(assignNode.assignable.getTypeNode() instanceof BaseType) {
-                    methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(assignNode.assignable.identifier));
-                } else if(assignNode.assignable.getTypeNode() instanceof ReferenceType) {
-                    methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
-                }
-            }
-        }
-    }
-
-    @Override
-    public void visit(IncrementNode incrementNode) {
-        if (incrementNode.assignableExpression.memberAccess != null) { // Object var / field
-            int localVarIndex = localVariables.indexOf(incrementNode.assignableExpression.identifier);
-            if (localVarIndex >= 0) { // object
-                methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-            } else { // this
-                methodVisitor.visitVarInsn(ALOAD, 0);
-            }
-            if (incrementNode.assignableExpression.memberAccess.getTypeNode() instanceof BaseType) {
-                methodVisitor.visitFieldInsn(GETFIELD, incrementNode.assignableExpression.memberAccess.identifiers.get(0), incrementNode.assignableExpression.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) incrementNode.assignableExpression.memberAccess.getTypeNode()));
-            } else if (incrementNode.assignableExpression.memberAccess.getTypeNode() instanceof ReferenceType) {
-                methodVisitor.visitFieldInsn(GETFIELD, incrementNode.assignableExpression.memberAccess.identifiers.get(0), incrementNode.assignableExpression.memberAccess.identifiers.get(1), "L" + (((ReferenceType) incrementNode.assignableExpression.memberAccess.getTypeNode()).getIdentifier() + ";"));
-            }
-            methodVisitor.visitInsn(DUP);
-            methodVisitor.visitInsn(ICONST_1);
-            methodVisitor.visitInsn(IADD);
-            if (incrementNode.assignableExpression.memberAccess.getTypeNode() instanceof BaseType) {
-                methodVisitor.visitFieldInsn(PUTFIELD, incrementNode.assignableExpression.memberAccess.identifiers.get(0), incrementNode.assignableExpression.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) incrementNode.assignableExpression.memberAccess.getTypeNode()));
-            } else if (incrementNode.assignableExpression.memberAccess.getTypeNode() instanceof ReferenceType) {
-                methodVisitor.visitFieldInsn(PUTFIELD, incrementNode.assignableExpression.memberAccess.identifiers.get(0), incrementNode.assignableExpression.memberAccess.identifiers.get(1), "L" + (((ReferenceType) incrementNode.assignableExpression.memberAccess.getTypeNode()).getIdentifier() + ";"));
-            }
-        } else { // local var
-            methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
-        }
-    }
-
-    @Override
-    public void visit(DecrementNode decrementNode) {
-        if (decrementNode.assignableExpression.memberAccess != null) { // Object var / field
-            int localVarIndex = localVariables.indexOf(decrementNode.assignableExpression.identifier);
-            if (localVarIndex >= 0) { // object
-                methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-            } else { // this
-                methodVisitor.visitVarInsn(ALOAD, 0);
-            }
-            methodVisitor.visitInsn(DUP);
-            if (decrementNode.assignableExpression.memberAccess.getTypeNode() instanceof BaseType) {
-                methodVisitor.visitFieldInsn(GETFIELD, decrementNode.assignableExpression.memberAccess.identifiers.get(0), decrementNode.assignableExpression.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) decrementNode.assignableExpression.memberAccess.getTypeNode()));
-            } else if (decrementNode.assignableExpression.memberAccess.getTypeNode() instanceof ReferenceType) {
-                methodVisitor.visitFieldInsn(GETFIELD, decrementNode.assignableExpression.memberAccess.identifiers.get(0), decrementNode.assignableExpression.memberAccess.identifiers.get(1), "L" + (((ReferenceType) decrementNode.assignableExpression.memberAccess.getTypeNode()).getIdentifier() + ";"));
-            }
-            methodVisitor.visitInsn(ICONST_1);
-            methodVisitor.visitInsn(ISUB);
-            if (decrementNode.assignableExpression.memberAccess.getTypeNode() instanceof BaseType) {
-                methodVisitor.visitFieldInsn(PUTFIELD, decrementNode.assignableExpression.memberAccess.identifiers.get(0), decrementNode.assignableExpression.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) decrementNode.assignableExpression.memberAccess.getTypeNode()));
-            } else if (decrementNode.assignableExpression.memberAccess.getTypeNode() instanceof ReferenceType) {
-                methodVisitor.visitFieldInsn(PUTFIELD, decrementNode.assignableExpression.memberAccess.identifiers.get(0), decrementNode.assignableExpression.memberAccess.identifiers.get(1), "L" + (((ReferenceType) decrementNode.assignableExpression.memberAccess.getTypeNode()).getIdentifier() + ";"));
-            }
-        } else { // local var
-            methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), -1);
+            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), "L"+referenceType.getIdentifier()+";");
         }
     }
 
@@ -604,7 +445,8 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
             expressionNode.accept(this);
             parameterNodes.add(new ParameterNode(expressionNode.getType(), ""));
         }
-        methodVisitor.visitMethodInsn(INVOKESPECIAL, newDeclarationNode.identifier, "<init>", mapper.generateMethodDescriptor(new BaseType(TypeEnum.VOID), parameterNodes), false);
+        methodVisitor.visitMethodInsn(INVOKESPECIAL, newDeclarationNode.identifier, "<init>", mapper.generateMethodDescriptor(new BaseType(TypeEnum.VOID),parameterNodes), false);
+        localVariables.add(newDeclarationNode.identifier);
     }
 
     @Override
@@ -676,13 +518,19 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         methodVisitor.visitLabel(endOfLoopLabel);
     }
 
+    @Override
+    public void visit(ChainedMethodNode chainedMethodNode) {
+        // TODO: Erstmal abwarten
+    }
+
     @Override
     public void visit(MethodCallNode methodCallNode) {
         List<ParameterNode> parameterNodes = new ArrayList<>();
-        for (IExpressionNode expressionNode : methodCallNode.parameters) {
+        for(IExpressionNode expressionNode : methodCallNode.parameters) {
             expressionNode.accept(this);
             parameterNodes.add(new ParameterNode(expressionNode.getType(), ""));
         }
-        methodVisitor.visitMethodInsn(INVOKEVIRTUAL, methodCallNode.target.memberAccess.identifiers.get(0), methodCallNode.identifier, mapper.generateMethodDescriptor(methodCallNode.type, parameterNodes), false);
+        // TODO: Klassenname und Returntype
+        //methodVisitor.visitMethodInsn(INVOKEVIRTUAL, classname, methodCallNode.identifier, mapper.generateMethodDescriptor(returntype, parameterNodes), false);
     }
 }

src/main/java/bytecode/visitor/ClassVisitor.java

@@ -5,5 +5,6 @@ import ast.members.FieldNode;
 
 public interface ClassVisitor {
     void visit(ClassNode classNode);
+
     void visit(FieldNode fieldNode);
 }

src/main/java/bytecode/visitor/MethodVisitor.java

@@ -39,14 +39,12 @@ public interface MethodVisitor {
     // statements
     void visit(IfElseNode ifElseNode);
 
-    void visit(IncrementNode incrementNode);
-    void visit(DecrementNode decrementNode);
-
     void visit(LocalVariableDeclarationNode localVariableDeclarationNode);
     void visit(ReturnNode returnNode);
     void visit(WhileNode whileNode);
 
     // statement expression
+    void visit(ChainedMethodNode chainedMethodNode);
     void visit(MethodCallNode methodCallNode);
 
     void visit(AssignNode assignNode);

src/main/java/semantic/SemanticAnalyzer.java

@@ -253,7 +253,6 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
         if (toCheck.memberAccess != null) {
             var result = toCheck.memberAccess.accept(this);
-            toCheck.identifier = toCheck.memberAccess.identifiers.getLast();
             toCheck.setTypeNode(result.getType());
             return result;
         } else {
@@ -317,13 +316,9 @@ public class SemanticAnalyzer implements SemanticVisitor {
     @Override
     public TypeCheckResult analyze(IfElseNode toCheck) {
         var resultIf = toCheck.ifStatement.accept(this);
-        if(toCheck.elseStatement != null){
-            var resultElse = toCheck.elseStatement.accept(this);
-            return new TypeCheckResult(resultIf.isValid() && resultElse.isValid(), new BaseType(TypeEnum.VOID));
-        }
+        var resultElse = toCheck.elseStatement.accept(this);
 
-
-        return new TypeCheckResult(resultIf.isValid(), new BaseType(TypeEnum.VOID));
+        return new TypeCheckResult(resultIf.isValid() && resultElse.isValid(), new BaseType(TypeEnum.VOID));
     }
 
     @Override
@@ -609,15 +604,11 @@ public class SemanticAnalyzer implements SemanticVisitor {
         ITypeNode currentType = null;
         int start = 0;
         if(!memberAccessNode.identifiers.isEmpty()){
-            if(currentFields.get(memberAccessNode.identifiers.getFirst()) != null){
-                memberAccessNode.identifiers.addFirst(currentClass.identifier);
-                start++;
+            if(currentFields.get(memberAccessNode.identifiers.get(0)) != null){
+                memberAccessNode.identifiers.add(0, currentClass.identifier);
+                start = 1;
             }
         }
-        if(context.getClasses().get(memberAccessNode.identifiers.getFirst()) == null){
-            memberAccessNode.identifiers.addFirst(currentClass.identifier);
-            start++;
-        }
         for (int i = start; i < memberAccessNode.identifiers.size(); i++) {
 
             String s = memberAccessNode.identifiers.get(i);
@@ -635,8 +626,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
             } else {
                 if (currentType instanceof ReferenceType reference) {
                     var currentTypeClass = context.getClass(reference.getIdentifier());
-                    memberAccessNode.identifiers.add(i, reference.getIdentifier());
-                    i++;
+
                     var currentField = currentTypeClass.getField(s);
                     if (currentField.getAccessModifier().accessType == EnumAccessModifierNode.PUBLIC) {
                         currentType = currentField.getType();

src/test/Makefile

@@ -12,6 +12,12 @@ compile-raupenpiler:
 	cd ../.. ; mvn exec:java -DgenJar=true -DgenClass=true -Dexec.mainClass="main.Main"  -Dexec.args="'src/main/resources/input/CompilerInput.java' 'src/main/resources/output'"
 	# cp ../main/resources/output/CompilerInput.class .java/resources/output/raupenpiler
 
+test: compile-javac compile-raupenpiler test-javac test-raupenpiler
+
+test-javac:
+	# gleich wie bei raupenpiler, kann ich ohne funktionierenden Compiler nicht testen
+
+
 test-raupenpiler:
 	# move the compiled class to the test/main folder
 	mv ../main/resources/output/CompilerInput.class .java/main/

src/test/java/main/E2EReflectionsTest.java

@@ -88,7 +88,7 @@ public class E2EReflectionsTest {
                 for (Field raupenpilerField : raupenpilerLoadedClassDeclaredFields) {
                     if (field.getName().equals(raupenpilerField.getName())) {
                         assertEquals(field.getType(), raupenpilerField.getType());
-                        //  assertEquals(field.getModifiers(), raupenpilerField.getModifiers());
+                      //  assertEquals(field.getModifiers(), raupenpilerField.getModifiers());
                     }
                 }
             }

src/test/java/semantic/EndToTypedAstTest.java

@@ -338,17 +338,6 @@ public class EndToTypedAstTest {
 
     }
 
-    @Test
-    public void Expression(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/Expression.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-
-    }
-
     // ------------------ Helpers ------------------
 
     /**

src/test/resources/input/singleFeatureSemanticTests/Expression.java

@@ -1,10 +0,0 @@
-class VariableCompare{
-
-    void trueMethod(boolean a, int c) {
-        if(a && c == 10){
-
-        }
-    }
-
-
-}

src/test/resources/input/typedAstFeatureTests/CorrectTest.java

@@ -1,16 +1,13 @@
-public class Compiler {
-    Node node;
-    public int add(int i, int j) {
-        node = new Node();
-        node.x = 1;
-        return i+j;
-    }
-}
+public class Klasse1 {
+    public int test;
 
-public class Node {
-    public int x;
-    public void main() {
-        Compiler compiler = new Compiler();
-        int i = compiler.add(5, 8);
+    public int test1() {
+        test = 5;
+        return 1;
+    }
+
+    public void test2() {
+        int testInt;
+        testInt = this.test1();
     }
 }