Revert "Merge remote-tracking branch 'origin/Endabgabe' into code-generator"

This reverts commit 721e1caa79, reversing
changes made to 6d3e1f859e.

.gitignore

@@ -77,10 +77,10 @@ fabric.properties
 .idea/caches/build_file_checksums.ser
 
 /target
-src/main/resources/logs/miniCompilerLog.log
+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

README.md

@@ -1,149 +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`;
-    - `switch` ... `case` ... ;
-- **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
-
-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.
-
-## 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/Endabgabe/src) 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
- ```
-
-## How to run tests
-
-```bash
-mvn test
-```
-Or start them manually in your IDE

readme.md

@@ -0,0 +1,68 @@
+# "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 Suttgart (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`;
+    - `switch` ... `case` ... ;
+- **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/                 -> MainTest, E2ETests, UtilityTests
+│   ├── 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)
+
+## 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
+
+## Download
+
+```bash

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,8 +1,9 @@
 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;
@@ -19,11 +20,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

@@ -32,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,7 +4,7 @@ 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 {

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

@@ -4,8 +4,8 @@ import ast.statementexpressions.AssignableNode;
 import ast.statementexpressions.IStatementExpressionNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
 import visitor.Visitable;
-import semantic.TypeCheckResult;
 
 public class IncrementNode implements IStatementExpressionNode, Visitable {
     public CrementType crementType;

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;

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,5 +4,6 @@ public enum TypeEnum {
     VOID,
     INT,
     CHAR,
-    BOOL
+    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,12 +19,12 @@ 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();

src/main/java/bytecode/MethodCodeGen.java

@@ -16,8 +16,6 @@ import ast.statementexpressions.crementexpressions.DecrementNode;
 import ast.statementexpressions.crementexpressions.IncrementNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
 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;
@@ -35,11 +33,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;
@@ -80,10 +78,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);
@@ -158,8 +154,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) {
@@ -177,17 +173,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);
         }
     }
 
@@ -322,17 +318,9 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     // 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++) {
@@ -350,6 +338,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
         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++) {
@@ -368,8 +357,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);
@@ -436,7 +423,8 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
                 assignLocalVar(assignNode);
                 incrementNode.accept(this);
             }
-        } else if (assignNode.expression instanceof DecrementNode decrementNode) {
+        } else if (assignNode.expression instanceof DecrementNode) {
+            DecrementNode decrementNode = (DecrementNode) assignNode.expression;
             if (decrementNode.crementType.equals(CrementType.PREFIX)) {
                 decrementNode.accept(this);
                 assignLocalVar(assignNode);
@@ -533,9 +521,9 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
             if(incrementNode.assignableExpression.memberAccess != null) {
                 incrementNode.assignableExpression.memberAccess.accept(this);
             } else {
-                if(assignNode.assignable.typeNode instanceof BaseType) {
+                if(assignNode.assignable.getTypeNode() instanceof BaseType) {
                     methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(assignNode.assignable.identifier));
-                } else if(assignNode.assignable.typeNode instanceof ReferenceType) {
+                } else if(assignNode.assignable.getTypeNode() instanceof ReferenceType) {
                     methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
                 }
             }
@@ -544,9 +532,9 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
             if(decrementNode.assignableExpression.memberAccess != null) {
                 decrementNode.assignableExpression.memberAccess.accept(this);
             } else {
-                if(assignNode.assignable.typeNode instanceof BaseType) {
+                if(assignNode.assignable.getTypeNode() instanceof BaseType) {
                     methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(assignNode.assignable.identifier));
-                } else if(assignNode.assignable.typeNode instanceof ReferenceType) {
+                } else if(assignNode.assignable.getTypeNode() instanceof ReferenceType) {
                     methodVisitor.visitVarInsn(ALOAD, localVariables.indexOf(assignNode.assignable.identifier));
                 }
             }

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

@@ -8,58 +8,48 @@ 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(MethodCallNode methodCallNode);
 
     void visit(AssignNode assignNode);
-
     void visit(NewDeclarationNode newDeclarationNode);
 
     // type

src/main/java/bytecode/visitor/ProgramVisitor.java

@@ -3,5 +3,5 @@ package bytecode.visitor;
 import ast.ProgramNode;
 
 public interface ProgramVisitor {
-    void visit(ProgramNode programNode);
+  void visit(ProgramNode programNode);
 }

src/main/java/main/Main.java

@@ -17,10 +17,10 @@ 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>
@@ -40,6 +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/main/resources/input/CompilerInput.java"));
+                compileFile(codeCharStream);
+            } catch (IOException e) {
+                System.err.println("Error reading the file: " + e.getMessage());
+            }
+        }
+        */
     }
 
     /**
@@ -56,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
@@ -64,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 -------------------------*/
@@ -97,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,11 +29,11 @@ import java.util.logging.*;
  * <code>consoleHandler.setLevel(Level.OFF);</code>
  * <code>fileHandler.setLevel(Level.ALL);</code>
  */
-public class MiniCompilerLogger {
+public class RaupenLogger {
 
-    static Logger logger = Logger.getLogger("miniCompilerLogs");
+    static Logger logger = Logger.getLogger("RaupenLogs");
 
-    public MiniCompilerLogger() {
+    public RaupenLogger() {
         // ------------------------- Logging -------------------------
         logger.setLevel(Level.ALL);
         logger.getParent().getHandlers()[0].setLevel(Level.ALL);
@@ -66,7 +66,7 @@ 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());
@@ -117,7 +117,7 @@ public class MiniCompilerLogger {
     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");
     }
 

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

@@ -211,8 +211,8 @@ 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;
     }
@@ -253,7 +253,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
         // Prä-Inkrement: Das Inkrement kommt vor dem Block
         if (crement != null && isPrefix) {
-            whileBody.addStatement(crement);
+            whileBody.addStatement((IStatementNode) crement);
         }
 
         // Block Statements der For-Schleife in den While-Block kopieren
@@ -263,7 +263,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
         // Post-Inkrement: Das Inkrement kommt nach dem Block
         if (crement != null && !isPrefix) {
-            whileBody.addStatement(crement);
+            whileBody.addStatement((IStatementNode) crement);
         }
 
         // Bedingung der While-Schleife
@@ -273,7 +273,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
         BlockNode resultBlock = new BlockNode();
         for (IStatementNode statement : statements) {
-            resultBlock.addStatement(statement);
+            resultBlock.addStatement((IStatementNode) statement);
         }
 
         return resultBlock;
@@ -559,9 +559,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
     @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;
     }
@@ -569,13 +569,13 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
     @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;
     }

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

@@ -33,7 +33,7 @@ import com.sun.jdi.IntegerType;
 import semantic.context.ClassContext;
 import semantic.context.Context;
 import semantic.exceptions.*;
-import semantic.TypeCheckResult;
+import typechecker.TypeCheckResult;
 
 public class SemanticAnalyzer implements SemanticVisitor {
 
@@ -480,8 +480,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
     @Override
     public TypeCheckResult analyze(DotNode toCheck) {
-        if (toCheck.dotSubtractionExpression != null) {
-            var result = toCheck.dotSubtractionExpression.accept(this);
+        if (toCheck.dotSubstractionExpression != null) {
+            var result = toCheck.dotSubstractionExpression.accept(this);
             toCheck.setType(result.getType());
             return result;
         }
@@ -489,7 +489,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
     }
 
     @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());

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/test/Makefile

@@ -2,17 +2,17 @@
 ### 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 .\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 .java/resources/output/miniCompiler
+	# cp ../main/resources/output/CompilerInput.class .java/resources/output/raupenpiler
 
-test-miniCompiler:
+test-raupenpiler:
 	# move the compiled class to the test/main folder
 	mv ../main/resources/output/CompilerInput.class .java/main/
 	# compile the test class
@@ -28,8 +28,8 @@ clean:
 	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
+	rm -f ./resources/output/raupenpiler/*.jar
 	# clean logs
 	rm -f ../main/resources/logs/*
 	# clean test/java/main folders from .class files for End-to-End tests

src/test/java/main/EndToEndTester.java

@@ -11,6 +11,8 @@ package main;
  * 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) {

src/test/java/main/MainTest.java

@@ -2,6 +2,8 @@ package main;
 
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
+import parser.ParserTest;
+import parser.ScannerTest;
 import semantic.EndToTypedAstTest;
 import semantic.SemanticTest;
 
@@ -13,6 +15,8 @@ import semantic.SemanticTest;
 @RunWith(Suite.class)
 @Suite.SuiteClasses({
         InputFilesTest.class,
+        ScannerTest.class,
+        ParserTest.class,
         SemanticTest.class,
         EndToTypedAstTest.class
 })

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;
@@ -514,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"));

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/SemanticHelper.java

@@ -30,6 +30,6 @@ public class SemanticHelper {
         ParseTree parseTree = parser.program();
         ASTBuilder astBuilder = new ASTBuilder();
 
-        return astBuilder.visit(parseTree);
+        return (ProgramNode) astBuilder.visit(parseTree);
     }
 }