.gitignore

@@ -77,10 +77,10 @@ fabric.properties
 .idea/caches/build_file_checksums.ser
 
 /target
-src/main/resources/logs/miniCompilerLog.log
-src/test/java/main/CompilerInput.class
+src/main/resources/logs/RaupenLog.log
+src/main/resources/output/CompilerInput.class
 src/test/resources/output/javac/CompilerInput$Test.class
 src/test/resources/output/javac/CompilerInput.class
-src/test/resources/output/miniCompiler/CompilerInput.class
-src/test/resources/output/miniCompiler/CompilerInput$Test.class
+src/test/resources/output/raupenpiler/CompilerInput.class
+src/test/resources/output/raupenpiler/CompilerInput$Test.class
 .idea/inspectionProfiles/Project_Default.xml

.lib/Kurzdokumentation.md

@@ -0,0 +1,58 @@
+# Kurzdokumentation
+
+## Aufgabenverteilung
+
+### Maximilian Stahl und Jannik Rombach:
+- **Scanner**
+- **Parser**
+- **AST**
+- **AstBuilder**
+    - **Modul: ast**
+        - Alle
+    - **Modul: parser**
+        - Alle
+    - **Modul: visitor**
+        - Alle
+    - **Testmodul: parser**
+        - AstBuildertest.java
+        - Helper.java
+    - **Testfiles: singleFeatureTests**
+        - Alle
+
+### Johannes Ehlert:
+- **Semantische Analyse**
+    - **Modul: semantic**
+    - **Modul: typecheck**
+    - **Testmodul: parser**
+        - AstBuildertest.java
+    - **Testfiles: typedAstFeatureTests**
+        - Großteil
+    - **Testfiles: typedAstExceptionsTests**
+        - Großteil
+
+### David Große:
+- **Bytecodegenerator**
+    - **Modul: bytecode**
+        - Alle
+
+### Lucas Janker:
+- **Tests**
+    - **Modul: main**
+        - Alle
+    - **Testmodul: main**
+        - Alle
+    - **Testmodul: parser**
+        - ScannerTest.java
+        - ParserTest.java
+    - **Testmodul: semantic**
+    - **Testfiles: combinedFeatureTests**
+        - Alle
+    - **Testfiles: failureTests**
+        - Alle
+    - **Testfiles: Alle**
+        - Refactoring
+    - **Ordnerstrukturen**
+        - Großteil
+    - **Build**
+    - **Makefile**
+    - **Dokumentation**

Makefile

@@ -1,37 +0,0 @@
-### IntelliJs play buttons do not work. Run in "src/test" folder with "make" command to run all
-### Or run only parts with "make compile-javac", "make clean" etc.
-
-all: compile-javac compile-miniCompiler
-
-compile-javac:
-	#javac -d src/test/resources/output/javac src/test/resources/input/CompilerInput.java
-
-compile-miniCompiler:
-	cd ../.. ; mvn -DskipTests install
-	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 src/main/resources/output/CompilerInput.class src/test/resources/output/miniCompiler
-
-test-miniCompiler:
-	# move the compiled class to the test/main folder
-	mv src/main/resources/output/CompilerInput.class src/test/java/main/
-	# compile the test class
-	javac src/test/java/main/EndToEndTester.java
-	# run the test class
-	java -cp src/test/java/main EndToEndTester
-
-clean:
-	# clean main output folders
-	rm -f src/main/resources/output/*.class
-	rm -f src/main/resources/output/*.jar
-	# clean resources output folders
-	rm -f src/test/resources/output/javac/*.class
-	rm -f src/test/resources/output/miniCompiler/*.class
-	rm -f src/test/resources/output/miniCompiler/*.jar
-	# clean logs
-	rm -f src/main/resources/logs/*
-	# clean test/java/main folders from .class files for End-to-End tests
-	rm -f src/test/java/main/*.class
-	# clean javac output from every folder
-	rm -f src/test/resources/input/*/*.class
-	# clean test results from maven surefire plugin
-	rm -f ../../target/surefire-reports/*.txt

README.md

@@ -1,136 +0,0 @@
-# "Nicht Haskel 2.0" Java Compiler
-
-Realisation of a subset of the Java Standard Compiler in the course Compiler Construction of the 4th semester Computer Science at the Duale Hochschule Stuttgart (Horb).
-
-This project aims to provide a simplified version of the Java compiler, focusing on key language features and demonstrating the principles of compiler construction.
-
-## Realised Java syntax
-
-- **Data types**: `int`, `boolean`, `char`
-- **Access modifier**: `public`, `protected`, `private`
-- **Operators**: `=` `+` `-` `*` `%` `/` `>` `<` `>=` `<=` `==` `!=` `!` `&&` `||` `++` `--`
-- **Keywords**: `class`, `this`, `while`, `do`, `if`, `else`, `for`, `return`, `new`, `switch`, `case`, `break`, `default`, `:`
-- **Statements**:
-    - `if` ... `if else` ... `else`;
-    - `while` ... ;
-    - `do` ... `while`;
-    - `for`;
-- **Comments**:
-    - Single line: `// comment`
-    - Multi-line: `/* comment */`
-- **Further functions**:
-    - All methods are overloadable
-    - High maintainability and expandability through implementation of the visitor pattern
-    - Logging Input and Outputs
-    - Error Handling in the Semantic Check
-
-## Project Structure
-
-```plain
-src/
-└── main/
-    ├── java/
-    │   ├── ast/              -> Defining the structure of the AST
-    │   ├── bytecode/         -> Generate Java bytecode
-    │   ├── main/             -> Running the compiler
-    │   ├── parser/
-    │   │   ├── astBuilder/   -> Builder creating the AST
-    │   │   ├── generated/    -> Antlr generated grammar
-    │   │   └── grammar/      -> Antlr grammar
-    │   ├── semantic/         -> Running the semantic check
-    │   └── visitor/          -> Visitor interface
-    └── resources/
-test/
-└── java/
-  │ ├── main/                 -> Running E2E tests 
-  │ ├── parser/               -> Performs tests on the parser
-  │ ├── semantic/             -> Performs tests on the semantic check
-  └── resources/              -> Ressources for running the Tests
-```
-
-## Class-Diagramm AST
-
-![AST Diagramm](ast.png)
-
-## Distribution of the realisation
-
-### i22030 & i22035
-Ausführliche Beschreibung der Parser Umsetzung:
-
-![Parserumsetzung](Parser_Dokumentation.pdf)
-
-Parser:
-- Grammar -> (src/main/java/parser/grammar)
-- Scanner 
-- Parser
-- Abstract Syntax Tree (AST) -> (src/main/java/ast)
-- AstBuilder -> (src/main/java/parser/astBuilder)
-
-Parser tests:
-- ParserTests -> (src/test/java/parser)
-- TestCases -> (src/test/resources/input/singeFeatureTests)
-
-Other:
-- Documentation -> (README.md)
-- Ast Class-Diagramm -> (ast.png) 
-- PowerPoint
-
-### i22005
-Semantic check:
-- Set all types and check whether types have been used correctly
-- Contexts -> (src/main/java/semantic/context)
-- Exceptions Handling -> (src/main/java/semantic/exceptions)
-
-Semantic Tests:
-- Typing and Type checking -> (src/test/java/semantic/EndToTypedAstTest)
-- Exception and feature test -> (src/test/resources/input/typedAstExceptionsTests)
-
-### i22007
-Bytecode generation:
-- Complete bytecode generation -> (src/mein/java/bytecode)
-
-### i22011
-Tests and execution:
-- Makefile
-- Running Compiler -> (src/main/main)
-- Running E2E tests -> (src/test/main)
-- Typing and Type checking -> (src/test/java/semantic/EndToTypedAstTest)
-
-
-## Used Tools
-
-- [Maven 4.0](https://maven.apache.org/index.html)
-  - Used for automating the build process and managing dependencies.
-- [ANTLR4 v.13.1](https://www.antlr.org/)
-  - Used to parse the input Java code into the Abstract Syntax Tree.
-
-## How to run the compiler
-### Possibilities
-### 1. Start miniCompiler using make:
-Make needs to be installed
-```bash
-cd .\src\test\ ; make clean compile-miniCompiler
-```
-
-### 2. Start miniCompiler using jar:
-If you do not have the .jar, download it [here](https://gitea.hb.dhbw-stuttgart.de/i22005/NichtHaskell2.0/src/branch/main/JavaCompiler-1.0-jar-with-dependencies.jar) or compile it using mvn package or make first
-```
-java.exe -DgenJar=bool -DgenClass=bool -jar path_to_jar\jarName.jar 'path_to_input_file.java' 'path_to_output_directory'
-```
-
-Example (jar needs to be in the target directory)
-```bash
- java.exe -DgenJar=true -DgenClass=true -jar .\target\JavaCompiler-1.0-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output'
-```
-
-- set DgenJar true, to generate the jar, false for no jar
-
-```
- DgenJar=true
-```
-
-- set DgenClass true, to generate class files, false for no class files
-
-```
- DgenClass=true
- ```

pom.xml

@@ -23,24 +23,6 @@
             <version>5.11.0-M2</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.junit.platform</groupId>
-            <artifactId>junit-platform-suite-engine</artifactId>
-            <version>1.11.0-M2</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>5.11.0-M2</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.13.1</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.antlr</groupId>
             <artifactId>antlr4-runtime</artifactId>
@@ -62,6 +44,18 @@
             <version>3.26.0</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.11.0-M2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.11.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -71,11 +65,6 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version>3.0.0-M5</version> <!-- Change the version as needed -->
-                <configuration>
-                    <includes>
-                        <include>**/*Test.java</include>
-                    </includes>
-                </configuration>
             </plugin>
             <plugin>
                 <artifactId>maven-assembly-plugin</artifactId>

src/main/java/ast/ASTNode.java

@@ -1,6 +1,20 @@
 package ast;
 
+import bytecode.visitor.ClassVisitor;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
+
 public interface ASTNode {
+
+    //Todo: @BruderJohn & @i22007 Interface anwenden + geeignetetn Methodename.
+
+    /*
+    Typecheck:
+    public TypeCheckResult acceptType(SemanticVisitor visitor);
+
+    Bytecode:
+    public void accepByteCode(ClassVisitor classVisitor);
+     */
 }
 
 

src/main/java/ast/ClassNode.java

@@ -1,11 +1,12 @@
 package ast;
 
 import ast.type.AccessModifierNode;
+import ast.members.ConstructorNode;
 import ast.members.MemberNode;
 import ast.members.MethodNode;
 import bytecode.visitor.ClassVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 import java.util.ArrayList;
@@ -16,11 +17,11 @@ public class ClassNode implements ASTNode, Visitable {
     public String identifier;
     public List<MemberNode> members = new ArrayList<>();
 
-    public ClassNode() {
+    public ClassNode(){
 
     }
 
-    public ClassNode(String accessType, String identifier) {
+    public ClassNode(String accessType, String identifier){
         this.accessType = new AccessModifierNode(accessType);
         this.identifier = identifier;
     }
@@ -29,7 +30,7 @@ public class ClassNode implements ASTNode, Visitable {
         members.add(member);
     }
 
-    public List<MethodNode> getMethods() {
+    public List<MethodNode> getMethods(){
         List<MethodNode> methods = new ArrayList<>();
         for (MemberNode member : members) {
             if (member instanceof MethodNode methodNode) {

src/main/java/ast/ProgramNode.java

@@ -2,7 +2,7 @@ package ast;
 
 import bytecode.visitor.ProgramVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 import java.util.ArrayList;

src/main/java/ast/expressions/binaryexpressions/BinaryNode.java

@@ -4,12 +4,12 @@ import ast.expressions.IExpressionNode;
 import ast.type.type.*;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 public class BinaryNode implements IExpressionNode, Visitable {
 
-    public ITypeNode typeNode;
+    private ITypeNode typeNode;
 
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {

src/main/java/ast/expressions/binaryexpressions/CalculationNode.java

@@ -1,13 +1,15 @@
 package ast.expressions.binaryexpressions;
 
+import ast.type.type.*;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class CalculationNode extends BinaryNode {
     public CalculationNode calculationExpression;
     public EnumLineOperator operator;
     public DotNode dotExpression;
+    private ITypeNode typeNode;
 
     public CalculationNode(CalculationNode calculationExpression, String operator, DotNode dotExpression) {
         this.calculationExpression = calculationExpression;
@@ -19,11 +21,11 @@ public class CalculationNode extends BinaryNode {
         this.dotExpression = dotExpression;
     }
 
-    public void setOperator(String operator) {
-        if (operator != null) {
-            if (operator.equals("+")) {
+    private void setOperator(String operator) {
+        if(operator != null) {
+            if(operator.equals("+")) {
                 this.operator = EnumLineOperator.PLUS;
-            } else if (operator.equals("-")) {
+            } else if(operator.equals("-")) {
                 this.operator = EnumLineOperator.MINUS;
             }
         }

src/main/java/ast/expressions/binaryexpressions/DotNode.java

@@ -2,28 +2,30 @@ package ast.expressions.binaryexpressions;
 
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class DotNode extends BinaryNode {
     public DotNode dotExpression;
     public EnumDotOperator operator;
-    public DotSubtractionNode dotSubtractionExpression;
+    public DotSubstractionNode dotSubstractionExpression;
 
-    public DotNode(DotNode dotExpression, String operator, DotSubtractionNode dotSubtractionExpression) {
+    public DotNode(DotNode dotExpression, String operator, DotSubstractionNode dotSubstractionExpression) {
         this.dotExpression = dotExpression;
         setOperator(operator);
-        this.dotSubtractionExpression = dotSubtractionExpression;
+        this.dotSubstractionExpression = dotSubstractionExpression;
     }
 
-    public DotNode(DotSubtractionNode dotSubtractionExpression) {
-        this.dotSubtractionExpression = dotSubtractionExpression;
+    public DotNode(DotSubstractionNode dotSubstractionExpression) {
+        this.dotSubstractionExpression = dotSubstractionExpression;
     }
 
-    public void setOperator(String operator) {
-        switch (operator) {
-            case "*" -> this.operator = EnumDotOperator.MULT;
-            case "/" -> this.operator = EnumDotOperator.DIV;
-            case "%" -> this.operator = EnumDotOperator.MOD;
+    private void setOperator(String operator) {
+        if(operator.equals("*")) {
+            this.operator = EnumDotOperator.MULT;
+        } else if(operator.equals("/")) {
+            this.operator = EnumDotOperator.DIV;
+        } else if(operator.equals("%")) {
+            this.operator = EnumDotOperator.MOD;
         }
     }
 

src/main/java/ast/expressions/binaryexpressions/DotSubstractionNode.java

@@ -2,31 +2,32 @@ package ast.expressions.binaryexpressions;
 
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
+import ast.type.type.*;
 import ast.type.ValueNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
-public class DotSubtractionNode extends BinaryNode {
+public class DotSubstractionNode extends BinaryNode {
     public ValueNode value;
     public String identifier;
     public MemberAccessNode memberAccess;
     public MethodCallNode methodCall;
     public CalculationNode calculationExpression;
 
-    public DotSubtractionNode(ValueNode value) {
+    public DotSubstractionNode(ValueNode value) {
         this.value = value;
     }
 
-    public DotSubtractionNode(String identifier) {
+    public DotSubstractionNode(String identifier) {
         this.identifier = identifier;
     }
 
-    public DotSubtractionNode(MemberAccessNode memberAccess) {
+    public DotSubstractionNode(MemberAccessNode memberAccess) {
         this.memberAccess = memberAccess;
     }
 
-    public DotSubtractionNode(MethodCallNode methodCall, CalculationNode calculationExpression) {
+    public DotSubstractionNode(MethodCallNode methodCall, CalculationNode calculationExpression) {
         this.methodCall = methodCall;
         this.calculationExpression = calculationExpression;
     }

src/main/java/ast/expressions/binaryexpressions/NonCalculationNode.java

@@ -2,9 +2,10 @@ package ast.expressions.binaryexpressions;
 
 import ast.expressions.IExpressionNode;
 import ast.expressions.unaryexpressions.UnaryNode;
+import ast.type.type.*;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class NonCalculationNode extends BinaryNode {
     public UnaryNode unaryExpression;
@@ -17,16 +18,23 @@ public class NonCalculationNode extends BinaryNode {
         this.expression = expression;
     }
 
-    public void setOperator(String operator) {
-        switch (operator) {
-            case "&&" -> this.operator = EnumNonCalculationOperator.AND;
-            case "||" -> this.operator = EnumNonCalculationOperator.OR;
-            case ">" -> this.operator = EnumNonCalculationOperator.GREATER;
-            case "<" -> this.operator = EnumNonCalculationOperator.LESS;
-            case ">=" -> this.operator = EnumNonCalculationOperator.GREATER_EQUAL;
-            case "<=" -> this.operator = EnumNonCalculationOperator.LESS_EQUAL;
-            case "==" -> this.operator = EnumNonCalculationOperator.EQUAL;
-            case "!=" -> this.operator = EnumNonCalculationOperator.NOT_EQUAL;
+    private void setOperator(String operator) {
+        if(operator.equals("&&")) {
+            this.operator = EnumNonCalculationOperator.AND;
+        } else if(operator.equals("||")) {
+            this.operator = EnumNonCalculationOperator.OR;
+        } else if(operator.equals(">")) {
+            this.operator = EnumNonCalculationOperator.GREATER;
+        } else if(operator.equals("<")) {
+            this.operator = EnumNonCalculationOperator.LESS;
+        } else if(operator.equals(">=")) {
+            this.operator = EnumNonCalculationOperator.GREATER_EQUAL;
+        } else if(operator.equals("<=")) {
+            this.operator = EnumNonCalculationOperator.LESS_EQUAL;
+        } else if(operator.equals("==")) {
+            this.operator = EnumNonCalculationOperator.EQUAL;
+        } else if(operator.equals("!=")) {
+            this.operator = EnumNonCalculationOperator.NOT_EQUAL;
         }
     }
 

src/main/java/ast/expressions/unaryexpressions/MemberAccessNode.java

@@ -1,11 +1,10 @@
 package ast.expressions.unaryexpressions;
 
 import ast.ASTNode;
-import ast.type.type.ITypeNode;
 import bytecode.visitor.MethodVisitor;
-
+import ast.type.type.ITypeNode;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 import java.util.ArrayList;
@@ -41,5 +40,4 @@ public class MemberAccessNode implements ASTNode, Visitable {
         this.typeNode = typeNode;
     }
 
-
 }

src/main/java/ast/expressions/unaryexpressions/NotNode.java

@@ -1,12 +1,13 @@
 package ast.expressions.unaryexpressions;
 
+import ast.ASTNode;
 import ast.expressions.IExpressionNode;
-import ast.type.type.ITypeNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
+import visitor.Visitable;
 
-public class NotNode implements IExpressionNode {
+public class NotNode implements ASTNode, Visitable {
     public IExpressionNode expression;
 
     public NotNode(IExpressionNode expression) {
@@ -23,13 +24,4 @@ public class NotNode implements IExpressionNode {
         return null;
     }
 
-    @Override
-    public ITypeNode getType() {
-        return expression.getType();
-    }
-
-    @Override
-    public void setType(ITypeNode type) {
-        this.expression.setType(type);
-    }
 }

src/main/java/ast/expressions/unaryexpressions/UnaryNode.java

@@ -6,7 +6,7 @@ import ast.type.type.*;
 import ast.type.ValueNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 import java.util.Objects;
 
@@ -18,10 +18,10 @@ public class UnaryNode implements IExpressionNode {
     public NotNode notExpression;
     public IStatementNode statement;
     public IExpressionNode expression;
-    public ITypeNode type;
+    private ITypeNode type;
 
     public UnaryNode(String value) {
-        if (Objects.equals(value, "this")) {
+        if(Objects.equals(value, "this")) {
             this.thisExp = "this";
         } else {
             this.identifier = value;

src/main/java/ast/literal/BooleanLiteralNode.java

@@ -0,0 +1,11 @@
+package ast.literal;
+
+public class BooleanLiteralNode {
+    private String value;
+
+    public BooleanLiteralNode(String value) {this.value = value;}
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/ast/literal/CharLiteralNode.java

@@ -0,0 +1,11 @@
+package ast.literal;
+
+public class CharLiteralNode {
+    public String value;
+
+    public CharLiteralNode(String value) {this.value = value;}
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/ast/literal/LiteralNode.java

@@ -0,0 +1,31 @@
+package ast.literal;
+
+import ast.expressions.IExpressionNode;
+import ast.type.type.ITypeNode;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
+
+public class LiteralNode implements IExpressionNode {
+
+    public String value;
+    private ITypeNode type;
+
+    public LiteralNode(String value, ITypeNode type) {
+        this.value = value;
+        this.type = type;
+    }
+
+    public ITypeNode getType() {
+        return type;
+    }
+
+    public void setType(ITypeNode type) {
+        this.type = type;
+    }
+
+
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return null;
+    }
+}

src/main/java/ast/members/ConstructorNode.java

@@ -11,8 +11,13 @@ import java.util.List;
 import java.util.Objects;
 
 public class ConstructorNode extends MethodNode implements Visitable {
+    public AccessModifierNode accessType;
+    public String identifier;
+    public List<ParameterNode> parameters = new ArrayList<>();
+    public BlockNode block;
+
     public ConstructorNode(String accessType, String identifier, BlockNode block) {
-        this.accesModifier = new AccessModifierNode(accessType);
+        this.accessType = new AccessModifierNode(accessType);
         this.identifier = identifier;
         this.block = block;
     }
@@ -27,7 +32,8 @@ public class ConstructorNode extends MethodNode implements Visitable {
     }
 
     public boolean isSame(MethodNode methodNode) {
-        if (!(Objects.equals(this.identifier, methodNode.getIdentifier())) || getParameters().size() != methodNode.getParameters().size()) {
+        if (!(Objects.equals(this.identifier, methodNode.getIdentifier()))
+                || getParameters().size() != methodNode.getParameters().size()) {
             return false;
         }
 

src/main/java/ast/members/FieldNode.java

@@ -3,8 +3,9 @@ package ast.members;
 import ast.type.AccessModifierNode;
 import ast.type.type.ITypeNode;
 import bytecode.visitor.ClassVisitor;
+import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 public class FieldNode implements MemberNode, Visitable {
@@ -12,7 +13,7 @@ public class FieldNode implements MemberNode, Visitable {
     public ITypeNode type;
     public String identifier;
 
-    public FieldNode(AccessModifierNode accessTypeNode, ITypeNode type, String name) {
+    public FieldNode(AccessModifierNode accessTypeNode, ITypeNode type, String name){
         this.accessTypeNode = accessTypeNode;
         this.type = type;
         this.identifier = name;

src/main/java/ast/members/MemberNode.java

@@ -10,8 +10,7 @@ import ast.ASTNode;
 @JsonSubTypes({
         @JsonSubTypes.Type(value = MethodNode.class, name = "Method"),
 
-        @JsonSubTypes.Type(value = FieldNode.class, name = "Field")}
+        @JsonSubTypes.Type(value = FieldNode.class, name = "Field") }
 )
 
-public interface MemberNode extends ASTNode {
-}
+public interface MemberNode extends ASTNode {}

src/main/java/ast/members/MethodNode.java

@@ -6,7 +6,7 @@ import ast.type.AccessModifierNode;
 import ast.type.type.*;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 import java.util.ArrayList;
@@ -15,16 +15,16 @@ import java.util.Objects;
 
 public class MethodNode implements MemberNode, Visitable {
     public AccessModifierNode accesModifier;
-    public ITypeNode type;
+    private ITypeNode type;
     public Boolean voidType;
-    public String identifier;
+    private String identifier;
     public List<ParameterNode> parameters = new ArrayList<>();
     public BlockNode block;
 
     public MethodNode() {
     }
 
-    public MethodNode(String accessModifier, ITypeNode type, Boolean voidType, String identifier, BlockNode block) {
+    public MethodNode(String accessModifier, ITypeNode type, Boolean voidType, String identifier, BlockNode block){
         this.accesModifier = new AccessModifierNode(accessModifier);
         this.type = type;
         this.voidType = voidType;
@@ -40,7 +40,7 @@ public class MethodNode implements MemberNode, Visitable {
         return parameters;
     }
 
-    public boolean isSame(MethodNode methodNode) {
+    public boolean isSame(MethodNode methodNode){
         if (!(Objects.equals(this.identifier, methodNode.getIdentifier())) || type.equals(methodNode.type)
                 || getParameters().size() != methodNode.getParameters().size()) {
             return false;

src/main/java/ast/parameters/ParameterNode.java

@@ -3,7 +3,7 @@ package ast.parameters;
 import ast.ASTNode;
 import ast.type.type.*;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 public class ParameterNode implements ASTNode, Visitable {

src/main/java/ast/statementexpressions/AssignNode.java

@@ -3,7 +3,7 @@ package ast.statementexpressions;
 import ast.expressions.IExpressionNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class AssignNode implements IStatementExpressionNode {
     public AssignableNode assignable;

src/main/java/ast/statementexpressions/AssignableNode.java

@@ -2,13 +2,12 @@ package ast.statementexpressions;
 
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.type.type.ITypeNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class AssignableNode implements IStatementExpressionNode {
     public String identifier;
-    public ITypeNode typeNode;
+    private ITypeNode typeNode;
 
     public MemberAccessNode memberAccess;
 
@@ -25,6 +24,10 @@ public class AssignableNode implements IStatementExpressionNode {
         return visitor.analyze(this);
     }
 
+    public ITypeNode getTypeNode() {
+        return typeNode;
+    }
+
     public void setTypeNode(ITypeNode typeNode) {
         this.typeNode = typeNode;
     }

src/main/java/ast/statementexpressions/IStatementExpressionNode.java

@@ -2,5 +2,4 @@ package ast.statementexpressions;
 
 import ast.statements.IStatementNode;
 
-public interface IStatementExpressionNode extends IStatementNode {
-}
+public interface IStatementExpressionNode extends IStatementNode {}

src/main/java/ast/statementexpressions/NewDeclarationNode.java

@@ -3,7 +3,7 @@ package ast.statementexpressions;
 import ast.expressions.IExpressionNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 import java.util.ArrayList;
 import java.util.List;

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

@@ -4,10 +4,10 @@ import ast.statementexpressions.AssignableNode;
 import ast.statementexpressions.IStatementExpressionNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+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

@@ -4,10 +4,9 @@ import ast.statementexpressions.AssignableNode;
 import ast.statementexpressions.IStatementExpressionNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import visitor.Visitable;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
-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

@@ -4,7 +4,7 @@ import ast.ASTNode;
 import ast.expressions.IExpressionNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 import java.util.ArrayList;
@@ -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/ast/statementexpressions/methodcallstatementnexpressions/MethodCallNode.java

@@ -5,7 +5,7 @@ import ast.statements.IStatementNode;
 import ast.type.type.ITypeNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 import java.util.ArrayList;
 import java.util.List;

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

@@ -3,8 +3,9 @@ package ast.statementexpressions.methodcallstatementnexpressions;
 import ast.ASTNode;
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.statementexpressions.NewDeclarationNode;
+import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 public class TargetNode implements ASTNode, Visitable {

src/main/java/ast/statements/BlockNode.java

@@ -1,8 +1,8 @@
 package ast.statements;
 
-import bytecode.visitor.MethodVisitor;
+import ast.ASTNode;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 import java.util.ArrayList;
@@ -11,8 +11,7 @@ import java.util.List;
 public class BlockNode implements IStatementNode, Visitable {
     public List<IStatementNode> statements = new ArrayList<>();
 
-    public BlockNode() {
-    }
+    public BlockNode() {}
 
     public void addStatement(IStatementNode statement) {
         statements.add(statement);
@@ -23,9 +22,4 @@ public class BlockNode implements IStatementNode, Visitable {
         return visitor.analyze(this);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
 }

src/main/java/ast/statements/BlockStatementNode.java

@@ -0,0 +1,10 @@
+package ast.statements;
+
+
+import java.util.List;
+
+public class BlockStatementNode {
+    List<IStatementNode> statements;
+
+    public BlockStatementNode(List<IStatementNode> statements) {this.statements = statements;}
+}

src/main/java/ast/statements/ElseNode.java

@@ -1,8 +1,7 @@
 package ast.statements;
 
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class ElseNode implements IStatementNode {
     public BlockNode block;

src/main/java/ast/statements/IfElseNode.java

@@ -1,8 +1,7 @@
 package ast.statements;
 
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -21,11 +20,6 @@ public class IfElseNode implements IStatementNode {
         elseIfStatements.add(elseIfStament);
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);

src/main/java/ast/statements/IfNode.java

@@ -2,7 +2,7 @@ package ast.statements;
 
 import ast.expressions.IExpressionNode;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class IfNode implements IStatementNode {
     public IExpressionNode expression;

src/main/java/ast/statements/LocalVariableDeclarationNode.java

@@ -4,7 +4,7 @@ import ast.expressions.IExpressionNode;
 import ast.type.type.*;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class LocalVariableDeclarationNode implements IStatementNode {
     public ITypeNode type;

src/main/java/ast/statements/ReturnNode.java

@@ -3,14 +3,14 @@ package ast.statements;
 import ast.expressions.IExpressionNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class ReturnNode implements IStatementNode {
     public IExpressionNode expression;
     public Boolean voidReturn = false;
 
     public ReturnNode(IExpressionNode expression) {
-        if (expression != null) {
+        if(expression != null) {
             this.expression = expression;
         } else {
             voidReturn = true;

src/main/java/ast/statements/WhileNode.java

@@ -1,9 +1,8 @@
 package ast.statements;
 
 import ast.expressions.IExpressionNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class WhileNode implements IStatementNode {
     public IExpressionNode expression;
@@ -15,14 +14,10 @@ public class WhileNode implements IStatementNode {
     }
 
     public void test() {
+        return;
 
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);

src/main/java/ast/type/AccessModifierNode.java

@@ -8,7 +8,7 @@ public class AccessModifierNode {
     }
 
     private void setModifier(String accessType) {
-        switch (accessType) {
+        switch(accessType) {
             case "public":
                 this.accessType = EnumAccessModifierNode.PUBLIC;
                 break;

src/main/java/ast/type/ValueNode.java

@@ -3,7 +3,7 @@ package ast.type;
 import ast.ASTNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
 
 public class ValueNode implements ASTNode, Visitable {

src/main/java/ast/type/type/BaseType.java

@@ -2,7 +2,7 @@ package ast.type.type;
 
 public class BaseType implements ITypeNode {
 
-    public final TypeEnum typeEnum;
+    private TypeEnum typeEnum;
 
     public BaseType(TypeEnum typeEnum) {
         this.typeEnum = typeEnum;
@@ -21,6 +21,8 @@ public class BaseType implements ITypeNode {
         if (getClass() != obj.getClass())
             return false;
         BaseType other = (BaseType) obj;
-        return typeEnum == other.typeEnum;
+        if (typeEnum != other.typeEnum)
+            return false;
+        return true;
     }
 }

src/main/java/ast/type/type/ITypeNode.java

@@ -1,4 +1,5 @@
 package ast.type.type;
 
 public interface ITypeNode {
+
 }

src/main/java/ast/type/type/ReferenceType.java

@@ -1,8 +1,8 @@
 package ast.type.type;
 
-public class ReferenceType implements ITypeNode {
+public class ReferenceType implements ITypeNode{
 
-    public final String identifier;
+    private String identifier;
 
     public ReferenceType(String identifier) {
         this.identifier = identifier;
@@ -22,8 +22,11 @@ public class ReferenceType implements ITypeNode {
             return false;
         ReferenceType other = (ReferenceType) obj;
         if (identifier == null) {
-            return other.identifier == null;
-        } else return identifier.equals(other.identifier);
+            if (other.identifier != null)
+                return false;
+        } else if (!identifier.equals(other.identifier))
+            return false;
+        return true;
     }
 
 

src/main/java/ast/type/type/TypeEnum.java

@@ -4,6 +4,6 @@ public enum TypeEnum {
     VOID,
     INT,
     CHAR,
-    BOOL,
-    NULL
+    BOOL;
+
 }

src/main/java/bytecode/ByteCodeGenerator.java

@@ -17,9 +17,9 @@ public class ByteCodeGenerator implements ProgramVisitor {
 
     private JarOutputStream jarOutputStream;
     private ByteArrayOutputStream byteArrayOutputStream;
-    private final String outputDirectory;
-    private final boolean generateJar;
-    private final boolean generateClassFiles;
+    private String outputDirectory;
+    private boolean generateJar;
+    private boolean generateClassFiles;
 
     public ByteCodeGenerator(String outputDirectory, boolean generateJar, boolean generateClassFiles) {
         this.outputDirectory = outputDirectory;

src/main/java/bytecode/ClassCodeGen.java

@@ -19,15 +19,15 @@ import java.util.jar.JarOutputStream;
 
 
 public class ClassCodeGen implements ClassVisitor {
-    private final Mapper mapper;
+    private Mapper mapper;
     private ClassWriter classWriter;
-    private final JarOutputStream jarOutputStream;
-    private final String outputDirectory;
-    private final boolean generateJar;
-    private final boolean generateClassFiles;
+    private JarOutputStream jarOutputStream;
+    private String outputDirectory;
+    private boolean generateJar;
+    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

@@ -10,15 +10,14 @@ import ast.members.MainMethodNode;
 import ast.members.MethodNode;
 import ast.parameters.ParameterNode;
 import ast.statementexpressions.AssignNode;
-import ast.statementexpressions.AssignableNode;
 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.AccessModifierNode;
-import ast.type.EnumAccessModifierNode;
 import ast.type.ValueNode;
 import ast.type.type.BaseType;
 import ast.type.type.ReferenceType;
@@ -36,11 +35,11 @@ import static org.objectweb.asm.Opcodes.*;
 
 public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
-    private final ClassWriter classWriter;
-    private final Mapper mapper;
+    private ClassWriter classWriter;
+    private Mapper mapper;
     private MethodVisitor methodVisitor;
 
-    private final List<String> localVariables;
+    private List<String> localVariables;
 
     public MethodCodeGen(ClassWriter classWriter) {
         this.classWriter = classWriter;
@@ -54,7 +53,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     @Override
     public void visit(ConstructorNode constructorNode) {
         methodVisitor =
-                classWriter.visitMethod(mapper.mapAccessTypeToOpcode(constructorNode.accesModifier),
+                classWriter.visitMethod(mapper.mapAccessTypeToOpcode(constructorNode.accessType),
                         "<init>",
                         mapper.generateMethodDescriptor(new BaseType(TypeEnum.VOID), constructorNode.parameters),
                         null,
@@ -72,8 +71,10 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
         // Visit all statements
         for (IStatementNode statementNode : constructorNode.block.statements) {
+            if (statementNode != null) {
                 statementNode.accept(this);
             }
+        }
 
         methodVisitor.visitMaxs(0, 0);
         methodVisitor.visitEnd();
@@ -81,10 +82,8 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     @Override
     public void visit(MainMethodNode mainMethodNode) {
-        AccessModifierNode accessModifierNode = new AccessModifierNode("");
-        accessModifierNode.accessType = EnumAccessModifierNode.PUBLIC_STATIC;
-        methodVisitor = classWriter.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC,
-                "main",
+        methodVisitor = classWriter.visitMethod(mapper.mapAccessTypeToOpcode(mainMethodNode.accesModifier),
+                mainMethodNode.getIdentifier(),
                 "([Ljava/lang/String;)V",
                 null,
                 null);
@@ -106,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);
 
@@ -136,12 +135,12 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     @Override
     public void visit(CalculationNode calculationNode) {
-        if (calculationNode.calculationExpression != null) {
-            calculationNode.calculationExpression.accept(this);
-        }
         if (calculationNode.dotExpression != null) {
             calculationNode.dotExpression.accept(this);
         }
+        if (calculationNode.calculationExpression != null) {
+            calculationNode.calculationExpression.accept(this);
+        }
         if (calculationNode.operator != null) {
             switch (calculationNode.operator) {
                 case PLUS:
@@ -159,8 +158,8 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (dotNode.dotExpression != null) {
             dotNode.dotExpression.accept(this);
         }
-        if (dotNode.dotSubtractionExpression != null) {
-            dotNode.dotSubtractionExpression.accept(this);
+        if (dotNode.dotSubstractionExpression != null) {
+            dotNode.dotSubstractionExpression.accept(this);
         }
         if (dotNode.operator != null) {
             switch (dotNode.operator) {
@@ -178,17 +177,17 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     }
 
     @Override
-    public void visit(DotSubtractionNode dotSubtractionNode) {
-        if (dotSubtractionNode.value != null) {
-            dotSubtractionNode.value.accept(this);
-        } else if (dotSubtractionNode.identifier != null) {
-            methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(dotSubtractionNode.identifier));
-        } else if (dotSubtractionNode.memberAccess != null) {
-            dotSubtractionNode.memberAccess.accept(this);
-        } else if (dotSubtractionNode.methodCall != null) {
-            dotSubtractionNode.methodCall.accept(this);
-        } else if (dotSubtractionNode.calculationExpression != null) {
-            dotSubtractionNode.calculationExpression.accept(this);
+    public void visit(DotSubstractionNode dotSubstractionNode) {
+        if (dotSubstractionNode.value != null) {
+            dotSubstractionNode.value.accept(this);
+        } else if (dotSubstractionNode.identifier != null) {
+            methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(dotSubstractionNode.identifier));
+        } else if (dotSubstractionNode.memberAccess != null) {
+            dotSubstractionNode.memberAccess.accept(this);
+        } else if (dotSubstractionNode.methodCall != null) {
+            dotSubstractionNode.methodCall.accept(this);
+        } else if (dotSubstractionNode.calculationExpression != null) {
+            dotSubstractionNode.calculationExpression.accept(this);
         }
     }
 
@@ -242,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);
                 }
@@ -267,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
         }
     }
 
@@ -305,8 +296,9 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     public void visit(UnaryNode unaryNode) {
         if (unaryNode.thisExp != null) {
             methodVisitor.visitVarInsn(ALOAD, 0); // this
+        } else if (unaryNode.identifier != null) {
+            methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(unaryNode.identifier));
         } else if (unaryNode.memberAccess != null) {
-            unaryNode.memberAccess.setTypeNode(unaryNode.getType());
             unaryNode.memberAccess.accept(this);
         } else if (unaryNode.value != null) {
             unaryNode.value.accept(this);
@@ -316,25 +308,15 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
             unaryNode.statement.accept(this);
         } else if (unaryNode.expression != null) {
             unaryNode.expression.accept(this);
-        } else if (unaryNode.identifier != null) {
-            methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(unaryNode.identifier));
         }
     }
 
 
     // Statements
 
-    @Override
-    public void visit(BlockNode blockNode) {
-        for (IStatementNode statementNode : blockNode.statements) {
-            statementNode.accept(this);
-        }
-    }
-
     @Override
     public void visit(IfElseNode ifElseNode) {
         Label elseLabel = new Label();
-        Label endLabel = new Label();
 
         Label[] elseIfLabels = new Label[ifElseNode.elseIfStatements.size()];
         for (int i = 0; i < ifElseNode.elseIfStatements.size(); i++) {
@@ -349,9 +331,9 @@ 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();
         methodVisitor.visitJumpInsn(GOTO, endLabel);
 
         for (int i = 0; i < ifElseNode.elseIfStatements.size(); i++) {
@@ -370,8 +352,6 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (ifElseNode.elseStatement != null) {
             methodVisitor.visitLabel(elseLabel);
             ifElseNode.elseStatement.block.accept(this);
-        } else {
-            methodVisitor.visitLabel(elseLabel);
         }
 
         methodVisitor.visitLabel(endLabel);
@@ -382,31 +362,22 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (localVariableDeclarationNode.expression != null) {
             // Process expression
             localVariableDeclarationNode.expression.accept(this);
-
-            if (localVariableDeclarationNode.expression instanceof UnaryNode) {
-                UnaryNode unaryNode = (UnaryNode) localVariableDeclarationNode.expression;
-                if (unaryNode.statement instanceof IncrementNode) {
-                    IncrementNode incrementNode = (IncrementNode) unaryNode.statement;
-                    incrementNode.assignableExpression.typeNode = unaryNode.type;
-                    loadIncrement(incrementNode);
-                } else if (unaryNode.statement instanceof DecrementNode) {
-                    DecrementNode decrementNode = (DecrementNode) unaryNode.statement;
-                    decrementNode.assignableExpression.typeNode = unaryNode.type;
-                    loadDecrement(decrementNode);
-                }
-            }
-
-            // add local var to list if not in list
-            if (!localVariables.contains(localVariableDeclarationNode.identifier)) {
-                localVariables.add(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 {
-            // Local var declaration
+                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));
+                }
+            }
+        } else {
             if (!localVariables.contains(localVariableDeclarationNode.identifier)) {
                 localVariables.add(localVariableDeclarationNode.identifier);
             }
@@ -415,212 +386,53 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     @Override
     public void visit(AssignNode assignNode) {
-        if (assignNode.assignable.memberAccess != null) { // this / object
-            assignNode.assignable.memberAccess.setTypeNode(assignNode.assignable.typeNode);
-            if (assignNode.expression instanceof UnaryNode) {
-                UnaryNode unaryNode = (UnaryNode) assignNode.expression;
-                if (unaryNode.statement instanceof IncrementNode) {
-                    IncrementNode incrementNode = (IncrementNode) unaryNode.statement;
+        // Process expression
+        if (assignNode.expression instanceof IncrementNode) {
+            IncrementNode incrementNode = (IncrementNode) assignNode.expression;
             if (incrementNode.crementType.equals(CrementType.PREFIX)) { // ++i
-                        incrementNode.accept(this); // crement
-                        fieldOrObjectVarCrementAssign(assignNode); // assign
-                    } else { // i++
-                        fieldOrObjectVarCrementAssign(assignNode); // assign
-                        incrementNode.accept(this); // crement
+                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 (unaryNode.statement instanceof DecrementNode) {
-                    DecrementNode decrementNode = (DecrementNode) unaryNode.statement;
+        } else if (assignNode.expression instanceof DecrementNode) {
+            DecrementNode decrementNode = (DecrementNode) assignNode.expression;
             if (decrementNode.crementType.equals(CrementType.PREFIX)) {
-                        decrementNode.accept(this); // crement
-                        fieldOrObjectVarCrementAssign(assignNode); // assign
-                    } else {
-                        fieldOrObjectVarCrementAssign(assignNode); // assign
-                        decrementNode.accept(this); // crement
-                    }
-                }
-            } else {
-                assignFieldOrObjectVar(assignNode);
-            }
-        } else { // local var
-            if (assignNode.expression instanceof UnaryNode) {
-                UnaryNode unaryNode = (UnaryNode) assignNode.expression;
-                if (unaryNode.statement instanceof IncrementNode || unaryNode.statement instanceof DecrementNode) {
-                    localVarCrementAssign(assignNode);
+                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 assign(AssignNode assignNode) {
+        if (assignNode.assignable.memberAccess.thisExpr) {
+            assignField(assignNode);
+        } else {
             assignLocalVar(assignNode);
         }
     }
-    }
-
-    private void loadIncrement(IncrementNode incrementNode) {
-        AssignableNode assignableNode = incrementNode.assignableExpression;
-        if (assignableNode.memberAccess != null) {
-            assignableNode.memberAccess.accept(this);
-        } else {
-            if (assignableNode.typeNode instanceof BaseType) {
-                methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(assignableNode.identifier));
-            } else if (assignableNode.typeNode instanceof ReferenceType) {
-                methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignableNode.identifier));
-            }
-        }
-    }
-
-    private void loadDecrement(DecrementNode decrementNode) {
-        AssignableNode assignableNode = decrementNode.assignableExpression;
-        if (assignableNode.memberAccess != null) {
-            assignableNode.memberAccess.accept(this);
-        } else {
-            if (assignableNode.typeNode instanceof BaseType) {
-                methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(assignableNode.identifier));
-            } else if (assignableNode.typeNode instanceof ReferenceType) {
-                methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignableNode.identifier));
-            }
-        }
-    }
 
     private void assignLocalVar(AssignNode assignNode) {
-        if (!localVariables.contains(assignNode.assignable.identifier)) {
-            localVariables.add(assignNode.assignable.identifier);
-        }
-
-        if (assignNode.expression.getType() instanceof BaseType) {
+        if (assignNode.expression instanceof BaseType) {
             methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(assignNode.assignable.identifier));
-        } else if (assignNode.expression.getType() instanceof ReferenceType) {
+        } else if (assignNode.expression instanceof ReferenceType) {
             methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(assignNode.assignable.identifier));
         }
     }
 
-    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);
-        }
-
-        assignNode.expression.accept(this);
-
-        if (assignNode.expression.getType() instanceof BaseType) {
+    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.getType() instanceof ReferenceType) {
+        } 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 localVarCrementAssign(AssignNode assignNode) {
-        UnaryNode unaryNode = (UnaryNode) assignNode.expression;
-        if (unaryNode.statement instanceof IncrementNode) {
-            IncrementNode incrementNode = (IncrementNode) unaryNode.statement;
-            if (incrementNode.crementType.equals(CrementType.PREFIX)) { // ++i
-                incrementNode.accept(this);
-                incrementNode.assignableExpression.typeNode = unaryNode.getType();
-                loadIncrement(incrementNode);
-                assignLocalVar(assignNode);
-            } else { // i++
-                incrementNode.assignableExpression.typeNode = unaryNode.getType();
-                loadIncrement(incrementNode);
-                assignLocalVar(assignNode);
-                incrementNode.accept(this);
-            }
-        } else if (unaryNode.statement instanceof DecrementNode) {
-            DecrementNode decrementNode = (DecrementNode) unaryNode.statement;
-            if (decrementNode.crementType.equals(CrementType.PREFIX)) {
-                decrementNode.accept(this);
-                decrementNode.assignableExpression.typeNode = unaryNode.getType();
-                loadDecrement(decrementNode);
-                assignLocalVar(assignNode);
-            } else {
-                decrementNode.assignableExpression.typeNode = unaryNode.getType();
-                loadDecrement(decrementNode);
-                assignLocalVar(assignNode);
-                decrementNode.accept(this);
-            }
-        }
-    }
-
-    private void fieldOrObjectVarCrementAssign(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);
-        }
-
-        UnaryNode unaryNode = (UnaryNode) assignNode.expression;
-        if (unaryNode.statement instanceof IncrementNode) {
-            IncrementNode incrementNode = (IncrementNode) unaryNode.statement;
-            incrementNode.assignableExpression.typeNode = unaryNode.getType();
-            loadIncrement((incrementNode));
-        } else if (unaryNode.statement instanceof DecrementNode) {
-            DecrementNode decrementNode = (DecrementNode) unaryNode.statement;
-            decrementNode.assignableExpression.typeNode = unaryNode.getType();
-            loadDecrement(decrementNode);
-        }
-
-        if (assignNode.expression.getType() 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.getType() 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() + ";");
-        }
-    }
-
-    @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(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);
-            }
-            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()+";");
         }
     }
 
@@ -633,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
@@ -679,21 +492,6 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         } else { // Return something
             // Process expression
             returnNode.expression.accept(this);
-
-            if (returnNode.expression instanceof UnaryNode) {
-                UnaryNode unaryNode = (UnaryNode) returnNode.expression;
-                if (unaryNode.statement instanceof IncrementNode) {
-                    IncrementNode incrementNode = (IncrementNode) unaryNode.statement;
-                    incrementNode.assignableExpression.typeNode = unaryNode.getType();
-                    loadIncrement(incrementNode);
-                }
-                if (unaryNode.statement instanceof DecrementNode) {
-                    DecrementNode decrementNode = (DecrementNode) unaryNode.statement;
-                    decrementNode.assignableExpression.typeNode = unaryNode.getType();
-                    loadDecrement(decrementNode);
-                }
-            }
-
             // Return result of expression
             if (returnNode.expression.getType() instanceof BaseType) {
                 methodVisitor.visitInsn(IRETURN);
@@ -720,25 +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<>();
-        int localVarIndex = -1;
-        if (methodCallNode.target.memberAccess.identifiers.size() > 1) {
-            localVarIndex = localVariables.indexOf(methodCallNode.target.memberAccess.identifiers.get(1));
-        }
-        if (localVarIndex >= 0) { // local var object
-            methodVisitor.visitVarInsn(ALOAD, localVarIndex);
-        } else { // this field
-            methodVisitor.visitVarInsn(ALOAD, 0);
-        }
-        for (IExpressionNode expressionNode : methodCallNode.parameters) {
+        for(IExpressionNode expressionNode : methodCallNode.parameters) {
             expressionNode.accept(this);
             parameterNodes.add(new ParameterNode(expressionNode.getType(), ""));
         }
-        if(methodCallNode.type == null) {
-            methodCallNode.type = new BaseType(TypeEnum.INT);
-        }
-        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

@@ -8,58 +8,46 @@ import ast.members.ConstructorNode;
 import ast.members.MainMethodNode;
 import ast.members.MethodNode;
 import ast.statementexpressions.AssignNode;
+import ast.statementexpressions.AssignableNode;
 import ast.statementexpressions.NewDeclarationNode;
 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;
 
 public interface MethodVisitor {
     // members
     void visit(ConstructorNode constructorNode);
-
     void visit(MethodNode methodNode);
-
     void visit(MainMethodNode mainMethodNode);
 
     // Binary expressions
     void visit(BinaryNode binaryNode);
-
     void visit(CalculationNode calculationNode);
-
     void visit(DotNode dotNode);
-
-    void visit(DotSubtractionNode dotSubtractionNode);
-
+    void visit(DotSubstractionNode dotSubstractionNode);
     void visit(NonCalculationNode nonCalculationNode);
 
     // Unary expressions
     void visit(MemberAccessNode memberAccessNode);
-
     void visit(NotNode notExpressionNode);
-
     void visit(UnaryNode unaryExpressionNode);
 
     // statements
-    void visit(BlockNode blockNode);
     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);
-
     void visit(NewDeclarationNode newDeclarationNode);
 
     // type

src/main/java/main/Main.java

@@ -15,11 +15,12 @@ import java.io.IOException;
 import java.nio.file.Paths;
 import java.util.Optional;
 
+
 /**
- * Start miniCompiler using make:
+ * Start Raupenpiler using make:
  * <p> <code> cd .\src\test\ </code>
- * <p> <code> make clean compile-miniCompiler </code>
- * <p> Start miniCompiler using jar:
+ * <p> <code> make clean compile-raupenpiler </code>
+ * <p> Start Raupenpiler using jar:
  * <p> <code> java.exe -DgenJar=true_OR_false -DgenClass=true_OR_false -jar path_to_jar\JavaCompiler-1.0-jar-with-dependencies.jar 'path_to_input_file.java' 'path_to_output_directory' </code>
  * <p> Example (jar needs to be in the target directory, compile with make or mvn package first):
  * <code> java.exe -DgenJar=true -DgenClass=true -jar .\target\JavaCompiler-1.0-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' </code>
@@ -39,14 +40,16 @@ public class Main {
                 System.err.println("Error reading the file: " + e.getMessage());
             }
         }
+        /*        !!! Else Branch (main ohne args starten) ist nicht zur Verwendung vorgesehen, immer mit args starten !!!
         else {
             try {
-                CharStream codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/input/finalTest/Car.java"));
-                compileFile(codeCharStream, "src/test/resources/input/finalTest");
+                CharStream codeCharStream = CharStreams.fromPath(Paths.get("src/main/resources/input/CompilerInput.java"));
+                compileFile(codeCharStream);
             } catch (IOException e) {
                 System.err.println("Error reading the file: " + e.getMessage());
             }
         }
+        */
     }
 
     /**
@@ -63,7 +66,7 @@ public class Main {
      */
     static void compileFile(CharStream inputCharStream, String outputDirectoryPath) {
         // Initialize the logger
-        new MiniCompilerLogger();
+        new RaupenLogger();
 
         /* ------------------------- Scanner -> tokens ------------------------- */
         // Use the SimpleJavaLexer to tokenize the input CharStream
@@ -71,27 +74,27 @@ public class Main {
         CommonTokenStream tokenStream = new CommonTokenStream(lexer);
         tokenStream.fill();
         // Log the tokens
-        MiniCompilerLogger.logScanner(tokenStream);
+        RaupenLogger.logScanner(tokenStream);
 
         /*------------------------- Parser -> Parsetree -------------------------*/
         // Use the SimpleJavaParser to parse the tokens and generate a ParseTree
         SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
         ParseTree parseTree = parser.program(); // parse the input
         // Log the ParseTree
-        MiniCompilerLogger.logParser(parseTree, parser);
+        RaupenLogger.logParser(parseTree, parser);
 
         /*------------------------- AST builder -> AST -------------------------*/
         // Use the ASTBuilder to visit the ParseTree and generate an Abstract Syntax Tree (AST)
         ASTBuilder astBuilder = new ASTBuilder();
         ASTNode abstractSyntaxTree = astBuilder.visit(parseTree);
         // Log the AST
-        MiniCompilerLogger.logAST(abstractSyntaxTree);
+        RaupenLogger.logAST(abstractSyntaxTree);
 
         /*------------------------- Semantic Analyzer -> typed AST -------------------------*/
         // Use the SemanticAnalyzer to generate a typed AST
         ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
         // Log the typed AST
-        MiniCompilerLogger.logSemanticAnalyzer(typedAst);
+        RaupenLogger.logSemanticAnalyzer(typedAst);
 
         if(SemanticAnalyzer.errors.isEmpty()){
             /*------------------------- Bytecode Generator -> Bytecode -------------------------*/
@@ -104,7 +107,7 @@ public class Main {
             assert typedAst != null;
             byteCodeGenerator.visit((ProgramNode) typedAst);
             // Log the bytecode generation
-            MiniCompilerLogger.logBytecodeGenerator();
+            RaupenLogger.logBytecodeGenerator();
         } else {
             for(Exception exception : SemanticAnalyzer.errors){
                 exception.printStackTrace();

src/main/java/main/RaupenLogger.java

@@ -29,15 +29,11 @@ import java.util.logging.*;
  * <code>consoleHandler.setLevel(Level.OFF);</code>
  * <code>fileHandler.setLevel(Level.ALL);</code>
  */
+public class RaupenLogger {
 
+    static Logger logger = Logger.getLogger("RaupenLogs");
 
-
-
-public class MiniCompilerLogger {
-
-    static Logger logger = Logger.getLogger("miniCompilerLogs");
-
-    public MiniCompilerLogger() {
+    public RaupenLogger() {
         // ------------------------- Logging -------------------------
         logger.setLevel(Level.ALL);
         logger.getParent().getHandlers()[0].setLevel(Level.ALL);
@@ -70,16 +66,14 @@ public class MiniCompilerLogger {
             logger.addHandler(consoleHandler);
 
             // Configure file handler
-            Handler fileHandler = new FileHandler("src/main/resources/logs/miniCompiler.log");
+            Handler fileHandler = new FileHandler("src/main/resources/logs/RaupenLog.log");
             // Toggle file logging on/off
             fileHandler.setLevel(Level.ALL);
             fileHandler.setFormatter(new CustomFormatter());
             logger.addHandler(fileHandler);
 
-        } catch (SecurityException e) {
+        } catch (SecurityException | IOException e) {
             e.printStackTrace();
-        } catch (IOException e) {
-            throw new RuntimeException(e);
         }
     }
 
@@ -108,7 +102,7 @@ public class MiniCompilerLogger {
     public static void logAST(ASTNode abstractSyntaxTree) {
         // Printing the AST
         logger.info("-------------------- AST builder -> AST  --------------------");
-        logger.info("Abstract Syntax Tree generated, Startnode:");
+        // logger.info("AST: " + ast.toString());
         logAST(abstractSyntaxTree, 0);
         logger.info("\n");
     }
@@ -116,15 +110,14 @@ public class MiniCompilerLogger {
     public static void logSemanticAnalyzer(ASTNode typedAst) {
         // Printing the typed AST
         logger.info("-------------------- Semantic Analyzer -> typed AST  --------------------");
-        // logAST(typedAst, 0);
-        logger.info("Typed Abstract Syntax Tree generated without errors");
+        logAST(typedAst, 0);
         logger.info("\n");
     }
 
     public static void logBytecodeGenerator() {
         // Printing the bytecode
         logger.info("-------------------- Bytecode Generator -> Bytecode  --------------------");
-        logger.info("Bytecode generated without errors");
+        logger.info("Bytecode generated");
         logger.info("\n");
     }
 
@@ -171,6 +164,7 @@ public class MiniCompilerLogger {
         }
     }
 
+    // TODO: Fix this method
     public static void logAST(ASTNode abstractSyntaxTree, int indent) {
         if (abstractSyntaxTree == null) {
             logger.severe("AST is null !!!");
@@ -178,7 +172,7 @@ public class MiniCompilerLogger {
         }
         String indentString = " ".repeat(indent * 2);
         logger.info(indentString + abstractSyntaxTree.getClass());
-        // for (ASTNode child : abstractSyntaxTree.getChildren()) {
+        //for (ASTNode child : abstractSyntaxTree.getChildren()) {
         //    logAST(child, indent + 1);
        // }
 

src/main/java/parser/astBuilder/ASTBuilder.java

@@ -30,18 +30,7 @@ import parser.generated.*;
 import java.util.ArrayList;
 import java.util.List;
 
-/**
- * ASTBuilder is a visitor that converts the parse tree into an abstract syntax tree (AST).
- */
 public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
-
-    /**
-     * Visits a program node and creates a ProgramNode.
-     * It iterates through all class declarations in the context and adds them to the ProgramNode.
-     *
-     * @param ctx the program context
-     * @return the AST node for the program
-     */
     @Override
     public ASTNode visitProgram(SimpleJavaParser.ProgramContext ctx) {
         ProgramNode program = new ProgramNode();
@@ -51,14 +40,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return program;
     }
 
-
-    /**
-     * Visits a class declaration and creates a ClassNode.
-     * It checks for an access modifier, processes member declarations, and ensures the class has a constructor.
-     *
-     * @param ctx the class declaration context
-     * @return the AST node for the class
-     */
     @Override
     public ASTNode visitClassDeclaration(SimpleJavaParser.ClassDeclarationContext ctx) {
         ClassNode classNode;
@@ -90,13 +71,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return classNode;
     }
 
-    /**
-     * Visits a constructor declaration and creates a ConstructorNode.
-     * It processes access modifiers, block statements, and parameters.
-     *
-     * @param ctx the constructor declaration context
-     * @return the AST node for the constructor
-     */
     @Override
     public ASTNode visitConstructorDeclaration(SimpleJavaParser.ConstructorDeclarationContext ctx) {
         ConstructorNode constructorNode;
@@ -114,13 +88,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return constructorNode;
     }
 
-    /**
-     * Visits a method declaration and creates a MethodNode or MainMethodNode.
-     * It handles method types, access modifiers, block statements, and parameters.
-     *
-     * @param ctx the method declaration context
-     * @return the AST node for the method
-     */
     @Override
     public ASTNode visitMethodDeclaration(SimpleJavaParser.MethodDeclarationContext ctx) {
         if(ctx.MainMethodDeclaration() != null) {
@@ -170,14 +137,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         }
     }
 
-
-    /**
-     * Visits a field declaration and creates a FieldNode.
-     * It handles access modifiers and types.
-     *
-     * @param ctx the field declaration context
-     * @return the AST node for the field
-     */
     @Override
     public ASTNode visitFieldDeclaration(SimpleJavaParser.FieldDeclarationContext ctx) {
         if(ctx.AccessModifier() != null) {
@@ -187,25 +146,11 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         }
     }
 
-    /**
-     * Visits a parameter and creates a ParameterNode.
-     * It handles the type and identifier of the parameter.
-     *
-     * @param ctx the parameter context
-     * @return the AST node for the parameter
-     */
     @Override
     public ASTNode visitParameter(SimpleJavaParser.ParameterContext ctx) {
         return new ParameterNode(createTypeNode(ctx.type().getText()), ctx.Identifier().getText());
     }
 
-    /**
-     * Visits a statement and creates the corresponding AST node.
-     * It determines the specific type of statement and processes it accordingly.
-     *
-     * @param ctx the statement context
-     * @return the AST node for the statement
-     */
     @Override
     public ASTNode visitStatement(SimpleJavaParser.StatementContext ctx) {
         if(ctx.returnStatement() != null) {
@@ -230,25 +175,11 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits a return statement and creates a ReturnNode.
-     * It processes the expression in the return statement.
-     *
-     * @param ctx the return statement context
-     * @return the AST node for the return statement
-     */
     @Override
     public ASTNode visitReturnStatement(SimpleJavaParser.ReturnStatementContext ctx) {
         return new ReturnNode((IExpressionNode) visit(ctx.expression()));
     }
 
-    /**
-     * Visits a return statement and creates a ReturnNode.
-     * It processes the expression in the return statement.
-     *
-     * @param ctx the return statement context
-     * @return the AST node for the return statement
-     */
     @Override
     public ASTNode visitLocalVariableDeclaration(SimpleJavaParser.LocalVariableDeclarationContext ctx) {
         if(ctx.Assign() != null) {
@@ -259,13 +190,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
     }
 
-    /**
-     * Visits a block statement and creates a BlockNode.
-     * It processes all statements within the block.
-     *
-     * @param ctx the block statement context
-     * @return the AST node for the block statement
-     */
     @Override
     public ASTNode visitBlockStatement(SimpleJavaParser.BlockStatementContext ctx) {
         BlockNode blockNode = new BlockNode();
@@ -275,25 +199,11 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return blockNode;
     }
 
-    /**
-     * Visits a while statement and creates a WhileNode.
-     * It processes the condition expression and the block statement.
-     *
-     * @param ctx the while statement context
-     * @return the AST node for the while statement
-     */
     @Override
     public ASTNode visitWhileStatement(SimpleJavaParser.WhileStatementContext ctx) {
         return new WhileNode((IExpressionNode) visit(ctx.expression()), (BlockNode) visit(ctx.blockStatement()));
     }
 
-    /**
-     * Visits a do-while statement and creates a BlockNode containing a WhileNode.
-     * It processes the condition expression and the block statement.
-     *
-     * @param ctx the do-while statement context
-     * @return the AST node for the do-while statement
-     */
     @Override
     public ASTNode visitDoWhileStatement(SimpleJavaParser.DoWhileStatementContext ctx) {
         IExpressionNode condition = (IExpressionNode) visit(ctx.expression());
@@ -301,19 +211,12 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
         WhileNode While = new WhileNode(condition, doBlock);
         BlockNode resultBlock = new BlockNode();
-        resultBlock.addStatement(doBlock);
-        resultBlock.addStatement(While);
+        resultBlock.addStatement((IStatementNode) doBlock);
+        resultBlock.addStatement((IStatementNode) While);
 
         return resultBlock;
     }
 
-    /**
-     * Visits a for statement and creates a BlockNode that contains a WhileNode.
-     * It processes the initialization, condition, and increment parts of the for loop.
-     *
-     * @param ctx the for statement context
-     * @return the AST node for the for statement
-     */
     @Override
     public ASTNode visitForStatement(SimpleJavaParser.ForStatementContext ctx) {
         List<IStatementNode> statements = new ArrayList<>();
@@ -332,8 +235,15 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
         // Inkrement
         IStatementExpressionNode crement = null;
+        boolean isPrefix = false;
         if (ctx.statementExpression(i) != null) {
             crement = (IStatementExpressionNode) visit(ctx.statementExpression(i));
+
+            if (crement instanceof IncrementNode) {
+                isPrefix = ((IncrementNode) crement).crementType == CrementType.PREFIX;
+            } else if (crement instanceof DecrementNode) {
+                isPrefix = ((DecrementNode) crement).crementType == CrementType.PREFIX;
+            }
         }
 
         BlockNode forBlock = (BlockNode) visit(ctx.blockStatement());
@@ -341,14 +251,19 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         // While-Schleife
         BlockNode whileBody = new BlockNode();
 
+        // Prä-Inkrement: Das Inkrement kommt vor dem Block
+        if (crement != null && isPrefix) {
+            whileBody.addStatement((IStatementNode) crement);
+        }
+
         // Block Statements der For-Schleife in den While-Block kopieren
         for (IStatementNode statement : forBlock.statements) {
             whileBody.addStatement(statement);
         }
 
         // Post-Inkrement: Das Inkrement kommt nach dem Block
-        if (crement != null) {
-            whileBody.addStatement(crement);
+        if (crement != null && !isPrefix) {
+            whileBody.addStatement((IStatementNode) crement);
         }
 
         // Bedingung der While-Schleife
@@ -358,19 +273,12 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
         BlockNode resultBlock = new BlockNode();
         for (IStatementNode statement : statements) {
-            resultBlock.addStatement(statement);
+            resultBlock.addStatement((IStatementNode) statement);
         }
 
         return resultBlock;
     }
 
-    /**
-     * Visits an if-else statement and creates an IfElseNode.
-     * It processes the if, else-if, and else parts of the statement.
-     *
-     * @param ctx the if-else statement context
-     * @return the AST node for the if-else statement
-     */
     @Override
     public ASTNode visitIfElseStatement(SimpleJavaParser.IfElseStatementContext ctx) {
         IfElseNode ifElseStatementNode;
@@ -388,49 +296,21 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return ifElseStatementNode;
     }
 
-    /**
-     * Visits an if statement and creates an IfNode.
-     * It processes the condition expression and the block statement.
-     *
-     * @param ctx the if statement context
-     * @return the AST node for the if statement
-     */
     @Override
     public ASTNode visitIfStatement(SimpleJavaParser.IfStatementContext ctx) {
         return new IfNode((IExpressionNode) visit(ctx.expression()), (BlockNode) visit(ctx.blockStatement()));
     }
 
-    /**
-     * Visits an else-if statement and creates an IfNode.
-     * It processes the condition expression and the block statement.
-     *
-     * @param ctx the else-if statement context
-     * @return the AST node for the else-if statement
-     */
     @Override
     public ASTNode visitElseIfStatement(SimpleJavaParser.ElseIfStatementContext ctx) {
         return new IfNode((IExpressionNode) visit(ctx.expression()), (BlockNode) visit(ctx.blockStatement()));
     }
 
-    /**
-     * Visits an else statement and creates an ElseNode.
-     * It processes the block statement of the else part.
-     *
-     * @param ctx the else statement context
-     * @return the AST node for the else statement
-     */
     @Override
     public ASTNode visitElseStatement(SimpleJavaParser.ElseStatementContext ctx) {
         return new ElseNode((BlockNode) visit(ctx.blockStatement()));
     }
 
-    /**
-     * Visits a statement expression and creates the corresponding AST node.
-     * It handles assignments, new declarations, method calls, and increment/decrement expressions.
-     *
-     * @param ctx the statement expression context
-     * @return the AST node for the statement expression
-     */
     @Override
     public ASTNode visitStatementExpression(SimpleJavaParser.StatementExpressionContext ctx) {
         if(ctx.assign() != null) {
@@ -445,13 +325,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits a switch statement and creates an IfElseNode representing the switch cases.
-     * It processes the switch expression, case statements, and default statement.
-     *
-     * @param ctx the switch statement context
-     * @return the AST node for the switch statement
-     */
     @Override
     public ASTNode visitSwitchStatement(SimpleJavaParser.SwitchStatementContext ctx) {
         UnaryNode switchExpression = (UnaryNode) visit(ctx.expression());
@@ -495,25 +368,11 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return ifElseNode;
     }
 
-    /**
-     * Visits an assignment expression and creates an AssignNode.
-     * It handles the assignable expression and the assigned expression.
-     *
-     * @param ctx the assignment context
-     * @return the AST node for the assignment
-     */
     @Override
     public ASTNode visitAssign(SimpleJavaParser.AssignContext ctx) {
         return new AssignNode((AssignableNode) visit(ctx.assignableExpression()), (IExpressionNode) visit(ctx.expression()));
     }
 
-    /**
-     * Visits a new declaration and creates a NewDeclarationNode.
-     * It processes the identifier and the argument list.
-     *
-     * @param ctx the new declaration context
-     * @return the AST node for the new declaration
-     */
     @Override
     public ASTNode visitNewDeclaration(SimpleJavaParser.NewDeclarationContext ctx) {
         NewDeclarationNode newDeclarationNode = new NewDeclarationNode(ctx.Identifier().getText());
@@ -523,13 +382,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return newDeclarationNode;
     }
 
-    /**
-     * Visits a method call and creates a MethodCallNode.
-     * It processes the target, chained methods, and argument list.
-     *
-     * @param ctx the method call context
-     * @return the AST node for the method call
-     */
     @Override
     public ASTNode visitMethodCall(SimpleJavaParser.MethodCallContext ctx) {
         MethodCallNode methodCallStatementExpressionNode;
@@ -547,13 +399,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return methodCallStatementExpressionNode;
     }
 
-    /**
-     * Visits the target of a method call and creates a TargetNode.
-     * It handles various types of targets including 'this', member access, new declarations, and identifiers.
-     *
-     * @param ctx the target context
-     * @return the AST node for the target
-     */
     @Override
     public ASTNode visitTarget(SimpleJavaParser.TargetContext ctx) {
         if(ctx.This() != null) {
@@ -568,13 +413,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits a chained method and creates a ChainedMethodNode.
-     * It processes the identifier and the argument list.
-     *
-     * @param ctx the chained method context
-     * @return the AST node for the chained method
-     */
     @Override
     public ASTNode visitChainedMethod(SimpleJavaParser.ChainedMethodContext ctx) {
         ChainedMethodNode chainedMethodNode = new ChainedMethodNode(ctx.Identifier().getText());
@@ -584,13 +422,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return chainedMethodNode;
     }
 
-    /**
-     * Visits an increment or decrement expression and creates the corresponding AST node.
-     * It handles both prefix and suffix forms of increment and decrement.
-     *
-     * @param ctx the crement expression context
-     * @return the AST node for the crement expression
-     */
     @Override
     public ASTNode visitCrementExpression(SimpleJavaParser.CrementExpressionContext ctx) {
         if(ctx.incrementExpression() != null) {
@@ -601,13 +432,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits an increment expression and creates an IncrementNode.
-     * It handles both prefix and suffix forms.
-     *
-     * @param ctx the increment expression context
-     * @return the AST node for the increment expression
-     */
     @Override
     public ASTNode visitIncrementExpression(SimpleJavaParser.IncrementExpressionContext ctx) {
         if(ctx.prefixIncrementExpression() != null) {
@@ -618,35 +442,16 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits a prefix increment expression and creates an IncrementNode.
-     *
-     * @param ctx the prefix increment expression context
-     * @return the AST node for the prefix increment expression
-     */
     @Override
     public ASTNode visitPrefixIncrementExpression(SimpleJavaParser.PrefixIncrementExpressionContext ctx) {
         return new IncrementNode(CrementType.PREFIX, (AssignableNode) visit(ctx.assignableExpression()));
     }
 
-    /**
-     * Visits a suffix increment expression and creates an IncrementNode.
-     *
-     * @param ctx the suffix increment expression context
-     * @return the AST node for the suffix increment expression
-     */
     @Override
     public ASTNode visitSuffixIncrementExpression(SimpleJavaParser.SuffixIncrementExpressionContext ctx) {
         return new IncrementNode(CrementType.SUFFIX, (AssignableNode) visit(ctx.assignableExpression()));
     }
 
-    /**
-     * Visits a decrement expression and creates a DecrementNode.
-     * It handles both prefix and suffix forms.
-     *
-     * @param ctx the decrement expression context
-     * @return the AST node for the decrement expression
-     */
     @Override
     public ASTNode visitDecrementExpression(SimpleJavaParser.DecrementExpressionContext ctx) {
         if(ctx.prefixDecrementExpression() != null) {
@@ -657,35 +462,16 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits a prefix decrement expression and creates a DecrementNode.
-     *
-     * @param ctx the prefix decrement expression context
-     * @return the AST node for the prefix decrement expression
-     */
     @Override
     public ASTNode visitPrefixDecrementExpression(SimpleJavaParser.PrefixDecrementExpressionContext ctx) {
         return new DecrementNode(CrementType.PREFIX, (AssignableNode) visit(ctx.assignableExpression()));
     }
 
-    /**
-     * Visits a suffix decrement expression and creates a DecrementNode.
-     *
-     * @param ctx the suffix decrement expression context
-     * @return the AST node for the suffix decrement expression
-     */
     @Override
     public ASTNode visitSuffixDecrementExpression(SimpleJavaParser.SuffixDecrementExpressionContext ctx) {
         return new DecrementNode(CrementType.SUFFIX, (AssignableNode) visit(ctx.assignableExpression()));
     }
 
-    /**
-     * Visits an expression and creates the corresponding AST node.
-     * It handles both unary and binary expressions.
-     *
-     * @param ctx the expression context
-     * @return the AST node for the expression
-     */
     @Override
     public ASTNode visitExpression(SimpleJavaParser.ExpressionContext ctx) {
         if(ctx.unaryExpression() != null) {
@@ -696,13 +482,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits a unary expression and creates a UnaryNode.
-     * It handles various forms of unary expressions including 'this', identifiers, member access, values, and more.
-     *
-     * @param ctx the unary expression context
-     * @return the AST node for the unary expression
-     */
     @Override
     public ASTNode visitUnaryExpression(SimpleJavaParser.UnaryExpressionContext ctx) {
         if(ctx.This() != null) {
@@ -723,13 +502,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits a member access expression and creates a MemberAccessNode.
-     * It processes the 'this' keyword and identifiers for member access.
-     *
-     * @param ctx the member access context
-     * @return the AST node for the member access
-     */
     @Override
     public ASTNode visitMemberAccess(SimpleJavaParser.MemberAccessContext ctx) {
         MemberAccessNode memberAccessNode;
@@ -744,13 +516,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return memberAccessNode;
     }
 
-    /**
-     * Visits a value and creates a ValueNode.
-     * It handles integer, boolean, char, and null values.
-     *
-     * @param ctx the value context
-     * @return the AST node for the value
-     */
     @Override
     public ASTNode visitValue(SimpleJavaParser.ValueContext ctx) {
         if(ctx.IntValue() != null) {
@@ -765,25 +530,12 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits a not expression and creates a NotNode.
-     * It processes the expression to which the 'not' operator is applied.
-     *
-     * @param ctx the not expression context
-     * @return the AST node for the not expression
-     */
     @Override
     public ASTNode visitNotExpression(SimpleJavaParser.NotExpressionContext ctx) {
         return new NotNode((IExpressionNode) visitExpression(ctx.expression()));
     }
 
-    /**
-     * Visits a binary expression and creates the corresponding AST node.
-     * It handles both calculation and non-calculation expressions.
-     *
-     * @param ctx the binary expression context
-     * @return the AST node for the binary expression
-     */
+
     @Override
     public ASTNode visitBinaryExpression(SimpleJavaParser.BinaryExpressionContext ctx) {
         if(ctx.calculationExpression() != null) {
@@ -794,13 +546,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits a calculation expression and creates a CalculationNode.
-     * It handles line operators and dot expressions.
-     *
-     * @param ctx the calculation expression context
-     * @return the AST node for the calculation expression
-     */
     @Override
     public ASTNode visitCalculationExpression(SimpleJavaParser.CalculationExpressionContext ctx) {
         if(ctx.calculationExpression() != null) {
@@ -811,69 +556,35 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Visits a dot expression and creates a DotNode.
-     * It handles dot operators and dot subtraction expressions.
-     *
-     * @param ctx the dot expression context
-     * @return the AST node for the dot expression
-     */
     @Override
     public ASTNode visitDotExpression(SimpleJavaParser.DotExpressionContext ctx) {
         if(ctx.dotExpression() != null) {
-            return new DotNode((DotNode) visit(ctx.dotExpression()), ctx.DotOperator().getText(), (DotSubtractionNode) visit(ctx.dotSubtractionExpression()));
+            return new DotNode((DotNode) visit(ctx.dotExpression()), ctx.DotOperator().getText(), (DotSubstractionNode) visit(ctx.dotSubtractionExpression()));
         } else if(ctx.dotSubtractionExpression() != null) {
-            return new DotNode((DotSubtractionNode) visit(ctx.dotSubtractionExpression()));
+            return new DotNode((DotSubstractionNode) visit(ctx.dotSubtractionExpression()));
         }
         return null;
     }
 
-    /**
-     * Visits a dot subtraction expression and creates a DotSubtractionNode.
-     * It handles integer values, identifiers, member access, and method calls.
-     *
-     * @param ctx the dot subtraction expression context
-     * @return the AST node for the dot subtraction expression
-     *//**
-     * Creates an ITypeNode based on the type identifier.
-     * It handles basic types and reference types.
-     *
-     * @param identifier the type identifier
-     * @return the type node
-     */
     @Override
     public ASTNode visitDotSubtractionExpression(SimpleJavaParser.DotSubtractionExpressionContext ctx) {
         if(ctx.IntValue() != null) {
-            return new DotSubtractionNode(new ValueNode(EnumValueNode.INT_VALUE, ctx.IntValue().getText()));
+            return new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, ctx.IntValue().getText()));
         } else if(ctx.Identifier() != null) {
-            return new DotSubtractionNode(ctx.Identifier().getText());
+            return new DotSubstractionNode(ctx.Identifier().getText());
         } else if(ctx.memberAccess() != null) {
-            return new DotSubtractionNode((MemberAccessNode) visit(ctx.memberAccess()));
+            return new DotSubstractionNode((MemberAccessNode) visit(ctx.memberAccess()));
         } else if(ctx.methodCall() != null && ctx.calculationExpression() != null) {
-            return new DotSubtractionNode((MethodCallNode) visit(ctx.methodCall()), (CalculationNode) visit(ctx.calculationExpression()));
+            return new DotSubstractionNode((MethodCallNode) visit(ctx.methodCall()), (CalculationNode) visit(ctx.calculationExpression()));
         }
         return null;
     }
 
-    /**
-     * Visits a non-calculation expression and creates a NonCalculationNode.
-     * It handles unary expressions combined with non-calculation operators.
-     *
-     * @param ctx the non-calculation expression context
-     * @return the AST node for the non-calculation expression
-     */
     @Override
     public ASTNode visitNonCalculationExpression(SimpleJavaParser.NonCalculationExpressionContext ctx) {
         return new NonCalculationNode((UnaryNode) visit(ctx.unaryExpression()), ctx.nonCalculationOperator().getText(), (IExpressionNode) visit(ctx.expression()));
     }
 
-    /**
-     * Visits an assignable expression and creates an AssignableNode.
-     * It handles identifiers and member access.
-     *
-     * @param ctx the assignable expression context
-     * @return the AST node for the assignable expression
-     */
     @Override
     public ASTNode visitAssignableExpression(SimpleJavaParser.AssignableExpressionContext ctx) {
         if(ctx.Identifier() != null) {
@@ -884,13 +595,6 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         return null;
     }
 
-    /**
-     * Creates an ITypeNode based on the type identifier.
-     * It handles basic types and reference types.
-     *
-     * @param identifier the type identifier
-     * @return the type node
-     */
     public ITypeNode createTypeNode(String identifier){
         return switch (identifier) {
             case "int" -> new BaseType(TypeEnum.INT);

src/main/java/parser/grammar/SimpleJava.g4

@@ -1,18 +1,18 @@
 grammar SimpleJava;
 
 // Programm-Konstrukte
-program: classDeclaration+; // Ein Programm besteht aus einer oder mehreren Klassendeklarationen
+program: classDeclaration+;
 
-classDeclaration: AccessModifier? 'class' Identifier OpenCurlyBracket memberDeclaration* ClosedCurlyBracket; // Deklariert eine Klasse mit optionalem Zugriffsmodifikator und mehreren Mitgliedern
-memberDeclaration: constructorDeclaration | fieldDeclaration | methodDeclaration; // Ein Mitglied kann ein Konstruktor, ein Feld oder eine Methode sein
+classDeclaration: AccessModifier? 'class' Identifier OpenCurlyBracket memberDeclaration* ClosedCurlyBracket;
+memberDeclaration: constructorDeclaration | fieldDeclaration | methodDeclaration;
 
-constructorDeclaration: AccessModifier? Identifier OpenRoundBracket parameterList? ClosedRoundBracket blockStatement; // Deklariert einen Konstruktor
-fieldDeclaration: AccessModifier? type Identifier (Assign expression)? Semicolon; // Deklariert ein Feld mit optionaler Initialisierung
-methodDeclaration: MainMethodDeclaration blockStatement | AccessModifier? (type | Void) Identifier OpenRoundBracket parameterList? ClosedRoundBracket blockStatement; // Deklariert eine Methode
+constructorDeclaration: AccessModifier? Identifier OpenRoundBracket parameterList? ClosedRoundBracket blockStatement;
+fieldDeclaration: AccessModifier? type Identifier (Assign expression)? Semicolon;
+methodDeclaration: MainMethodDeclaration blockStatement | AccessModifier? (type | Void) Identifier OpenRoundBracket parameterList? ClosedRoundBracket blockStatement;
 
-parameterList: parameter (Comma parameter)*; // Parameterliste für Methoden und Konstruktoren
-parameter: type Identifier; // Ein einzelner Parameter mit Typ und Bezeichner
-argumentList: (expression (Comma expression)*)?; // Argumentliste für Methodenaufrufe
+parameterList: parameter (Comma parameter)*;
+parameter: type Identifier;
+argumentList: (expression (Comma expression)*)?;
 
 // Anweisungen
 statement: returnStatement Semicolon
@@ -23,32 +23,32 @@ statement: returnStatement Semicolon
          | forStatement
          | ifElseStatement
          | switchStatement
-         | statementExpression Semicolon; // Verschiedene Arten von Anweisungen
+         | statementExpression Semicolon;
 
-blockStatement: OpenCurlyBracket statement* ClosedCurlyBracket; // Ein Block von Anweisungen
+blockStatement: OpenCurlyBracket statement* ClosedCurlyBracket;
 
-returnStatement: Return (expression)?; // Rückgabe-Anweisung
-localVariableDeclaration: type Identifier (Assign expression)?; // Deklaration einer lokalen Variable
+returnStatement: Return (expression)?;
+localVariableDeclaration: type Identifier (Assign expression)?;
 
-whileStatement: While OpenRoundBracket expression ClosedRoundBracket blockStatement; // While-Schleife
-doWhileStatement: Do blockStatement While OpenRoundBracket expression ClosedRoundBracket Semicolon; // Do-While-Schleife
-forStatement: For OpenRoundBracket (statementExpression | localVariableDeclaration) Semicolon (expression)? Semicolon (statementExpression)? ClosedRoundBracket blockStatement; // For-Schleife
+whileStatement: While OpenRoundBracket expression ClosedRoundBracket blockStatement;
+doWhileStatement: Do blockStatement While OpenRoundBracket expression ClosedRoundBracket Semicolon;
+forStatement: For OpenRoundBracket (statementExpression | localVariableDeclaration) Semicolon (expression)? Semicolon (statementExpression)? ClosedRoundBracket blockStatement;
 
-ifElseStatement: ifStatement elseIfStatement* elseStatement?; // If-Else-Bedingung
-ifStatement: If OpenRoundBracket expression ClosedRoundBracket blockStatement; // If-Teil der Bedingung
-elseIfStatement: Else If OpenRoundBracket expression ClosedRoundBracket blockStatement; // Else-If-Teil der Bedingung
-elseStatement: Else blockStatement; // Else-Teil der Bedingung
+ifElseStatement: ifStatement elseIfStatement* elseStatement?;
+ifStatement: If OpenRoundBracket expression ClosedRoundBracket blockStatement;
+elseIfStatement: Else If OpenRoundBracket expression ClosedRoundBracket blockStatement;
+elseStatement: Else blockStatement;
 
-switchStatement: Switch OpenRoundBracket expression ClosedRoundBracket OpenCurlyBracket caseStatement+ defaultStatement? ClosedCurlyBracket; // Switch-Anweisung
-caseStatement: Case value Colon statement*; // Ein Case-Teil einer Switch-Anweisung
-defaultStatement: Default Colon statement*; // Default-Teil einer Switch-Anweisung
+switchStatement: Switch OpenRoundBracket expression ClosedRoundBracket OpenCurlyBracket caseStatement+ defaultStatement? ClosedCurlyBracket;
+caseStatement: Case value Colon statement*;
+defaultStatement: Default Colon statement*;
 
-statementExpression: assign | newDeclaration | methodCall | crementExpression; // Ausdruck innerhalb einer Anweisung
-assign: assignableExpression Assign expression; // Zuweisung
-newDeclaration: New Identifier OpenRoundBracket argumentList ClosedRoundBracket; // Instanziierung eines neuen Objekts
+statementExpression: assign | newDeclaration | methodCall | crementExpression;
+assign: assignableExpression Assign expression;
+newDeclaration: New Identifier OpenRoundBracket argumentList ClosedRoundBracket;
 
 // Ausdrücke
-expression: unaryExpression | binaryExpression; // Ein Ausdruck kann unär oder binär sein
+expression: unaryExpression | binaryExpression;
 
 unaryExpression: This
                | Identifier
@@ -56,97 +56,97 @@ unaryExpression: This
                | value
                | notExpression
                | statementExpression
-               | OpenRoundBracket expression ClosedRoundBracket; // Unäre Ausdrücke
+               | OpenRoundBracket expression ClosedRoundBracket;
 
-notExpression: Not expression; // Nicht-Ausdruck
+notExpression: Not expression;
 
-crementExpression: incrementExpression | decrementExpression; // Inkrement-/Dekrement-Ausdrücke
+crementExpression: incrementExpression | decrementExpression;
 
 incrementExpression: prefixIncrementExpression | suffixIncrementExpression;
-prefixIncrementExpression: '++' assignableExpression; // Präfix-Inkrement
-suffixIncrementExpression: assignableExpression '++'; // Suffix-Inkrement
+prefixIncrementExpression: '++' assignableExpression;
+suffixIncrementExpression: assignableExpression '++';
 
-decrementExpression: prefixDecrementExpression | suffixDecrementExpression; // Dekrement-Ausdrücke
-prefixDecrementExpression: '--' assignableExpression; // Präfix-Dekrement
-suffixDecrementExpression: assignableExpression '--'; // Suffix-Dekrement
+decrementExpression: prefixDecrementExpression | suffixDecrementExpression;
+prefixDecrementExpression: '--' assignableExpression;
+suffixDecrementExpression: assignableExpression '--';
 
-assignableExpression: Identifier | memberAccess; // Zuweisbarer Ausdruck
+assignableExpression: Identifier | memberAccess;
 
 memberAccess: This Dot Identifier
-            | (This Dot)? (Identifier Dot)+ Identifier; // Mitgliedszugriff
+            | (This Dot)? (Identifier Dot)+ Identifier;
 
-binaryExpression: calculationExpression | nonCalculationExpression; // Binäre Ausdrücke
+binaryExpression: calculationExpression | nonCalculationExpression;
 
 calculationExpression: calculationExpression LineOperator dotExpression
-                     | dotExpression; // Berechnungsausdrücke
+                     | dotExpression;
 
 dotExpression: dotExpression DotOperator dotSubtractionExpression
-              | dotSubtractionExpression; // Punktoperationen
+              | dotSubtractionExpression;
 
 dotSubtractionExpression: IntValue
                         | Identifier
                         | memberAccess
-                        | methodCall OpenRoundBracket calculationExpression ClosedRoundBracket; // Punkt-Subtraktionsausdrücke
+                        | methodCall OpenRoundBracket calculationExpression ClosedRoundBracket;
 
-nonCalculationExpression: unaryExpression nonCalculationOperator expression; // Nicht-Berechnungsausdrücke
+nonCalculationExpression: unaryExpression nonCalculationOperator expression;
 
 // Methodenaufrufe
-methodCall: target? chainedMethod* Identifier OpenRoundBracket argumentList ClosedRoundBracket; // Methodenaufruf
-target: (This | memberAccess | newDeclaration | Identifier) Dot; // Ziel eines Methodenaufrufs
-chainedMethod: Identifier OpenRoundBracket argumentList ClosedRoundBracket Dot; // Verkettete Methode
+methodCall: target? chainedMethod* Identifier OpenRoundBracket argumentList ClosedRoundBracket;
+target: (This | memberAccess | newDeclaration | Identifier) Dot;
+chainedMethod: Identifier OpenRoundBracket argumentList ClosedRoundBracket Dot;
 
 // Typen
 type: Int
     | Boolean
     | Char
-    | Identifier; // Datentypen
+    | Identifier;
 
-Void: 'void'; // Void-Typ
-Boolean: 'boolean'; // Boolean-Typ
-Char: 'char'; // Char-Typ
-Int: 'int'; // Integer-Typ
+Void: 'void';
+Boolean: 'boolean';
+Char: 'char';
+Int: 'int';
 
 value: IntValue
      | BooleanValue
      | CharValue
-     | NullValue; // Werte
+     | NullValue;
 
 // Zugriffsmodifikatoren
-AccessModifier: 'public' | 'private' | 'public static' | 'private static'; // Zugriffsmodifikatoren
-MainMethodDeclaration: 'public static void main(String[] args)'; // Hauptmethoden-Deklaration
+AccessModifier: 'public' | 'private' | 'public static' | 'private static';
+MainMethodDeclaration: 'public static void main(String[] args)';
 
 // Operatoren
-nonCalculationOperator: LogicalOperator | ComparisonOperator; // Nicht-Berechnungsoperatoren
+nonCalculationOperator: LogicalOperator | ComparisonOperator;
 
-DotOperator: Mult | Div | Modulo; // Punktoperatoren
-LineOperator: Plus | Minus; // Linienoperatoren
-ComparisonOperator: Greater | Less | GreaterEqual | LessEqual | Equal | NotEqual; // Vergleichsoperatoren
-LogicalOperator: And | Or; // Logische Operatoren
+DotOperator: Mult | Div | Modulo;
+LineOperator: Plus | Minus;
+ComparisonOperator: Greater | Less | GreaterEqual | LessEqual | Equal | NotEqual;
+LogicalOperator: And | Or;
 
-Assign: '='; // Zuweisungsoperator
-Plus: '+'; // Plus-Operator
-Minus: '-'; // Minus-Operator
-Mult: '*'; // Multiplikationsoperator
-Modulo: '%'; // Modulo-Operator
-Div: '/'; // Divisionsoperator
-Greater: '>'; // Größer-Operator
-Less: '<'; // Kleiner-Operator
-GreaterEqual: '>='; // Größer-Gleich-Operator
-LessEqual: '<='; // Kleiner-Gleich-Operator
-Equal: '=='; // Gleichheitsoperator
-NotEqual: '!='; // Ungleichheitsoperator
-Not: '!'; // Nicht-Operator
-And: '&&'; // Und-Operator
-Or: '||'; // Oder-Operator
+Assign: '=';
+Plus: '+';
+Minus: '-';
+Mult: '*';
+Modulo: '%';
+Div: '/';
+Greater: '>';
+Less: '<';
+GreaterEqual: '>=';
+LessEqual: '<=';
+Equal: '==';
+NotEqual: '!=';
+Not: '!';
+And: '&&';
+Or: '||';
 
 // Symbole
-Dot: '.'; // Punkt-Symbol
-OpenRoundBracket: '('; // Öffnende runde Klammer
-ClosedRoundBracket: ')'; // Schließende runde Klammer
-OpenCurlyBracket: '{'; // Öffnende geschweifte Klammer
-ClosedCurlyBracket: '}'; // Schließende geschweifte Klammer
-Semicolon: ';'; // Semikolon
-Comma: ','; // Komma
+Dot: '.';
+OpenRoundBracket: '(';
+ClosedRoundBracket: ')';
+OpenCurlyBracket: '{';
+ClosedCurlyBracket: '}';
+Semicolon: ';';
+Comma: ',';
 
 // Schlüsselwörter
 Class: 'class';
@@ -161,21 +161,21 @@ New: 'new';
 Switch: 'switch';
 Case: 'case';
 Default: 'default';
-Colon: ':'; // Doppelpunkt
+Colon: ':';
 
 // Werte
-CharValue: '\'' ~[\r\n]* '\''; // Zeichenwert
-IntValue: Minus? Numeric+; // Ganzzahlwert
-BooleanValue: 'true' | 'false'; // Boolean-Wert
-NullValue: 'null'; // Null-Wert
+CharValue: '\'' ~[\r\n]* '\'';
+IntValue: Minus? Numeric+;
+BooleanValue: 'true' | 'false';
+NullValue: 'null';
 
 // Bezeichner
 fragment Alphabetic: [a-zA-Z];
 fragment Numeric: [0-9];
 fragment ValidIdentSymbols: Alphabetic | Numeric | '$' | '_';
-Identifier: Alphabetic ValidIdentSymbols*; // Bezeichner
+Identifier: Alphabetic ValidIdentSymbols*;
 
 // Whitespaces und Kommentare ignorieren
-WS: [ \t\r\n]+ -> skip; // Leerzeichen ignorieren
-InlineComment: '//' ~[\r\n]* -> skip; // Einzeilige Kommentare ignorieren
-MultilineComment: '/*' .*? '*/' -> skip; // Mehrzeilige Kommentare ignorieren
+WS: [ \t\r\n]+ -> skip;
+InlineComment: '//' ~[\r\n]* -> skip;
+MultilineComment: '/*' .*? '*/' -> skip;

src/main/java/semantic/Scope.java

@@ -8,7 +8,7 @@ import java.util.Stack;
 
 public class Scope {
 
-    private final Stack<HashMap<String, ITypeNode>> localVars;
+    private Stack<HashMap<String, ITypeNode>> localVars;
 
     public Scope() {
         localVars = new Stack<HashMap<String, ITypeNode>>();

src/main/java/semantic/SemanticAnalyzer.java

@@ -1,5 +1,6 @@
 package semantic;
 
+
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -24,11 +25,15 @@ import ast.statementexpressions.methodcallstatementnexpressions.ChainedMethodNod
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
 import ast.statementexpressions.methodcallstatementnexpressions.TargetNode;
 import ast.statements.*;
+import ast.type.AccessModifierNode;
 import ast.type.EnumAccessModifierNode;
 import ast.type.ValueNode;
 import ast.type.type.*;
+import com.sun.jdi.IntegerType;
+import semantic.context.ClassContext;
 import semantic.context.Context;
 import semantic.exceptions.*;
+import typechecker.TypeCheckResult;
 
 public class SemanticAnalyzer implements SemanticVisitor {
 
@@ -109,6 +114,10 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
     @Override
     public TypeCheckResult analyze(MethodNode methodNode) {
+        if (methodNode instanceof ConstructorNode) {
+            return new TypeCheckResult(true, new BaseType(TypeEnum.VOID));
+        } else {
+
             var valid = true;
 
             for (var otherMethod : currentClass.getMethods()) {
@@ -150,6 +159,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
             }
 
             return new TypeCheckResult(valid, resultType);
+
+        }
     }
 
     @Override
@@ -166,6 +177,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
             currentFields.put(toCheck.identifier, toCheck.type);
         }
         return new TypeCheckResult(true, null);
+
+
     }
 
     @Override
@@ -240,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 {
@@ -254,11 +266,12 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 return new TypeCheckResult(true, type);
             } else if (currentScope.getLocalVar(toCheck.identifier) != null) {
                 var type = currentScope.getLocalVar(toCheck.identifier);
-                toCheck.setTypeNode(type);
                 return new TypeCheckResult(true, type);
             }
         }
+
         return new TypeCheckResult(true, null);
+
     }
 
     @Override
@@ -303,22 +316,9 @@ public class SemanticAnalyzer implements SemanticVisitor {
     @Override
     public TypeCheckResult analyze(IfElseNode toCheck) {
         var resultIf = toCheck.ifStatement.accept(this);
-        var validElseIf = true;
-
-        if(!toCheck.elseIfStatements.isEmpty()) {
-            for(IfNode ifNode : toCheck.elseIfStatements) {
-                var resultIfFor = ifNode.accept(this);
-                validElseIf = validElseIf && resultIfFor.isValid();
-            }
-        }
-
-        if(toCheck.elseStatement != null){
         var resultElse = toCheck.elseStatement.accept(this);
-            return new TypeCheckResult(resultIf.isValid() && resultElse.isValid() && validElseIf, new BaseType(TypeEnum.VOID));
-        }
 
-
-        return new TypeCheckResult(resultIf.isValid(), new BaseType(TypeEnum.VOID));
+        return new TypeCheckResult(resultIf.isValid() && resultElse.isValid(), new BaseType(TypeEnum.VOID));
     }
 
     @Override
@@ -359,7 +359,6 @@ public class SemanticAnalyzer implements SemanticVisitor {
                     if (toCheck.target.thisTar) {
                         var type = getTypeFromMethod(toCheck, new ReferenceType(currentClass.identifier));
                         if (type != null) {
-                            toCheck.type = type;
                             return new TypeCheckResult(true, type);
                         }
                     }
@@ -371,10 +370,6 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 }
             }
         } else {
-            if(toCheck.identifier != null) {
-                toCheck.target = new TargetNode(new MemberAccessNode(false));
-                toCheck.target.memberAccess.identifiers.add(currentClass.identifier);
-            }
 
             ReferenceType reference = new ReferenceType(currentClass.identifier);
             if (!toCheck.chainedMethods.isEmpty()) {
@@ -392,6 +387,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
             } else {
                 return new TypeCheckResult(false, null);
             }
+
         }
 
         return new TypeCheckResult(false, null);
@@ -429,10 +425,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
     @Override
     public TypeCheckResult analyze(NewDeclarationNode toCheck) {
+
         if (context.containsClass(toCheck.identifier)) {
-            for(var t : toCheck.expressions) {
-                t.accept(this);
-            }
             return new TypeCheckResult(true, new ReferenceType(toCheck.identifier));
         } else {
             throw new RuntimeException("Cannot find class " + toCheck.identifier);
@@ -460,7 +454,6 @@ public class SemanticAnalyzer implements SemanticVisitor {
                     case PLUS, MINUS:
                         if (calcRes.getType() instanceof BaseType calcType && dotRes.getType() instanceof BaseType dotType &&
                                 calcType.getTypeEnum().equals(TypeEnum.INT) && dotType.getTypeEnum().equals(TypeEnum.INT)) {
-                            calcNode.setType(new BaseType(TypeEnum.INT));
                             return new TypeCheckResult(true, new BaseType(TypeEnum.INT));
                         }
                         break;
@@ -468,12 +461,10 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 }
 
             } else {
-                calcNode.setType(calcNode.getType());
                 return new TypeCheckResult(calcRes.isValid(), calcRes.getType());
             }
         } else if (calcNode.dotExpression != null) {
             var dotRes = calcNode.dotExpression.accept(this);
-            calcNode.setType(dotRes.getType());
             return new TypeCheckResult(dotRes.isValid(), dotRes.getType());
         }
         return new TypeCheckResult(false, null);
@@ -481,46 +472,28 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
     @Override
     public TypeCheckResult analyze(DotNode toCheck) {
-        if (toCheck.dotSubtractionExpression != null) {
-            var result = toCheck.dotSubtractionExpression.accept(this);
-            toCheck.setType(result.getType());
-            return result;
+        if (toCheck.dotSubstractionExpression != null) {
+            return toCheck.dotSubstractionExpression.accept(this);
         }
         return new TypeCheckResult(false, null);
     }
 
     @Override
-    public TypeCheckResult analyze(DotSubtractionNode toCheck) {
+    public TypeCheckResult analyze(DotSubstractionNode toCheck) {
         if (toCheck.value != null) {
-            var result = toCheck.value.accept(this);
-            toCheck.setType(result.getType());
-            return result;
+            return toCheck.value.accept(this);
         } else if (toCheck.memberAccess != null) {
-            var result = toCheck.memberAccess.accept(this);
-            toCheck.setType(result.getType());
-            return result;
+            return toCheck.memberAccess.accept(this);
         } else if (toCheck.methodCall != null) {
-            var result = toCheck.methodCall.accept(this);
-            toCheck.setType(result.getType());
-            return result;
+            return toCheck.methodCall.accept(this);
         } else if (toCheck.identifier != null) {
             if (currentScope.contains(toCheck.identifier)) {
-                var type = currentScope.getLocalVar(toCheck.identifier);
-                toCheck.setType(type);
-                return new TypeCheckResult(true, type);
+                return new TypeCheckResult(true, currentScope.getLocalVar(toCheck.identifier));
             } else if (currentFields.get(toCheck.identifier) != null) {
-                var type = currentFields.get(toCheck.identifier);
-                toCheck.setType(type);
-                MemberAccessNode memberAccessNode = new MemberAccessNode(false);
-                memberAccessNode.identifiers.add(currentClass.identifier);
-                memberAccessNode.identifiers.add(toCheck.identifier);
-                toCheck.memberAccess = memberAccessNode;
-                return new TypeCheckResult(true, type);
+                return new TypeCheckResult(true, currentFields.get(toCheck.identifier));
             }
         } else if (toCheck.calculationExpression != null) {
-            var result = toCheck.calculationExpression.accept(this);
-            toCheck.setType(result.getType());
-            return result;
+            return toCheck.calculationExpression.accept(this);
         }
         return null;
     }
@@ -534,19 +507,15 @@ public class SemanticAnalyzer implements SemanticVisitor {
             case LESS, LESS_EQUAL, GREATER, GREATER_EQUAL:
                 if (expResult.getType() instanceof BaseType expResultType && expResultType.getTypeEnum().equals(TypeEnum.INT) &&
                         unaryResult.getType() instanceof BaseType unaryResultType && unaryResultType.getTypeEnum().equals(TypeEnum.INT)) {
-                    ITypeNode type = new BaseType(TypeEnum.BOOL);
-                    nonCalculationNode.setType(type);
-                    return new TypeCheckResult(true, type);
+                    return new TypeCheckResult(true, new BaseType(TypeEnum.BOOL));
                 } else {
                     errors.add(new TypeMismatchException("Both types must be Integer"));
                 }
                 break;
             case OR, AND:
-                if (expResult.getType() instanceof BaseType expResultType && expResultType.getTypeEnum().equals(TypeEnum.BOOL) &&
-                        unaryResult.getType() instanceof BaseType unaryResultType && unaryResultType.getTypeEnum().equals(TypeEnum.BOOL)) {
-                    ITypeNode type = new BaseType(TypeEnum.BOOL);
-                    nonCalculationNode.setType(type);
-                    return new TypeCheckResult(true, type);
+                if (expResult.getType() instanceof BaseType expResultType && expResultType.getTypeEnum().equals(TypeEnum.INT) &&
+                        unaryResult.getType() instanceof BaseType unaryResultType && unaryResultType.getTypeEnum().equals(TypeEnum.INT)) {
+                    return new TypeCheckResult(true, new BaseType(TypeEnum.BOOL));
                 } else {
                     errors.add(new TypeMismatchException("Both types must be Boolean"));
                 }
@@ -554,9 +523,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
             case EQUAL, NOT_EQUAL:
                 if (expResult.getType() instanceof BaseType expResultType && unaryResult.getType() instanceof BaseType unaryResultType
                         && Objects.equals(expResultType, unaryResultType)) {
-                    ITypeNode type = new BaseType(TypeEnum.BOOL);
-                    nonCalculationNode.setType(type);
-                    return new TypeCheckResult(true, type);
+                    return new TypeCheckResult(true, new BaseType(TypeEnum.BOOL));
                 } else {
                     errors.add(new TypeMismatchException("Both types must be the same"));
                 }
@@ -571,21 +538,13 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
         if (unary.identifier != null) {
             if (currentScope.contains(unary.identifier)) {
-                var type = currentScope.getLocalVar(unary.identifier);
-                unary.setType(type);
-                return new TypeCheckResult(valid, type);
+                return new TypeCheckResult(valid, currentScope.getLocalVar(unary.identifier));
             } else if (currentFields.get(unary.identifier) != null) {
                 MemberAccessNode memberAccessNode = new MemberAccessNode(false);
                 memberAccessNode.identifiers.add(currentClass.identifier);
                 memberAccessNode.identifiers.add(unary.identifier);
                 unary.memberAccess = memberAccessNode;
-                var type = currentFields.get(unary.identifier);
-                unary.setType(type);
-                return new TypeCheckResult(valid,type );
-            } else if (unary.value != null) {
-                var result = unary.value.accept(this);
-                unary.setType(result.getType());
-                return new TypeCheckResult(result.isValid(), result.getType());
+                return new TypeCheckResult(valid, currentFields.get(unary.identifier));
             } else if (unary.statement != null) {
                 var result = unary.statement.accept(this);
                 unary.setType(result.getType());
@@ -595,19 +554,15 @@ public class SemanticAnalyzer implements SemanticVisitor {
             }
         } else if (unary.statement != null) {
             var result = unary.statement.accept(this);
-            unary.setType(result.getType());
             return new TypeCheckResult(result.isValid(), result.getType());
         } else if (unary.value != null) {
             var result = unary.value.accept(this);
-            unary.setType(result.getType());
             return new TypeCheckResult(result.isValid(), result.getType());
         } else if (unary.memberAccess != null) {
             var result = unary.memberAccess.accept(this);
-            unary.setType(result.getType());
             return new TypeCheckResult(result.isValid(), result.getType());
         } else if (unary.expression != null) {
             var result = unary.expression.accept(this);
-            unary.setType(result.getType());
             return new TypeCheckResult(result.isValid(), result.getType());
         }
 
@@ -620,21 +575,18 @@ 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);
             if (currentType == null) {
                 if (currentScope.getLocalVar(s) != null) {
                     currentType = currentScope.getLocalVar(s);
+
                 } else if (currentFields.get(s) != null) {
                     currentType = currentFields.get(s);
                 } else {
@@ -645,8 +597,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();
@@ -658,7 +609,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
             }
 
         }
-        memberAccessNode.setTypeNode(currentType);
+
         return new TypeCheckResult(true, currentType);
     }
 
@@ -684,7 +635,6 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 return new TypeCheckResult(true, new BaseType(TypeEnum.INT));
             }
             case CHAR_VALUE -> {
-                valueNode.value = valueNode.value.replace("'", "");
                 return new TypeCheckResult(true, new BaseType(TypeEnum.CHAR));
             }
             case BOOLEAN_VALUE -> {

src/main/java/semantic/SemanticVisitor.java

@@ -15,6 +15,7 @@ import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
 import ast.statementexpressions.methodcallstatementnexpressions.TargetNode;
 import ast.statements.*;
 import ast.type.ValueNode;
+import typechecker.TypeCheckResult;
 
 public interface SemanticVisitor {
 
@@ -60,7 +61,7 @@ public interface SemanticVisitor {
 
     TypeCheckResult analyze(DotNode toCheck);
 
-    TypeCheckResult analyze(DotSubtractionNode toCheck);
+    TypeCheckResult analyze(DotSubstractionNode toCheck);
 
     TypeCheckResult analyze(NonCalculationNode toCheck);
 

src/main/java/semantic/context/ClassContext.java

@@ -9,8 +9,8 @@ import java.util.HashMap;
 
 public class ClassContext {
 
-  private final HashMap<String, FieldContext> fields;
-  private final ArrayList<MethodNode> methods = new ArrayList<>();
+  private HashMap<String, FieldContext> fields;
+  private ArrayList<MethodNode> methods = new ArrayList<>();
 
   public ClassContext(ClassNode classNode) {
 

src/main/java/semantic/context/Context.java

@@ -5,7 +5,7 @@ import java.util.HashMap;
 
 public class Context {
 
-  private final HashMap<String, ClassContext> classes;
+  private HashMap<String, ClassContext> classes;
 
   public Context(ProgramNode programNode) {
     classes = new HashMap<>();

src/main/java/semantic/context/FieldContext.java

@@ -6,8 +6,8 @@ import ast.type.type.*;
 
 public class FieldContext {
 
-  private final AccessModifierNode accessModifier;
-  private final ITypeNode type;
+  private AccessModifierNode accessModifier;
+  private ITypeNode type;
 
   public FieldContext(FieldNode field) {
     accessModifier = field.accessTypeNode;

src/main/java/typechecker/TypeCheckResult.java

@@ -1,12 +1,12 @@
-package semantic;
+package typechecker;
 
 
 import ast.type.type.ITypeNode;
 
 public class TypeCheckResult {
 
-  private final boolean valid;
-  private final ITypeNode type;
+  private boolean valid;
+  private ITypeNode type;
 
   public TypeCheckResult(boolean valid, ITypeNode type) {
     this.valid = valid;

src/main/java/visitor/Visitable.java

@@ -4,7 +4,7 @@ import bytecode.visitor.ClassVisitor;
 import bytecode.visitor.MethodVisitor;
 import bytecode.visitor.ProgramVisitor;
 import semantic.SemanticVisitor;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public interface Visitable {
     default void accept(ProgramVisitor programVisitor) {

src/main/resources/input/CompilerInput.java

@@ -1,63 +1,14 @@
-public class CompilerInput {
-    public int ps;
-    public char brand;
-    public int tires;
-    public int drivenKilometers;
-
-    public CompilerInput(int horsePower) {
-        this.ps = horsePower;
-        this.tires = 4;
-    }
-
-    public int getTires() {
-        return this.tires;
-    }
-
-    public boolean isSuperCar() {
-        if(this.ps > 300) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    public void tune(int horsePower) {
-        this.ps = this.ps + horsePower;
-    }
-
-    public void tune() {
-        this.ps = this.ps + 50;
-    }
-
-    public void driveCircels(int circels) {
-        for(int i = 0; i < circels; i++) {
-            this.drivenKilometers = this.drivenKilometers + 5;
-        }
-    }
-
-    public void isTunable(boolean hasEngine, boolean hasTires) {
-        if(hasEngine && hasTires) {
-            this.tune(5);
-        }
-    }
-
-    public char race() {
-        int enemyHorsePower = 200;
-        char win = 'W';
-        char lose = 'L';
-        CompilerInput enemy = new CompilerInput(ps);
-        if(this.ps > enemyHorsePower) {
-            return win;
-        } else {
-            return lose;
-        }
-    }
-
-    public int refuel(int currentTank, int maxTank){
-        int tank = currentTank;
-        do{
-            tank++;
-        }while(tank<maxTank);
-        return tank;
+public class Compiler {
+    public int add(int i, int j) {
+        return i+j;
     }
 }
+
+public class Node {
+    public void main() {
+        Compiler compiler = new Compiler();
+        int i = compiler.add(5, 8);
+        return i;
+    }
+}
+

src/test/Makefile

@@ -2,30 +2,44 @@
 ### IntelliJs play buttons do not work. Run in "src/test" folder with "make" command to run all
 ### Or run only parts with "make compile-javac", "make clean" etc.
 
-all: compile-javac compile-miniCompiler
+all: compile-javac compile-raupenpiler
 
 compile-javac:
-	javac -d .\resources\output\javac ..\main\resources\input\CompilerInput.java
+	javac -d .\resources\output\javac .\resources\input\CompilerInput.java
 
-compile-miniCompiler:
+compile-raupenpiler:
 	cd ../.. ; mvn -DskipTests install
 	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 .\resources\output\miniCompiler
+	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/
+	# compile the test class
+	javac .java/main.EndToEndTester.java
+	# run the test class
+	java .java/main.EndToEndTester
+
+
 
 clean:
-	# clean main output folders
+	# clean output folders
 	rm -f ../main/resources/output/*.class
 	rm -f ../main/resources/output/*.jar
-	# clean resources output folders
 	rm -f ./resources/output/javac/*.class
-	rm -f ./resources/output/miniCompiler/*.class
-	rm -f ./resources/output/miniCompiler/*.jar
+	rm -f ./resources/output/raupenpiler/*.class
 	# clean logs
-	rm -f ../main/resources/logs/*
+	rm -f ../main/resources/logs/*.log
 	# clean test/java/main folders from .class files for End-to-End tests
 	rm -f ./java/main/*.class
-	# clean javac output from every folder
-	rm -f ./resources/input/*/*.class
-	# clean test results from maven surefire plugin
-	rm -f ../../target/surefire-reports/*.txt
+	# clean javac output from combinedFeatureTests
+	rm -f ./resources/input/combinedFeatureTests/*.class
+	rm -f ./resources/input/singleFeatureTests/*.class
+	rm -f ./resources/input/typedAstFeatureTests/*.class
 

src/test/TestSpecs.md

@@ -0,0 +1,93 @@
+# Scanner
+
+## Scanner Input
+
+### Beispiel 1: Empty Class
+
+    String empty class = "public class Name {}";
+
+### Beispiel 2: Filled Class
+
+    String filled class = 
+            "class javaFileInput.Example {" +
+            "if (x < 5) {" +
+            "for (int i = 0; i < 10; i++) {" +
+            "while (true) {" +
+            "x = 5;" +
+            "}"
+
+## Scanner Output
+
+CommonTokenStream
+
+### Beispiel 1: Empty Class
+
+Token Type; Token Text
+Type gibts nur bei Terminalen, Text bei allen
+
+    [null "public", null "class", IDENTIFIER "Name", null "{", null "}", EOF "<EOF>"]
+
+    Bsp von Ihm mal:
+    [TokPublic,TokClass,TokIdentifier "Name",TokLeftBrace,TokRightBrace]
+
+# Parser
+
+## Parser Input
+
+CommonTokenStream
+(Scanner Output)
+
+## Parser Output (AST)
+
+(program (classDeclaration (accessType public) class Name { }))
+
+ParseTree
+
+### Beispiel 1: Empty Class
+
+# Semantische Analyse / Typcheck
+
+## Typcheck Input
+
+(Parser Output = AST)
+
+## Typcheck Output
+
+### Beispiel 1: Empty Class
+
+# Bytecodegenerierung
+
+## Bytecodegenerierung Input
+
+(Typcheck Output = vom Typcheck eventuell manipulierter AST)
+
+## Bytecodegenerierung Output
+
+### Beispiel 1: Empty Class
+
+Compiled Classfile
+
+    public class javaFileInput.Example {
+    }
+
+## E2E Tests:
+
+- Testdatei mit Main ausführen/kompilieren
+- Testdatei mit "javac -d output .\CompilerInput.java" kompilieren
+- -> Dateien mit javap vergleichen
+
+wenn beides erfolgreich
+
+- Ergebnis vom eigenen Compiler mithilfe von main.EndToEndTester ausführen
+- (Ergebnis von javac mithilfe von main.EndToEndTester ausführen)
+
+### Andis Tipps:
+
+- cp mitgeben
+- makefile
+- java -jar pfadtocompiler.jar EmptyClass.java
+- mvn package
+- javac tester // tester compilen
+- java tester // tester ausführen
+- -> tester ist in unserem Fall main.EndToEndTester.java
+- -> Hab ich alles umgesetzt

src/test/java/main/E2EReflectionsTest.java

@@ -1,209 +1,95 @@
 package main;
 
-import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.nio.file.StandardCopyOption;
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Test;
+
 import javax.tools.JavaCompiler;
 import javax.tools.ToolProvider;
 
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.*;
 
 public class E2EReflectionsTest {
-
     @Test
-    public void CharTest() {
-        runTest("Char");
-    }
-
-    @Test
-    public void CommentsTest() {
-        runTest("Comments");
-    }
-
-    @Test
-    public void ConstructorMethodCallTest() {
-        runTest("ConstructorMethodCall");
-    }
-
-    @Test
-    public void ConstructorMethodCallParametersTest() {
-        runTest("ConstructorMethodCallParameters");
-    }
-
-    @Test
-    public void ConstructorParameterTest() {
-        runTest("ConstructorParameter");
-    }
-
-    @Test
-    public void ConstructorThisDotTest() {
-        runTest("ConstructorThisDot");
-    }
-
-    @Test
-    public void DoWhileTest() {
-        runTest("DoWhile");
-    }
-
-    @Test
-    public void EmptyClassTest() {
-        runTest("EmptyClass");
-    }
-
-    @Test
-    public void EmptyClassWithConstructorTest() {
-        runTest("EmptyClassWithConstructor");
-    }
-
-    @Test
-    public void FieldTest() {
-        runTest("Field");
-    }
-
-    @Test
-    public void FieldWithAccessModifierTest() {
-        runTest("FieldWithAccessModifier");
-    }
-
-    @Test
-    public void ForTest() {
-        runTest("For");
-    }
-
-    @Test
-    public void IfTest() {
-        runTest("If");
-    }
-
-    @Test
-    public void IfElseTest() {
-        runTest("IfElse");
-    }
-
-    @Test
-    public void IfElseIfElseTest() {
-        runTest("IfElseIfElse");
-    }
-
-    @Test
-    public void IncrementTest() {
-        runTest("Increment");
-    }
-
-    @Test
-    public void MainMethodTest() {
-        runTest("MainMethod");
-    }
-
-    @Test
-    public void MultipleClassesTest() {
-        runTest("MultipleClasses");
-    }
-
-    @Test
-    public void ThisDotTest() {
-        runTest("ThisDot");
-    }
-
-    @Test
-    public void VariableCalculationTest() {
-        runTest("VariableCalculation");
-    }
-
-    @Test
-    public void VariableCompareTest() {
-        runTest("VariableCompare");
-    }
-
-    @Test
-    public void VoidMethodTest() {
-        runTest("VoidMethod");
-    }
-
-    @Test
-    public void WhileTest() {
-        runTest("While");
-    }
-
-    // Helper method to eliminate redundancy
-    private void runTest(String fileName) {
+    public void AllFeaturesClassExampleTest(){
         try {
-            // compile with miniCompiler
-            Main.main(new String[]{"src/test/resources/input/singleFeatureTests/" + fileName + ".java", "src/test/resources/output/miniCompiler"});
+            Main.main(new String[]{"src/test/resources/input/combinedFeatureTests/AllFeaturesClassExample.java", "src/test/resources/output/raupenpiler"});
             // Get the system Java compiler
             JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
             // Assert that the compiler is available
             assertNotNull(javac, "Java Compiler is not available");
-            // compile with javac
-            javac.run(null, null, null, "src/test/resources/input/singleFeatureTests/" + fileName + ".java");
-            moveFile("src/test/resources/input/singleFeatureTests/" + fileName + ".class", "src/test/resources/output/javac/" + fileName + ".class");
+            javac.run(null, null, null, "src/test/resources/input/combinedFeatureTests/AllFeaturesClassExample.java");
 
-            // Load the javac class
-            Path javacClassPath = Paths.get("src/test/resources/output/javac");
-            ClassLoader javacClassLoader = new java.net.URLClassLoader(new java.net.URL[]{javacClassPath.toUri().toURL()});
-            Class<?> javacLoadedClass = javacClassLoader.loadClass(fileName);
-
-            // Load the miniCompiler class
-            Path miniCompilerClassPath = Paths.get("src/test/resources/output/miniCompiler");
-            ClassLoader miniCompilerClassLoader = new java.net.URLClassLoader(new java.net.URL[]{miniCompilerClassPath.toUri().toURL()});
-            Class<?> miniCompilerLoadedClass = miniCompilerClassLoader.loadClass(fileName);
+            Class<?> clazz = Class.forName("src.resources.input.combinedFeatureTests.AllFeaturesClassExample");
+            ClassLoader classLoader = getClass().getClassLoader();
+           // Class<?> clazz = classLoader.loadClass("main.AllFeaturesClassExample");
 
             // Class Name
-            assertEquals(fileName, javacLoadedClass.getName());
-            assertEquals(fileName, miniCompilerLoadedClass.getName());
+            assertEquals("main.AllFeaturesClassExample", clazz.getName());
 
             // Constructors
-            Constructor<?>[] javacConstructors = javacLoadedClass.getDeclaredConstructors();
-            Constructor<?>[] miniCompilerConstructors = miniCompilerLoadedClass.getDeclaredConstructors();
-            assertEquals(javacConstructors.length, miniCompilerConstructors.length);
-            for (Constructor<?> c : javacConstructors) {
-                for (Constructor<?> miniCompilerConstructor : miniCompilerConstructors) {
-                    assertEquals(c.getParameterCount(), miniCompilerConstructor.getParameterCount());
-                    if (c.getParameterCount() == miniCompilerConstructor.getParameterCount()) {
-                        assertEquals(c.getName(), miniCompilerConstructor.getName());
-                    }
+            Constructor<?>[] actualConstructors = clazz.getDeclaredConstructors();
+            assertTrue(actualConstructors.length > 0, "No constructors found");
+
+            Constructor<?> expectedConstructor = clazz.getConstructor(int.class, boolean.class, char.class);
+
+            boolean constructorFound = false;
+            for (Constructor<?> constructor : actualConstructors) {
+                if (constructor.equals(expectedConstructor)) {
+                    constructorFound = true;
+                    break;
                 }
             }
+            assertTrue(constructorFound, "Expected constructor not found in actual constructors");
 
             // Methods
-            Method[] javacMethods = javacLoadedClass.getDeclaredMethods();
-            Method[] miniCompilerMethods = miniCompilerLoadedClass.getDeclaredMethods();
-            assertEquals(javacMethods.length, miniCompilerMethods.length);
-            for (int i = 0; i < javacMethods.length; i++) {
-                assertEquals(javacMethods[i].getName(), miniCompilerMethods[i].getName());
-                assertEquals(javacMethods[i].getReturnType(), miniCompilerMethods[i].getReturnType());
-                assertEquals(javacMethods[i].getParameterCount(), miniCompilerMethods[i].getParameterCount());
+            Method[] actualMethodNames = clazz.getDeclaredMethods();
+            assertTrue(actualMethodNames.length > 0);
+            for (Method method : actualMethodNames) {
+                System.out.println("Method: " + method.getName());
+            }
+
+            // Method Names
+            String[] expectedMethodNames = {
+                "controlStructures",
+                "logicalOperations",
+                "add",
+                "subtract",
+                "multiply",
+                "divide",
+                "modulo",
+                "main"
+            };
+
+            for (Method method : actualMethodNames) {
+                assertTrue(Arrays.asList(expectedMethodNames).contains(method.getName()));
             }
 
             // Fields
-            Field[] javacLoadedClassDeclaredFields = javacLoadedClass.getDeclaredFields();
-            Field[] miniCompilerLoadedClassDeclaredFields = miniCompilerLoadedClass.getDeclaredFields();
-            assertEquals(javacLoadedClassDeclaredFields.length, miniCompilerLoadedClassDeclaredFields.length);
-            for (Field field : javacLoadedClassDeclaredFields) {
-                for (Field miniCompilerField : miniCompilerLoadedClassDeclaredFields) {
-                    if (field.getName().equals(miniCompilerField.getName())) {
-                        assertEquals(field.getType(), miniCompilerField.getType());
-                    }
+            Field[] actualFields = clazz.getDeclaredFields();
+            assertTrue(actualFields.length > 0, "No fields found");
+
+            Field expectedField = clazz.getDeclaredField("c");
+            assertEquals(expectedField.getType(), char.class);
+
+            boolean fieldFound = false;
+            for (Field field : actualFields) {
+                if (field.equals(expectedField)) {
+                    fieldFound = true;
+                    break;
                 }
             }
+            assertTrue(fieldFound, "Expected field not found in actual fields");
+
+
+
         } catch (ClassNotFoundException | NoSuchFieldException | NoSuchMethodException e) {
             e.printStackTrace();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
-
-    // Helper method to move file
-    public static void moveFile(String sourceFilePath, String destinationFilePath) throws IOException {
-        Path sourcePath = Paths.get(sourceFilePath);
-        Path destinationPath = Paths.get(destinationFilePath);
-        Files.move(sourcePath, destinationPath, StandardCopyOption.REPLACE_EXISTING);
-    }
 }

src/test/java/main/EndToEndTester.java

@@ -0,0 +1,45 @@
+package main;
+
+/**
+ * This class is used to test the output of the compiler.
+ *
+ * <p>Im gleichen Ordner wie diese Datei (EndToEndTester.java) muss die selbst kompilierte CompilerInput.class Datei sein.
+ * <br><strong>Hinweis:</strong> Diese muss man also vom Ordner <code> main/resources/output </code> in diesen Ordner hier (test/java/main) rein kopieren. (bis es eine bessere Lösung gibt -> bin grad in der Make dran das alles hier automatisch zu machen)</p>
+ *
+ * <p>Die selbst kompilierte .class Datei wird dann hier drin geladen und eine Instanz von ihr erstellt, es können auch Methoden aufgerufen werden.
+ * <p>Diese EndToEndTester.java Datei wird dann in <code> \src\test\java> </code>  mit <code>javac .\main.EndToEndTester.java</code> kompiliert und mit <code>java main.EndToEndTester</code> ausgeführt.
+ * Wenn unser Compiler funktioniert, sollten keine Errors kommen (sondern nur die Ausgaben, die wir in der CompilerInput.java Datei gemacht haben,
+ * oder Methoden, die wir hier aufrufen).</p>
+ *
+ * <p><strong>PROBLEM:</strong> Hier kommen Errors, was eigentlich heißt, dass der Compiler nicht funktioniert, der Test sollte eigentlich passen.
+ * <br><strong>DENN:</strong> Wenn ich statt unserem CompilerInput.class die CompilerInput.class von javac verwende (aus  <code> src/test/resources/output/javac </code>), dann funktioniert es.</p>
+ */
+public class EndToEndTester {
+    public static void main(String[] args) {
+        try {
+            // Try to load the class named "CompilerInput"
+            Class<?> cls = Class.forName("CompilerInput");
+            // Print a success message if the class is loaded successfully
+            System.out.println("Class loaded successfully: " + cls.getName());
+
+            // Try to create an instance of the loaded class
+            Object instance = cls.getDeclaredConstructor().newInstance();
+            // Print a success message if the instance is created successfully
+            System.out.println("Instance created: " + instance);
+
+
+            // If the class has a main method, you can invoke it
+            // cls.getMethod("main", String[].class).invoke(null, (Object) new String[]{});
+
+            // If the class has other methods, you can invoke them as well
+            // Example: cls.getMethod("someMethod").invoke(instance);
+
+        } catch (ClassNotFoundException e) {
+            // Print an error message if the class is not found
+            System.err.println("Class not found: " + e.getMessage());
+        } catch (Exception e) {
+            // Print an error message if any other exception occurs during class loading or instance creation
+            System.err.println("Error during class loading or execution: " + e.getMessage());
+        }
+    }
+}

src/test/java/main/InputFilesTest.java

@@ -26,69 +26,13 @@ public class InputFilesTest {
         // Assert that the compiler is available
         assertNotNull(javac, "Java Compiler is not available");
 
-        File combinedFeatureTests = new File("src/test/resources/input/combinedFeatureTests");
-        File endabgabeTests = new File("src/test/resources/input/endabgabeTests");
-        File singleFeatureSemanticTests = new File("src/test/resources/input/singleFeatureSemanticTests");
-        File singleFeatureTests = new File("src/test/resources/input/singleFeatureTests");
-        File typedAstFeatureTests = new File("src/test/resources/input/typedAstFeatureTests");
-        File finalTest = new File("src/test/resources/input/finalTest");
+        File folder1 = new File("src/test/resources/input/combinedFeatureTests");
+        File folder2 = new File("src/test/resources/input/singleFeatureTests");
+        File folder3 = new File("src/test/resources/input/typedAstFeatureTests");
 
-        List<File> files = getJavaFilesFromDirectory(combinedFeatureTests);
-        // files.addAll(getJavaFilesFromDirectory(endabgabeTests));
-        // files.addAll(getJavaFilesFromDirectory(singleFeatureSemanticTests));
-        files.addAll(getJavaFilesFromDirectory(singleFeatureTests));
-        // files.addAll(getJavaFilesFromDirectory(typedAstFeatureTests));
-        //files.addAll(getJavaFilesFromDirectory(finalTest));
-
-        if (!files.isEmpty()) {
-            for (File file : files) {
-                // Try to compile the file and get the result
-                int result = javac.run(null, null, null, file.getPath());
-
-                // Assert that the compilation succeeded (i.e., the result is zero)
-                assertEquals(0, result, "Expected compilation success for " + file.getName());
-            }
-        } else {
-            System.out.println("No files found in the directories.");
-        }
-    }
-
-    @Test
-    public void areCombinedFeatureTestsValid() throws IOException {
-        // Get the system Java compiler
-        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
-        // Assert that the compiler is available
-        assertNotNull(javac, "Java Compiler is not available");
-
-        File combinedFeatureTests = new File("src/test/resources/input/combinedFeatureTests");
-
-        List<File> files = getJavaFilesFromDirectory(combinedFeatureTests);
-
-        if (!files.isEmpty()) {
-            for (File file : files) {
-                // Try to compile the file and get the result
-                int result = javac.run(null, null, null, file.getPath());
-
-                // Assert that the compilation succeeded (i.e., the result is zero)
-                assertEquals(0, result, "Expected compilation success for " + file.getName());
-            }
-        } else {
-            System.out.println("No files found in the directories.");
-        }
-    }
-
-
-
-    @Test
-    public void areSingleFeatureTestsActuallyValid() throws IOException {
-        // Get the system Java compiler
-        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
-        // Assert that the compiler is available
-        assertNotNull(javac, "Java Compiler is not available");
-
-        File singleFeatureTests = new File("src/test/resources/input/singleFeatureTests");
-
-        List<File> files = getJavaFilesFromDirectory(singleFeatureTests);
+        List<File> files = getJavaFilesFromDirectory(folder1);
+        files.addAll(getJavaFilesFromDirectory(folder2));
+        files.addAll(getJavaFilesFromDirectory(folder3));
 
         if (!files.isEmpty()) {
             for (File file : files) {

src/test/java/main/MainTest.java

@@ -1,18 +1,28 @@
 package main;
 
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-import semantic.EndToTypedAstTest;
-import semantic.SemanticTest;
+import org.junit.jupiter.api.Test;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+
 
 /**
- * This class is a test suite that runs all the test classes in the project.
- * <p> run: <code> mvn test </code>
- * <p> check results in console or <code> target/surefire-reports </code>
+ * run every test: mvn test
+ * Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen
  */
-@RunWith(Suite.class)
-@Suite.SuiteClasses({
-})
 public class MainTest {
-    // This class remains empty, it is used only as a holder for the above annotations
+    @Test
+    void test() {
+        CharStream codeCharStream = null;
+        try {
+            codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/CompilerInput.java"));
+            Main.compileFile(codeCharStream, "src/main/test/resources/output");
+        } catch (IOException e) {
+            System.err.println("Error reading the file: " + e.getMessage());
+        }
+    }
 }
+
+

src/test/java/main/ReflectionsTest.java

@@ -0,0 +1,145 @@
+package main;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+
+import org.antlr.v4.runtime.CharStream;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+
+public class ReflectionsTest {
+
+    @Test
+    public void testSimpleJavaLexerClass() throws ClassNotFoundException, NoSuchMethodException {
+        Class<?> clazz = Class.forName("parser.generated.SimpleJavaLexer");
+
+        // Class Name
+        assertEquals("parser.generated.SimpleJavaLexer", clazz.getName());
+
+        // Constructors
+        Constructor<?>[] actualConstructors = clazz.getDeclaredConstructors();
+        assertTrue(actualConstructors.length > 0, "No constructors found");
+
+        Constructor<?> expectedConstructor = clazz.getConstructor(CharStream.class);
+
+        boolean constructorFound = false;
+        for (Constructor<?> constructor : actualConstructors) {
+            if (constructor.equals(expectedConstructor)) {
+                constructorFound = true;
+                break;
+            }
+        }
+        assertTrue(constructorFound, "Expected constructor not found in actual constructors");
+
+
+
+        // Methods
+        Method[] actualMethodNames = clazz.getDeclaredMethods();
+        assertTrue(actualMethodNames.length > 0);
+        Arrays.stream(actualMethodNames).forEach(method -> System.out.println("Method: " + method.getName()));
+
+        List<String> expectedMethodNames = Arrays.asList(
+                "getTokenNames",
+                "getVocabulary",
+                "getGrammarFileName",
+                "getRuleNames",
+                "getSerializedATN",
+                "getChannelNames",
+                "getModeNames",
+                "getATN",
+                "makeRuleNames",
+                "makeLiteralNames",
+                "makeSymbolicNames"
+        );
+
+        for (Method method : actualMethodNames) {
+            assertTrue(expectedMethodNames.contains(method.getName()));
+        }
+
+        for (String expectedMethodName : expectedMethodNames) {
+            boolean methodFound = false;
+            for (Method method : actualMethodNames) {
+                if (method.getName().equals(expectedMethodName)) {
+                    methodFound = true;
+                    break;
+                }
+            }
+            assertTrue(methodFound, "Expected method " + expectedMethodName + " not found in actual methods");
+        }
+
+
+        // Fields
+        Field[] actualFieldNames = clazz.getDeclaredFields();
+        assertTrue(actualFieldNames.length > 0);
+        Arrays.stream(actualFieldNames).forEach(field -> System.out.println("Field: " + field.getName()));
+
+        List<String> expectedFieldNames = Arrays.asList(
+                "_decisionToDFA",
+                "_sharedContextCache",
+                "channelNames",
+                "modeNames",
+                "ruleNames",
+                "_LITERAL_NAMES",
+                "_SYMBOLIC_NAMES",
+                "VOCABULARY",
+                "tokenNames",
+                "_serializedATN",
+                "_ATN"
+        );
+
+        for (Field field : actualFieldNames) {
+            assertTrue(expectedFieldNames.contains(field.getName()));
+        }
+    }
+
+    @Test
+    public void testSimpleJavaParserClass() throws ClassNotFoundException {
+        Class<?> clazz = Class.forName("parser.generated.SimpleJavaParser");
+
+        // Class Name
+        assertEquals("parser.generated.SimpleJavaParser", clazz.getName());
+
+        // Constructors
+        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+        assertTrue(constructors.length > 0);
+
+        // Methods
+        Method[] methods = clazz.getDeclaredMethods();
+        assertTrue(methods.length > 0);
+        Arrays.stream(methods).forEach(method -> System.out.println("Method: " + method.getName()));
+
+        // Fields
+        Field[] fields = clazz.getDeclaredFields();
+        assertTrue(fields.length > 0);
+        Arrays.stream(fields).forEach(field -> System.out.println("Field: " + field.getName()));
+    }
+
+    @Test
+    public void testASTBuilderClass() throws ClassNotFoundException {
+        Class<?> clazz = Class.forName("parser.astBuilder.ASTBuilder");
+
+        // Class Name
+        assertEquals("parser.astBuilder.ASTBuilder", clazz.getName());
+
+        // Constructors
+        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+        assertTrue(constructors.length > 0);
+
+        // Methods
+        Method[] methods = clazz.getDeclaredMethods();
+        assertTrue(methods.length > 0);
+        Arrays.stream(methods).forEach(method -> System.out.println("Method: " + method.getName()));
+
+        // Fields
+        Field[] fields = clazz.getDeclaredFields();
+        assertTrue(fields.length > 0);
+        Arrays.stream(fields).forEach(field -> System.out.println("Field: " + field.getName()));
+    }
+
+    // Similarly, you can add tests for SemanticAnalyzer and ByteCodeGenerator
+}

src/test/java/parser/AstBuilderTest.java

@@ -6,7 +6,7 @@ import ast.ProgramNode;
 import ast.expressions.IExpressionNode;
 import ast.expressions.binaryexpressions.CalculationNode;
 import ast.expressions.binaryexpressions.DotNode;
-import ast.expressions.binaryexpressions.DotSubtractionNode;
+import ast.expressions.binaryexpressions.DotSubstractionNode;
 import ast.expressions.binaryexpressions.NonCalculationNode;
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.expressions.unaryexpressions.UnaryNode;
@@ -308,6 +308,31 @@ class AstBuilderTest {
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
+    @Test
+    @DisplayName("Null Test")
+    public void nullTest() {
+        BlockNode blockCon = new BlockNode();
+        MemberAccessNode memberAccess = new MemberAccessNode(true);
+        memberAccess.addIdentifier("a");
+
+        AssignableNode assignable = new AssignableNode(memberAccess);
+
+        blockCon.addStatement(new AssignNode(assignable, new UnaryNode(new ValueNode(EnumValueNode.NULL_VALUE, "null"))));
+        blockCon.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "Null", blockCon);
+
+        ClassNode class1 = new ClassNode("public", "Null");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new ReferenceType("Null"), "a"));
+        class1.addMember(constructor);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST(directoryPath + "Null.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
     @Test
     @DisplayName("If Test")
     public void ifTest() {
@@ -403,7 +428,7 @@ class AstBuilderTest {
         MemberNode testClassObject = new FieldNode(new AccessModifierNode("public"), new ReferenceType("SelfReference"),"selfReference");
 
         BlockNode testMethod1Block = new BlockNode();
-        testMethod1Block.addStatement(new ReturnNode(new UnaryNode(new MethodCallNode(null, "testMethod2"))));
+        testMethod1Block.addStatement(new ReturnNode(new UnaryNode(new MethodCallNode(new TargetNode(true), "testMethod2"))));
         MethodNode testMethod1 = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod1", testMethod1Block);
 
         BlockNode testMethod2Block = new BlockNode();
@@ -413,7 +438,9 @@ class AstBuilderTest {
         BlockNode testMethod3Block = new BlockNode();
         testMethod3Block.addStatement(new LocalVariableDeclarationNode(new ReferenceType("SelfReference"),"selfReference1", "=", new UnaryNode(new NewDeclarationNode("SelfReference")))); // Assing einfach "=" ?
         MemberAccessNode methodAccess = new MemberAccessNode(false);
-        TargetNode methodTarget = new TargetNode("selfReference1");
+        methodAccess.addIdentifier("selfReference1");
+        methodAccess.addIdentifier("selfReference");
+        TargetNode methodTarget = new TargetNode(methodAccess);
         testMethod3Block.addStatement(new ReturnNode(new UnaryNode(new MethodCallNode(methodTarget,"testMethod1"))));
         MethodNode testMethod3 = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod3", testMethod3Block);
 
@@ -487,31 +514,31 @@ class AstBuilderTest {
         ClassNode class1 = Helper.generateEmptyClass("VariableCalculation");
 
         BlockNode aPlusBBlock = new BlockNode();
-        aPlusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubtractionNode("a"))), "+", new DotNode(new DotSubtractionNode("b")))));
+        aPlusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubstractionNode("a"))), "+", new DotNode(new DotSubstractionNode("b")))));
         MethodNode aPlusBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aPlusB", aPlusBBlock);
         aPlusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
         aPlusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
 
         BlockNode aMinusBBlock = new BlockNode();
-        aMinusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubtractionNode("a"))), "-", new DotNode(new DotSubtractionNode("b")))));
+        aMinusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubstractionNode("a"))), "-", new DotNode(new DotSubstractionNode("b")))));
         MethodNode aMinusBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aMinusB", aMinusBBlock);
         aMinusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
         aMinusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
 
         BlockNode aTimeBBlock = new BlockNode();
-        aTimeBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubtractionNode("a")), "*", new DotSubtractionNode("b")))));
+        aTimeBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "*", new DotSubstractionNode("b")))));
         MethodNode aTimeBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aTimeB", aTimeBBlock);
         aTimeBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
         aTimeBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
 
         BlockNode aDivBBlock = new BlockNode();
-        aDivBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubtractionNode("a")), "/", new DotSubtractionNode("b")))));
+        aDivBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "/", new DotSubstractionNode("b")))));
         MethodNode aDivBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aDivB", aDivBBlock);
         aDivBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
         aDivBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
 
         BlockNode complexCalcBlock = new BlockNode();
-        complexCalcBlock.addStatement(new ReturnNode(new CalculationNode(null, null, new DotNode(new DotNode(new DotNode(new DotNode(new DotSubtractionNode("a")), "*", new DotSubtractionNode("b")), "/", new DotSubtractionNode(new ValueNode(EnumValueNode.INT_VALUE, "1"))), "*", new DotSubtractionNode(new ValueNode(EnumValueNode.INT_VALUE, "3"))))));
+        complexCalcBlock.addStatement(new ReturnNode(new CalculationNode(null, null, new DotNode(new DotNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "*", new DotSubstractionNode("b")), "/", new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, "1"))), "*", new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, "3"))))));
         MethodNode complexCalcMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "complexCalc", complexCalcBlock);
         complexCalcMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
         complexCalcMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
@@ -583,7 +610,7 @@ class AstBuilderTest {
         blockCon.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "i", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "10"))));
         blockCon.addStatement(whileStatement);
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "While", blockCon);
+        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
 
         ClassNode class1 = new ClassNode("public", "While");
         class1.addMember(constructor);
@@ -614,7 +641,7 @@ class AstBuilderTest {
         blockCon.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "i", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "0"))));
         blockCon.addStatement(blockDoWhile);
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "DoWhile", blockCon);
+        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
 
         ClassNode class1 = new ClassNode("public", "DoWhile");
         class1.addMember(constructor);
@@ -633,7 +660,7 @@ class AstBuilderTest {
         LocalVariableDeclarationNode forDeclaration = new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "i", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "0")));
 
         AssignableNode assignable = new AssignableNode("i");
-        IncrementNode increment = new IncrementNode(CrementType.PREFIX, assignable);
+        IncrementNode increment = new IncrementNode(CrementType.SUFFIX, assignable);
 
         LocalVariableDeclarationNode declaration = new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "a", null, null);
 
@@ -650,7 +677,7 @@ class AstBuilderTest {
         BlockNode blockCon = new BlockNode();
         blockCon.addStatement(forStatement);
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "For", blockCon);
+        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
 
         ClassNode class1 = new ClassNode("public", "For");
         class1.addMember(constructor);

src/test/java/parser/Helper.java

@@ -2,10 +2,12 @@ package parser;
 
 import ast.ASTNode;
 import ast.ClassNode;
+import ast.ProgramNode;
 import ast.members.ConstructorNode;
 import ast.members.MemberNode;
 import ast.statements.BlockNode;
 import ast.statements.ReturnNode;
+import ast.type.AccessModifierNode;
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
@@ -37,7 +39,7 @@ public class Helper {
     public static ClassNode generateEmptyClass(String className) {
         BlockNode blockNode = new BlockNode();
         blockNode.addStatement(new ReturnNode(null));
-        MemberNode constructor = new ConstructorNode("public", className, blockNode);
+        MemberNode constructor = new ConstructorNode("public",className, blockNode);
         ClassNode classNode = new ClassNode("public", className);
         classNode.addMember(constructor);
         return classNode;

src/test/java/parser/ParserTest.java

@@ -0,0 +1,138 @@
+package parser;
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import parser.generated.SimpleJavaLexer;
+import parser.generated.SimpleJavaParser;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.*;
+
+public class ParserTest {
+    /*
+    @BeforeEach
+    public void init() { // noch nicht benötigt
+        String inputFilePath = "src/main/resources/input/CompilerInput.java";
+        String outputDirectoryPath = "src/main/resources/output";
+    }
+     */
+
+    @Test
+    public void parserTest() {
+        // init
+        CharStream inputCharStream = CharStreams.fromString("public class Name {}");
+        SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+        tokenStream.fill();
+
+
+        /* Parser -> Parsetree */
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTree = parser.program(); // parse the input
+
+        //Variante 1 (geht)
+        String expectedParseTreeAsString = "(program (classDeclaration public class Name { }))";
+        String actualParseTreeAsString = parseTree.toStringTree(parser);
+
+        assertEquals(expectedParseTreeAsString, actualParseTreeAsString);
+
+        // Variante 2 (geht nicht)
+        // - Sollte es gehen und es liegt am Parser? (keine Ahnung)  -> Bitte Fehler (actual und expected) durchlesen
+        // ist die Methode parseStringToTree() korrekt? -> (glaub nicht)
+        Map<String, Object> expectedTreeStructure = parseStringToTree(expectedParseTreeAsString);
+        Map<String, Object> actualTreeStructure = buildTreeStructure(parseTree, parser);
+
+        // assertEquals(expectedTreeStructure, actualTreeStructure);
+    }
+
+
+
+    // Helpers Variante 2.1
+
+    public static Map<String, Object> buildTreeStructure(ParseTree tree, Parser parser) {
+        return buildTree(tree, parser, 0);
+    }
+
+    private static Map<String, Object> buildTree(ParseTree tree, Parser parser, int indent) {
+        Map<String, Object> node = new HashMap<>();
+
+        if (tree instanceof RuleContext) {
+            int ruleIndex = ((RuleContext) tree).getRuleIndex();
+            String ruleName = parser.getRuleNames()[ruleIndex];
+            node.put("rule", ruleName);
+        } else {
+            node.put("text", tree.getText());
+        }
+
+        List<Map<String, Object>> children = new ArrayList<>();
+        for (int i = 0; i < tree.getChildCount(); i++) {
+            children.add(buildTree(tree.getChild(i), parser, indent + 1));
+        }
+
+        if (!children.isEmpty()) {
+            node.put("children", children);
+        }
+
+        return node;
+    }
+
+    // Helpers Variante 2.2
+
+    public static Map<String, Object> parseStringToTree(String input) {
+        input = input.trim();
+        if (input.startsWith("(") && input.endsWith(")")) {
+            input = input.substring(1, input.length() - 1).trim();
+        }
+        return parse(input);
+    }
+
+    private static Map<String, Object> parse(String input) {
+        Map<String, Object> node = new HashMap<>();
+        StringBuilder currentToken = new StringBuilder();
+        List<Map<String, Object>> children = new ArrayList<>();
+
+        int depth = 0;
+        boolean inToken = false;
+        for (char ch : input.toCharArray()) {
+            if (ch == '(') {
+                if (depth == 0) {
+                    if (!currentToken.isEmpty()) {
+                        node.put("node", currentToken.toString().trim());
+                        currentToken.setLength(0);
+                    }
+                } else {
+                    currentToken.append(ch);
+                }
+                depth++;
+            } else if (ch == ')') {
+                depth--;
+                if (depth == 0) {
+                    children.add(parse(currentToken.toString().trim()));
+                    currentToken.setLength(0);
+                } else {
+                    currentToken.append(ch);
+                }
+            } else if (Character.isWhitespace(ch) && depth == 0) {
+                if (!currentToken.isEmpty()) {
+                    node.put("node", currentToken.toString().trim());
+                    currentToken.setLength(0);
+                }
+            } else {
+                currentToken.append(ch);
+            }
+        }
+
+        if (!currentToken.isEmpty()) {
+            node.put("node", currentToken.toString().trim());
+        }
+
+        if (!children.isEmpty()) {
+            node.put("children", children);
+        }
+
+        return node;
+    }
+}

src/test/java/parser/ScannerTest.java

@@ -0,0 +1,45 @@
+package parser;
+
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.Token;
+import org.junit.jupiter.api.Test;
+import parser.generated.SimpleJavaLexer;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ScannerTest {
+
+    /**
+     * This test method is used to test the scanner functionality of the SimpleJavaLexer.
+     * It creates a CharStream from a string representing a simple Java class declaration,
+     * and uses the SimpleJavaLexer to tokenize this input.
+     * It then compares the actual tokens and their types produced by the lexer to the expected tokens and their types.
+     */
+    @Test
+    public void scannerTest() {
+        // Create a CharStream from a string representing a simple Java class declaration
+        CharStream inputCharStream = CharStreams.fromString("public class Name {}");
+
+        // Use the SimpleJavaLexer to tokenize the input
+        SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+        tokenStream.fill();
+
+        // Prepare the expected results
+        List<String> expectedTokens = Arrays.asList("public", "class", "Name", "{", "}", "<EOF>");
+        List<String> expectedTokenTypes = Arrays.asList("AccessModifier", "Class", "Identifier", "OpenCurlyBracket", "ClosedCurlyBracket", "EOF");
+        List<Token> actualTokens = tokenStream.getTokens();
+
+        // Compare the actual tokens and their types to the expected tokens and their types
+        assertEquals(expectedTokens.size(), actualTokens.size());
+        for (int i = 0; i < expectedTokens.size(); i++) {
+            assertEquals(expectedTokens.get(i), actualTokens.get(i).getText());
+            assertEquals(expectedTokenTypes.get(i), SimpleJavaLexer.VOCABULARY.getSymbolicName(actualTokens.get(i).getType()));
+        }
+    }
+}

src/test/java/semantic/BeginnToTAST.java

@@ -0,0 +1,45 @@
+package semantic;
+
+import ast.ProgramNode;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.junit.jupiter.api.Test;
+import parser.astBuilder.ASTBuilder;
+import parser.generated.SimpleJavaLexer;
+import parser.generated.SimpleJavaParser;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class BeginnToTAST {
+
+    @Test
+    public void FieldTests() {
+        SemanticAnalyzer.clearAnalyzer();
+
+        CharStream codeCharStream = null;
+        try {
+            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/input/johnsTests/FieldTests.java"));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTree = parser.program(); // parse the input
+
+        /* ------------------------- AST builder -> AST ------------------------- */
+        ASTBuilder astBuilder = new ASTBuilder();
+        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
+
+        var result = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+    }
+
+}

src/test/java/semantic/EndToTypedAstTest.java

@@ -281,74 +281,6 @@ public class EndToTypedAstTest {
 
     }
 
-    @Test
-    public void VariableCompare(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/VariableCompare.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-
-    }
-
-    @Test
-    public void IfExpressionInt(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/IfExpressionInt.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void SelectWrongMethodCauseParameter(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/SelectWrongMethodCauseParameter.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void SelectRightMethodCauseParameter(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/SelectRightMethodCauseParameter.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-
-    }
-
-    @Test
-    public void VariableCalculation(){
-
-        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/VariableCalculation.java");
-
-        SemanticAnalyzer.generateTast(tast);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-
-    }
-
-    @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/java/semantic/SemanticHelper.java

@@ -14,9 +14,6 @@ import java.io.IOException;
 
 public class SemanticHelper {
     public static ASTNode generateTypedASTFrom(String filePath) {
-
-        SemanticAnalyzer.clearAnalyzer();
-
         CharStream testFile = null;
         try {
             testFile = CharStreams.fromFileName(filePath);
@@ -30,6 +27,6 @@ public class SemanticHelper {
         ParseTree parseTree = parser.program();
         ASTBuilder astBuilder = new ASTBuilder();
 
-        return astBuilder.visit(parseTree);
+        return (ProgramNode) astBuilder.visit(parseTree);
     }
 }

src/test/java/semantic/SemanticTest.java

@@ -1,413 +1,5 @@
 package semantic;
 
-import ast.ASTNode;
-import ast.ClassNode;
-import ast.ProgramNode;
-import ast.expressions.IExpressionNode;
-import ast.expressions.unaryexpressions.MemberAccessNode;
-import ast.expressions.unaryexpressions.UnaryNode;
-import ast.members.ConstructorNode;
-import ast.members.FieldNode;
-import ast.members.MethodNode;
-import ast.parameters.ParameterNode;
-import ast.statementexpressions.AssignNode;
-import ast.statementexpressions.AssignableNode;
-import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
-import ast.statements.BlockNode;
-import ast.statements.ReturnNode;
-import ast.type.AccessModifierNode;
-import ast.type.EnumValueNode;
-import ast.type.ValueNode;
-import ast.type.type.BaseType;
-import ast.type.type.TypeEnum;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import parser.Helper;
-
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 public class SemanticTest {
 
-    @BeforeEach
-    public void setUp() {
-        SemanticAnalyzer.clearAnalyzer();
-    }
-
-    @Test
-    @DisplayName("Empty Class Test")
-    public void emptyClassTest() {
-        ClassNode emptyClass = Helper.generateEmptyClass("EmptyClass");
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(emptyClass);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-
-    @Test
-    @DisplayName("Multiple Empty Classes Test")
-    public void multipleEmptyClassesTest() {
-        ClassNode class1 = Helper.generateEmptyClass("MultipleClasses");
-        ClassNode class2 = Helper.generateEmptyClass("TestClass2");
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-        abstractSyntaxTree.addClass(class2);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-
-    @Test
-    @DisplayName("Empty Class Test with Constructor")
-    public void emptyClassWithConstructorTest() {
-        ClassNode class1 = Helper.generateEmptyClass("EmptyClassWithConstructor");
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("Field Test")
-    public void fieldTest() {
-        ClassNode class1 = Helper.generateEmptyClass("Field");
-        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("Field Test with Accessmodifier")
-    public void fieldTestWithModifier() {
-        ClassNode class1 = Helper.generateEmptyClass("FieldWithAccessModifier");
-        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("Comments Ignore Test")
-    public void commentsIgnoreTest() {
-        ClassNode class1 = Helper.generateEmptyClass("Comments");
-        class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a"));
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("Constructor Parameter Test")
-    public void constructorParameterTest() {
-        BlockNode block = new BlockNode();
-        block.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "ConstructorParameter", block);
-        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
-
-        ClassNode class1 = new ClassNode("public", "ConstructorParameter");
-        class1.addMember(constructor);
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("This Dot Test")
-    public void thisDotTest() {
-        BlockNode block = new BlockNode();
-        MemberAccessNode memberAccess = new MemberAccessNode(true);
-        memberAccess.addIdentifier("a");
-
-        AssignableNode assignable = new AssignableNode(memberAccess);
-
-        ValueNode value = new ValueNode(EnumValueNode.INT_VALUE, "1");
-        IExpressionNode expression = new UnaryNode(value);
-
-        block.addStatement(new AssignNode(assignable, expression));
-        block.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "ThisDot", block);
-
-        ClassNode class1 = new ClassNode("public", "ThisDot");
-        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
-        class1.addMember(constructor);
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("Constructor This Dot Test")
-    public void constructorThisDotTest() {
-        BlockNode block = new BlockNode();
-        MemberAccessNode memberAccess = new MemberAccessNode(true);
-        memberAccess.addIdentifier("a");
-
-        AssignableNode assignable = new AssignableNode(memberAccess);
-
-        IExpressionNode expression = new UnaryNode("a");
-
-        block.addStatement(new AssignNode(assignable, expression));
-        block.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "ConstructorThisDot", block);
-        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-
-        ClassNode class1 = new ClassNode("public", "ConstructorThisDot");
-        class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a"));
-        class1.addMember(constructor);
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("Void Methoden Test")
-    public void voidMethodenTest() {
-        ClassNode class1 = Helper.generateEmptyClass("VoidMethod");
-        BlockNode block = new BlockNode();
-        block.addStatement(new ReturnNode(null));
-        class1.addMember(new MethodNode("public", null, true, "test", block));
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("Constructor Method call Test")
-    public void constructorMethodCallTest() {
-        BlockNode blockCon = new BlockNode();
-        MemberAccessNode memberAccess = new MemberAccessNode(true);
-        memberAccess.addIdentifier("a");
-
-        AssignableNode assignable = new AssignableNode(memberAccess);
-
-        IExpressionNode expression = new UnaryNode(new MethodCallNode(null, "testMethod"));
-
-        blockCon.addStatement(new AssignNode(assignable, expression));
-        blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCall", blockCon);
-
-        BlockNode blockMethod = new BlockNode();
-        blockMethod.addStatement(new ReturnNode(new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "1"))));
-        MethodNode method = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod", blockMethod);
-
-        ClassNode class1 = new ClassNode("public", "ConstructorMethodCall");
-        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
-        class1.addMember(constructor);
-        class1.addMember(method);
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("Constructor Method call Parameters Test")
-    public void constructorMethodCallParametersTest() {
-        BlockNode blockCon = new BlockNode();
-        MemberAccessNode memberAccess = new MemberAccessNode(true);
-        memberAccess.addIdentifier("a");
-
-        AssignableNode assignable = new AssignableNode(memberAccess);
-
-        MethodCallNode methodCall = new MethodCallNode(null, "testMethod");
-        methodCall.addExpression(new UnaryNode("a"));
-        IExpressionNode expression = new UnaryNode(methodCall);
-
-        blockCon.addStatement(new AssignNode(assignable, expression));
-        blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCallParameters", blockCon);
-        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-
-        BlockNode blockMethod = new BlockNode();
-        blockMethod.addStatement(new ReturnNode(new UnaryNode("a")));
-        MethodNode method = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod", blockMethod);
-        method.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
-
-        ClassNode class1 = new ClassNode("public", "ConstructorMethodCallParameters");
-        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
-        class1.addMember(constructor);
-        class1.addMember(method);
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("Char Test")
-    public void charTest() {
-        BlockNode blockCon = new BlockNode();
-        MemberAccessNode memberAccess = new MemberAccessNode(true);
-        memberAccess.addIdentifier("a");
-
-        AssignableNode assignable = new AssignableNode(memberAccess);
-
-        MethodCallNode methodCall = new MethodCallNode(null, "testMethod");
-        methodCall.addExpression(new UnaryNode("a"));
-        IExpressionNode expression = new UnaryNode(methodCall);
-
-        blockCon.addStatement(new AssignNode(assignable, expression));
-        blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "Char", blockCon);
-        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a"));
-
-        BlockNode blockMethod = new BlockNode();
-        blockMethod.addStatement(new ReturnNode(new UnaryNode("a")));
-        MethodNode method = new MethodNode("public", new BaseType(TypeEnum.CHAR), false, "testMethod", blockMethod);
-        method.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a"));
-
-        ClassNode class1 = new ClassNode("public", "Char");
-        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.CHAR), "a"));
-        class1.addMember(constructor);
-        class1.addMember(method);
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(class1);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
-
-    @Test
-    @DisplayName("Self Reference Test")
-    public void selfReferenceTest() {
-
-    }
-
-    @Test
-    @DisplayName("Variable Compare Test")
-    public void variableCompareTest() {
-
-    }
-
-    @Test
-    @DisplayName("Variable Calculation Test")
-    public void variableCalculationTest() {
-
-    }
-
-    @Test
-    @DisplayName("Main Method Test")
-    public void mainMethodTest() {
-
-    }
-
-    @Test
-    @DisplayName("While Test")
-    public void whileTest() {
-
-    }
-
-    @Test
-    @DisplayName("Do While Test")
-    public void doWhileTest() {
-
-    }
-
-    @Test
-    @DisplayName("For Test")
-    public void forTest() {
-
-    }
-
-    @Test
-    @DisplayName("Increment Test")
-    public void incrementTest() {
-        ClassNode classNode = Helper.generateEmptyClass("Increment");
-        classNode.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
-
-        ProgramNode abstractSyntaxTree = new ProgramNode();
-        abstractSyntaxTree.addClass(classNode);
-
-        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-        for (Exception runtimeException : SemanticAnalyzer.errors) {
-            runtimeException.printStackTrace();
-        }
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-        assertNotNull(typedAst);
-    }
 }

src/test/resources/input/endabgabeTests/Car.java

@@ -0,0 +1,25 @@
+public class Main {
+    public static void main(String[] args) {
+        Car myCar = new Car(2020);
+        int tires = 0;
+        int year = myCar.getYear();
+
+        if (year == 2020) {
+            tires = 4;
+        } else {
+            tires = 2;
+        }
+    }
+}
+
+class Car {
+    private int year;
+
+    public Car(int year) {
+        this.year = year;
+    }
+
+    public int getYear() {
+        return this.year;
+    }
+}

src/test/resources/input/endabgabeTests/ControlStructures.java

@@ -0,0 +1,36 @@
+public class ControlStructures {
+
+    public int sum(int a, int b) {
+        return a + b;
+    }
+
+    public cahr checkNumber(int num) {
+        if (num > 0) {
+            return "p";
+        } else if (num < 0) {
+            return "n";
+        } else {
+            return "z";
+        }
+    }
+
+    public void printNumbersUpTo(int limit) {
+        int even = 0;
+        int uneven = 0;
+        int i = 0;
+        while (i < limit) {
+            if (i % 2 == 0) {
+                even++;
+            } else {
+                uneven = uneven + 1;
+            }
+            i++;
+        }
+    }
+
+    public static void main(String[] args) {
+        ControlStructures cs = new ControlStructures();
+        cs.printNumbersUpTo(5);
+        int result = cs.sum(5, 5);
+    }
+}

src/test/resources/input/endabgabeTests/Person.java

@@ -0,0 +1,11 @@
+public class Person {
+    private int age;
+
+    public Person(int age) {
+        this.age = age;
+    }
+
+    public int getAge() {
+        return this.age;
+    }
+}

src/test/resources/input/finalTest/Car.java

@@ -1,63 +0,0 @@
-public class Car {
-    public int ps;
-    public char brand;
-    public int tires;
-    public int drivenKilometers;
-
-    public Car(int horsePower) {
-        this.ps = horsePower;
-        this.tires = 4;
-    }
-
-    public int getTires() {
-        return this.tires;
-    }
-
-    public boolean isSuperCar() {
-        if(this.ps > 300) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    public void tune(int horsePower) {
-        this.ps = this.ps + horsePower;
-    }
-
-    public void tune() {
-        this.ps = this.ps + 50;
-    }
-
-    public void driveCircels(int circels) {
-        for(int i = 0; i < circels; i++) {
-            this.drivenKilometers = this.drivenKilometers + 5;
-        }
-    }
-
-    public void isTunable(boolean hasEngine, boolean hasTires) {
-        if(hasEngine && hasTires) {
-            this.tune(5);
-        }
-    }
-
-    public char race() {
-        int enemyHorsePower = 200;
-        char win = 'W';
-        char lose = 'L';
-        Car enemy = new Car(ps);
-        if(this.ps > enemyHorsePower) {
-            return win;
-        } else {
-            return lose;
-        }
-    }
-
-    public int refuel(int currentTank, int maxTank){
-        int tank = currentTank;
-        do{
-            tank++;
-        }while(tank<maxTank);
-        return tank;
-    }
-}

src/test/resources/input/finalTest/Main.java

@@ -1,32 +0,0 @@
-public class Main {
-    public static void main(String[] args) {
-        Car vw = new Car(50);
-        System.out.println(vw.getTires());
-        System.out.println(vw.isSuperCar());
-
-        System.out.println("--------------------------------------");
-
-        vw.tune(300);
-        System.out.println(vw.ps);
-        System.out.println(vw.isSuperCar());
-
-        System.out.println("--------------------------------------");
-
-        System.out.println(vw.drivenKilometers);
-        vw.driveCircels(25);
-        System.out.println(vw.drivenKilometers);
-
-        System.out.println("--------------------------------------");
-
-        vw.isTunable(true, true);
-        System.out.println(vw.ps);
-
-        System.out.println("--------------------------------------");
-
-        System.out.println(vw.race());
-
-        System.out.println("--------------------------------------");
-
-        System.out.println(vw.refuel(10, 20));
-    }
-}

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/singleFeatureSemanticTests/SelectRightMethodCauseParameter.java

@@ -1,22 +0,0 @@
-// @expected: TypeMismatchException
-public class Test{
-
-    public int i;
-    public boolean b;
-
-    public int test(){
-
-        return test(b);
-
-    }
-
-    public void test(int a){
-
-    }
-
-    public int test(boolean bool){
-        int ret = 1;
-        return ret;
-    }
-
-}

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

@@ -1,34 +0,0 @@
-class VariableCalculation{
-
-    int aPlusB(int a, int b){
-        return a + b;
-    }
-
-    int aMinusB(int a, int b){
-        return a - b;
-    }
-
-    int aTimeB(int a, int b){
-        return a * b;
-    }
-
-    int aDivB(int a, int b){
-        return a / b;
-    }
-
-    int complexCalc (int a, int b){
-        return a * b / 1 * 3;
-    }
-
-    boolean aSmallerB (int a, int b){
-        return a < b;
-    }
-
-    boolean aGreaterB (int a, int b){
-        return a > b;
-    }
-
-    boolean aEqualsB (int a, int b){
-        return a == b;
-    }
-}

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

@@ -1,30 +0,0 @@
-class VariableCompare{
-
-    boolean trueMethod() {
-        return true;
-    }
-
-    boolean falseMethod(){
-        return false;
-    }
-
-    boolean trueAndTrueMethod(){
-        return true && true;
-    }
-
-    boolean trueAndFalseMethod(){
-        return true && false;
-    }
-
-    boolean falseAndFalseMethod(){
-        return false && false;
-    }
-
-    boolean trueOrTrueMethod(){
-        return true || true;
-    }
-
-    boolean falseOrFalseMethod(){
-        return false || false;
-    }
-}

src/test/resources/input/singleFeatureTests/For.java

@@ -1,7 +1,7 @@
 class For{
 
     public For(){
-        for(int i = 0; i < 10; ++i){
+        for(int i = 0; i < 10; i++){
             int a;
         }
     }

src/test/resources/input/singleFeatureTests/Increment.java

@@ -3,7 +3,7 @@ public class Increment {
     public int test;
 
     public void increment(int p) {
-        this.test = p++;
+        test = p++;
 
         for(int i = 1; i<=10; i++) {
             int a = 5;

src/test/resources/input/singleFeatureTests/Null.java

@@ -0,0 +1,8 @@
+class Null{
+
+    Null a;
+
+    public Null(){
+      this.a = null;
+    }
+}