readme.md gelöscht

# Conflicts:
#	src/main/java/semantic/SemanticAnalyzer.java
#	src/test/java/semantic/SemanticTest.java

.gitignore

@@ -77,10 +77,10 @@ fabric.properties
 .idea/caches/build_file_checksums.ser
 
 /target
-src/main/resources/logs/RaupenLog.log
+src/main/resources/logs/miniCompilerLog.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/raupenpiler/CompilerInput.class
+src/test/resources/output/miniCompiler/CompilerInput.class
-src/test/resources/output/raupenpiler/CompilerInput$Test.class
+src/test/resources/output/miniCompiler/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**

README.md

@@ -0,0 +1,149 @@
+# "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

pom.xml

@@ -20,7 +20,25 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
-            <version>5.9.3</version> <!-- Change the version as needed -->
+            <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>
@@ -44,12 +62,6 @@
             <version>3.26.0</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>
@@ -59,6 +71,11 @@
                 <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,20 +1,6 @@
 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,12 +1,11 @@
 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 typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 import visitor.Visitable;
 
 import java.util.ArrayList;
@@ -17,11 +16,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;
     }
@@ -30,7 +29,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 typechecker.TypeCheckResult;
+import semantic.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 typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 import visitor.Visitable;
 
 public class BinaryNode implements IExpressionNode, Visitable {
 
-    private ITypeNode typeNode;
+    public ITypeNode typeNode;
 
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {

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

@@ -1,15 +1,13 @@
 package ast.expressions.binaryexpressions;
 
-import ast.type.type.*;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.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;
@@ -21,11 +19,11 @@ public class CalculationNode extends BinaryNode {
         this.dotExpression = dotExpression;
     }
 
-    private void setOperator(String operator) {
+    public void setOperator(String operator) {
-        if(operator != null) {
+        if (operator != null) {
-            if(operator.equals("+")) {
+            if (operator.equals("+")) {
                 this.operator = EnumLineOperator.PLUS;
-            } else if(operator.equals("-")) {
+            } else if (operator.equals("-")) {
                 this.operator = EnumLineOperator.MINUS;
             }
         }
@@ -42,4 +40,4 @@ public class CalculationNode extends BinaryNode {
         methodVisitor.visit(this);
     }
 
-}
+}

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

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

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

@@ -1,45 +1,44 @@
-package ast.expressions.binaryexpressions;
+package ast.expressions.binaryexpressions;
-
+
-import ast.expressions.unaryexpressions.MemberAccessNode;
+import ast.expressions.unaryexpressions.MemberAccessNode;
-import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
+import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
-import ast.type.type.*;
+import ast.type.ValueNode;
-import ast.type.ValueNode;
+import bytecode.visitor.MethodVisitor;
-import bytecode.visitor.MethodVisitor;
+import semantic.SemanticVisitor;
-import semantic.SemanticVisitor;
+import semantic.TypeCheckResult;
-import typechecker.TypeCheckResult;
+
-
+public class DotSubtractionNode extends BinaryNode {
-public class DotSubstractionNode extends BinaryNode {
+    public ValueNode value;
-    public ValueNode value;
+    public String identifier;
-    public String identifier;
+    public MemberAccessNode memberAccess;
-    public MemberAccessNode memberAccess;
+    public MethodCallNode methodCall;
-    public MethodCallNode methodCall;
+    public CalculationNode calculationExpression;
-    public CalculationNode calculationExpression;
+
-
+    public DotSubtractionNode(ValueNode value) {
-    public DotSubstractionNode(ValueNode value) {
+        this.value = value;
-        this.value = value;
+    }
-    }
+
-
+    public DotSubtractionNode(String identifier) {
-    public DotSubstractionNode(String identifier) {
+        this.identifier = identifier;
-        this.identifier = identifier;
+    }
-    }
+
-
+    public DotSubtractionNode(MemberAccessNode memberAccess) {
-    public DotSubstractionNode(MemberAccessNode memberAccess) {
+        this.memberAccess = memberAccess;
-        this.memberAccess = memberAccess;
+    }
-    }
+
-
+    public DotSubtractionNode(MethodCallNode methodCall, CalculationNode calculationExpression) {
-    public DotSubstractionNode(MethodCallNode methodCall, CalculationNode calculationExpression) {
+        this.methodCall = methodCall;
-        this.methodCall = methodCall;
+        this.calculationExpression = calculationExpression;
-        this.calculationExpression = calculationExpression;
+    }
-    }
+
-
+    @Override
-    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
-    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
-        return visitor.analyze(this);
+    }
-    }
+
-
+    @Override
-    @Override
+    public void accept(MethodVisitor methodVisitor) {
-    public void accept(MethodVisitor methodVisitor) {
+        methodVisitor.visit(this);
-        methodVisitor.visit(this);
+    }
-    }
+
-
+}
-}

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

@@ -2,10 +2,9 @@ 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 typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 public class NonCalculationNode extends BinaryNode {
     public UnaryNode unaryExpression;
@@ -18,23 +17,16 @@ public class NonCalculationNode extends BinaryNode {
         this.expression = expression;
     }
 
-    private void setOperator(String operator) {
+    public void setOperator(String operator) {
-        if(operator.equals("&&")) {
+        switch (operator) {
-            this.operator = EnumNonCalculationOperator.AND;
+            case "&&" -> this.operator = EnumNonCalculationOperator.AND;
-        } else if(operator.equals("||")) {
+            case "||" -> this.operator = EnumNonCalculationOperator.OR;
-            this.operator = EnumNonCalculationOperator.OR;
+            case ">" -> this.operator = EnumNonCalculationOperator.GREATER;
-        } else if(operator.equals(">")) {
+            case "<" -> this.operator = EnumNonCalculationOperator.LESS;
-            this.operator = EnumNonCalculationOperator.GREATER;
+            case ">=" -> this.operator = EnumNonCalculationOperator.GREATER_EQUAL;
-        } else if(operator.equals("<")) {
+            case "<=" -> this.operator = EnumNonCalculationOperator.LESS_EQUAL;
-            this.operator = EnumNonCalculationOperator.LESS;
+            case "==" -> this.operator = EnumNonCalculationOperator.EQUAL;
-        } else if(operator.equals(">=")) {
+            case "!=" -> this.operator = EnumNonCalculationOperator.NOT_EQUAL;
-            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

@@ -2,9 +2,9 @@ package ast.expressions.unaryexpressions;
 
 import ast.ASTNode;
 import bytecode.visitor.MethodVisitor;
-import ast.type.type.ITypeNode;
+
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 import visitor.Visitable;
 
 import java.util.ArrayList;
@@ -13,7 +13,6 @@ import java.util.List;
 public class MemberAccessNode implements ASTNode, Visitable {
     public Boolean thisExpr;
     public List<String> identifiers = new ArrayList<>();
-    private ITypeNode typeNode;
 
     public MemberAccessNode(Boolean thisExpr) {
         this.thisExpr = thisExpr;
@@ -27,17 +26,10 @@ public class MemberAccessNode implements ASTNode, Visitable {
     public void accept(MethodVisitor methodVisitor) {
         methodVisitor.visit(this);
     }
-    
+
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
     }
 
-    public ITypeNode getTypeNode() {
-        return typeNode;
-    }
-
-    public void setTypeNode(ITypeNode typeNode) {
-        this.typeNode = typeNode;
-    }
 
 }

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

@@ -1,13 +1,12 @@
 package ast.expressions.unaryexpressions;
 
-import ast.ASTNode;
 import ast.expressions.IExpressionNode;
+import ast.type.type.ITypeNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
-import visitor.Visitable;
 
-public class NotNode implements ASTNode, Visitable {
+public class NotNode implements IExpressionNode {
     public IExpressionNode expression;
 
     public NotNode(IExpressionNode expression) {
@@ -24,4 +23,13 @@ public class NotNode implements ASTNode, Visitable {
         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 typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 import java.util.Objects;
 
@@ -18,10 +18,10 @@ public class UnaryNode implements IExpressionNode {
     public NotNode notExpression;
     public IStatementNode statement;
     public IExpressionNode expression;
-    private ITypeNode type;
+    public 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

@@ -1,11 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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,8 +32,7 @@ public class ConstructorNode extends MethodNode implements Visitable {
     }
 
     public boolean isSame(MethodNode methodNode) {
-        if (!(Objects.equals(this.identifier, methodNode.getIdentifier()))
+        if (!(Objects.equals(this.identifier, methodNode.getIdentifier())) || getParameters().size() != methodNode.getParameters().size()) {
-                || getParameters().size() != methodNode.getParameters().size()) {
             return false;
         }
 

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

@@ -3,9 +3,8 @@ package ast.members;
 import ast.type.AccessModifierNode;
 import ast.type.type.ITypeNode;
 import bytecode.visitor.ClassVisitor;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 import visitor.Visitable;
 
 public class FieldNode implements MemberNode, Visitable {
@@ -13,7 +12,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/MainMethodNode.java

@@ -5,7 +5,6 @@ import bytecode.visitor.MethodVisitor;
 import visitor.Visitable;
 
 public class MainMethodNode extends MethodNode implements Visitable {
-    public BlockNode block;
 
     public MainMethodNode(BlockNode block) {
         this.block = block;

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

@@ -10,7 +10,8 @@ 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 typechecker.TypeCheckResult;
+import semantic.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;
-    private ITypeNode type;
+    public ITypeNode type;
     public Boolean voidType;
-    private String identifier;
+    public 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 typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 import visitor.Visitable;
 
 public class ParameterNode implements ASTNode, Visitable {

src/main/java/ast/statement/BlockStatementNode.java

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

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 typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 public class AssignNode implements IStatementExpressionNode {
     public AssignableNode assignable;

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

@@ -3,11 +3,11 @@ package ast.statementexpressions;
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.type.type.ITypeNode;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 public class AssignableNode implements IStatementExpressionNode {
     public String identifier;
-    private ITypeNode typeNode;
+    public ITypeNode typeNode;
 
     public MemberAccessNode memberAccess;
 
@@ -24,10 +24,6 @@ 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,4 +2,5 @@ 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 typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 import java.util.ArrayList;
 import java.util.List;

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

@@ -2,10 +2,8 @@ package ast.statementexpressions.crementexpressions;
 
 import ast.statementexpressions.AssignableNode;
 import ast.statementexpressions.IStatementExpressionNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
-import visitor.Visitable;
 
 public class DecrementNode implements IStatementExpressionNode {
     public CrementType crementType;

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

@@ -2,9 +2,8 @@ package ast.statementexpressions.crementexpressions;
 
 import ast.statementexpressions.AssignableNode;
 import ast.statementexpressions.IStatementExpressionNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 public class IncrementNode implements IStatementExpressionNode {
     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 typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 import visitor.Visitable;
 
 import java.util.ArrayList;

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

@@ -2,15 +2,17 @@ package ast.statementexpressions.methodcallstatementnexpressions;
 
 import ast.expressions.IExpressionNode;
 import ast.statements.IStatementNode;
+import ast.type.type.ITypeNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class MethodCallNode implements IStatementNode {
     public TargetNode target;
+    public ITypeNode type;
     public List<ChainedMethodNode> chainedMethods = new ArrayList<>();
     public String identifier;
     public List<IExpressionNode> parameters = new ArrayList<>();

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

@@ -3,9 +3,8 @@ package ast.statementexpressions.methodcallstatementnexpressions;
 import ast.ASTNode;
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.statementexpressions.NewDeclarationNode;
-import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 import visitor.Visitable;
 
 public class TargetNode implements ASTNode, Visitable {
@@ -30,11 +29,6 @@ public class TargetNode implements ASTNode, Visitable {
         this.identifier = identifier;
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
     }

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

@@ -1,8 +1,7 @@
 package ast.statements;
 
-import ast.ASTNode;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 import visitor.Visitable;
 
 import java.util.ArrayList;
@@ -11,7 +10,8 @@ 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);

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

@@ -1,10 +0,0 @@
-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,7 +1,7 @@
 package ast.statements;
 
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 public class ElseNode implements IStatementNode {
     public BlockNode block;

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

@@ -1,7 +1,7 @@
 package ast.statements;
 
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 import java.util.ArrayList;
 import java.util.List;

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

@@ -2,7 +2,7 @@ package ast.statements;
 
 import ast.expressions.IExpressionNode;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.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 typechecker.TypeCheckResult;
+import semantic.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 typechecker.TypeCheckResult;
+import semantic.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

@@ -2,7 +2,7 @@ package ast.statements;
 
 import ast.expressions.IExpressionNode;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 public class WhileNode implements IStatementNode {
     public IExpressionNode expression;
@@ -13,6 +13,10 @@ public class WhileNode implements IStatementNode {
         this.block = block;
     }
 
+    public void test() {
+
+    }
+
     @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 typechecker.TypeCheckResult;
+import semantic.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 {
 
-    private TypeEnum typeEnum;
+    public final TypeEnum typeEnum;
 
     public BaseType(TypeEnum typeEnum) {
         this.typeEnum = typeEnum;
@@ -21,8 +21,6 @@ public class BaseType implements ITypeNode {
         if (getClass() != obj.getClass())
             return false;
         BaseType other = (BaseType) obj;
-        if (typeEnum != other.typeEnum)
+        return typeEnum == other.typeEnum;
-            return false;
-        return true;
     }
 }

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

@@ -1,5 +1,4 @@
 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 {
 
-    private String identifier;
+    public final String identifier;
 
     public ReferenceType(String identifier) {
         this.identifier = identifier;
@@ -22,11 +22,8 @@ public class ReferenceType implements ITypeNode{
             return false;
         ReferenceType other = (ReferenceType) obj;
         if (identifier == null) {
-            if (other.identifier != null)
+            return other.identifier == null;
-                return false;
+        } else return identifier.equals(other.identifier);
-        } else if (!identifier.equals(other.identifier))
-            return false;
-        return true;
     }
 
 

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

@@ -4,6 +4,5 @@ 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 String outputDirectory;
+    private final String outputDirectory;
-    private boolean generateJar;
+    private final boolean generateJar;
-    private boolean generateClassFiles;
+    private final 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 Mapper mapper;
+    private final Mapper mapper;
     private ClassWriter classWriter;
-    private JarOutputStream jarOutputStream;
+    private final JarOutputStream jarOutputStream;
-    private String outputDirectory;
+    private final String outputDirectory;
-    private boolean generateJar;
+    private final boolean generateJar;
-    private boolean generateClassFiles;
+    private final boolean generateClassFiles;
 
     public ClassCodeGen(JarOutputStream jarOutputStream, String outputDirectory, boolean generateJar, boolean generateClassFiles) {
         mapper = new Mapper();

src/main/java/bytecode/MethodCodeGen.java

@@ -16,7 +16,6 @@ import ast.statementexpressions.crementexpressions.DecrementNode;
 import ast.statementexpressions.crementexpressions.IncrementNode;
 import ast.statementexpressions.methodcallstatementnexpressions.ChainedMethodNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
-import ast.statementexpressions.methodcallstatementnexpressions.TargetNode;
 import ast.statements.*;
 import ast.type.ValueNode;
 import ast.type.type.BaseType;
@@ -35,16 +34,16 @@ import static org.objectweb.asm.Opcodes.*;
 
 public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
-    private ClassWriter classWriter;
+    private final ClassWriter classWriter;
-    private Mapper mapper;
+    private final Mapper mapper;
     private MethodVisitor methodVisitor;
 
-    private List<String> localVaribales;
+    private final List<String> localVariables;
 
     public MethodCodeGen(ClassWriter classWriter) {
         this.classWriter = classWriter;
         mapper = new Mapper();
-        localVaribales = new ArrayList<>();
+        localVariables = new ArrayList<>();
     }
 
 
@@ -60,10 +59,10 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
                         null);
 
         methodVisitor.visitCode();
-        localVaribales.add("this");
+        localVariables.add("this");
         // Add all method parameters to localVariables
         for (ParameterNode parameterNode : constructorNode.parameters) {
-            localVaribales.add(parameterNode.identifier);
+            localVariables.add(parameterNode.identifier);
         }
 
         methodVisitor.visitVarInsn(ALOAD, 0);
@@ -89,8 +88,8 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
                 null);
 
         methodVisitor.visitCode();
-        localVaribales.add("this");
+        localVariables.add("this");
-        localVaribales.add("args");
+        localVariables.add("args");
 
         // Visit all statements
         for (IStatementNode statementNode : mainMethodNode.block.statements) {
@@ -110,10 +109,10 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
                 null);
 
         methodVisitor.visitCode();
-        localVaribales.add("this");
+        localVariables.add("this");
         // Add all method parameters to localVariables
         for (ParameterNode parameterNode : methodNode.parameters) {
-            localVaribales.add(parameterNode.identifier);
+            localVariables.add(parameterNode.identifier);
         }
 
         // Visit all statements
@@ -158,8 +157,8 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (dotNode.dotExpression != null) {
             dotNode.dotExpression.accept(this);
         }
-        if (dotNode.dotSubstractionExpression != null) {
+        if (dotNode.dotSubtractionExpression != null) {
-            dotNode.dotSubstractionExpression.accept(this);
+            dotNode.dotSubtractionExpression.accept(this);
         }
         if (dotNode.operator != null) {
             switch (dotNode.operator) {
@@ -177,17 +176,17 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     }
 
     @Override
-    public void visit(DotSubstractionNode dotSubstractionNode) {
+    public void visit(DotSubtractionNode dotSubtractionNode) {
-        if (dotSubstractionNode.value != null) {
+        if (dotSubtractionNode.value != null) {
-            dotSubstractionNode.value.accept(this);
+            dotSubtractionNode.value.accept(this);
-        } else if (dotSubstractionNode.identifier != null) {
+        } else if (dotSubtractionNode.identifier != null) {
-            methodVisitor.visitVarInsn(ILOAD, localVaribales.indexOf(dotSubstractionNode.identifier));
+            methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(dotSubtractionNode.identifier));
-        } else if (dotSubstractionNode.memberAccess != null) {
+        } else if (dotSubtractionNode.memberAccess != null) {
-            dotSubstractionNode.memberAccess.accept(this);
+            dotSubtractionNode.memberAccess.accept(this);
-        } else if (dotSubstractionNode.methodCall != null) {
+        } else if (dotSubtractionNode.methodCall != null) {
-            dotSubstractionNode.methodCall.accept(this);
+            dotSubtractionNode.methodCall.accept(this);
-        } else if (dotSubstractionNode.calculationExpression != null) {
+        } else if (dotSubtractionNode.calculationExpression != null) {
-            dotSubstractionNode.calculationExpression.accept(this);
+            dotSubtractionNode.calculationExpression.accept(this);
         }
     }
 
@@ -195,7 +194,6 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     public void visit(NonCalculationNode nonCalculationNode) {
         Label labelFalse = new Label();
         Label labelTrue = new Label();
-        // TODO: Null check
         switch (nonCalculationNode.operator) {
             case AND:
                 nonCalculationNode.unaryExpression.accept(this);
@@ -266,8 +264,10 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     @Override
     public void visit(MemberAccessNode memberAccessNode) {
-        if (memberAccessNode.thisExpr) {
+        // Only used to get, not to put
-            // methodVisitor.visitFieldInsn(PUTFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), );
+        if (memberAccessNode.thisExpr) { // Field
+            // methodVisitor.visitFieldInsn(GETFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), );
+        } else { // Object Attribut
         }
     }
 
@@ -296,7 +296,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (unaryNode.thisExp != null) {
             methodVisitor.visitVarInsn(ALOAD, 0); // this
         } else if (unaryNode.identifier != null) {
-            methodVisitor.visitVarInsn(ILOAD, localVaribales.indexOf(unaryNode.identifier));
+            methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(unaryNode.identifier));
         } else if (unaryNode.memberAccess != null) {
             unaryNode.memberAccess.accept(this);
         } else if (unaryNode.value != null) {
@@ -362,23 +362,23 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
             // Process expression
             localVariableDeclarationNode.expression.accept(this);
             // Store result of expression in variable
-            if (localVaribales.contains(localVariableDeclarationNode.identifier)) {
+            if (localVariables.contains(localVariableDeclarationNode.identifier)) {
                 if (localVariableDeclarationNode.type instanceof BaseType) {
-                    methodVisitor.visitVarInsn(ISTORE, localVaribales.indexOf(localVariableDeclarationNode.identifier));
+                    methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
                 } else if (localVariableDeclarationNode.type instanceof ReferenceType) {
-                    methodVisitor.visitVarInsn(ASTORE, localVaribales.indexOf(localVariableDeclarationNode.identifier));
+                    methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
                 }
             } else {
-                localVaribales.add(localVariableDeclarationNode.identifier);
+                localVariables.add(localVariableDeclarationNode.identifier);
                 if (localVariableDeclarationNode.type instanceof BaseType) {
-                    methodVisitor.visitVarInsn(ISTORE, localVaribales.indexOf(localVariableDeclarationNode.identifier));
+                    methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
                 } else if (localVariableDeclarationNode.type instanceof ReferenceType) {
-                    methodVisitor.visitVarInsn(ASTORE, localVaribales.indexOf(localVariableDeclarationNode.identifier));
+                    methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
                 }
             }
         } else {
-            if (!localVaribales.contains(localVariableDeclarationNode.identifier)) {
+            if (!localVariables.contains(localVariableDeclarationNode.identifier)) {
-                localVaribales.add(localVariableDeclarationNode.identifier);
+                localVariables.add(localVariableDeclarationNode.identifier);
             }
         }
     }
@@ -386,46 +386,50 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     @Override
     public void visit(AssignNode assignNode) {
         // Process expression
-        if (assignNode.expression instanceof IncrementNode) {
+        if (assignNode.expression instanceof IncrementNode incrementNode) {
-            IncrementNode incrementNode = (IncrementNode) assignNode.expression;
             if (incrementNode.crementType.equals(CrementType.PREFIX)) { // ++i
-                methodVisitor.visitIincInsn(localVaribales.indexOf(incrementNode.assignableExpression.identifier), 1);
+                methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
                 assign(assignNode);
             } else if (incrementNode.crementType.equals(CrementType.SUFFIX)) { // Suffix: i++
                 assign(assignNode);
-                methodVisitor.visitIincInsn(localVaribales.indexOf(incrementNode.assignableExpression.identifier), 1);
+                methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
             }
-        } else if (assignNode.expression instanceof DecrementNode) {
+        } else if (assignNode.expression instanceof DecrementNode decrementNode) {
-            DecrementNode decrementNode = (DecrementNode) assignNode.expression;
             if (decrementNode.crementType.equals(CrementType.PREFIX)) {
-                methodVisitor.visitIincInsn(localVaribales.indexOf(decrementNode.assignableExpression.identifier), -1);
+                methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), -1);
                 assign(assignNode);
             } else if (decrementNode.crementType.equals(CrementType.SUFFIX)) {
                 assign(assignNode);
-                methodVisitor.visitIincInsn(localVaribales.indexOf(decrementNode.assignableExpression.identifier), 1);
+                methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), 1);
             }
         } else {
             assignNode.expression.accept(this);
+            assign(assignNode);
         }
     }
 
     private void assign(AssignNode assignNode) {
-        // Store result of expression in variable
         if (assignNode.assignable.memberAccess.thisExpr) {
-            // Global var
+            assignField(assignNode);
-            methodVisitor.visitVarInsn(ALOAD, 0);
-            if (assignNode.expression instanceof BaseType) {
-                //methodVisitor.visitFieldInsn(PUTFIELD, class name, var identifier, mapper.getTypeChar(((BaseTypeNode) type).enumType));
-            } else if (assignNode.expression instanceof ReferenceType) {
-                //methodVisitor.visitFieldInsn(PUTFIELD, class name, var identifier, "L"class name object +";");
-            }
         } else {
-            // Local var
+            assignLocalVar(assignNode);
-            if (assignNode.expression instanceof BaseType) {
+        }
-                methodVisitor.visitVarInsn(ISTORE, localVaribales.indexOf(assignNode.assignable.identifier));
+    }
-            } else if (assignNode.expression instanceof ReferenceType) {
+
-                methodVisitor.visitVarInsn(ASTORE, localVaribales.indexOf(assignNode.assignable.identifier));
+    private void assignLocalVar(AssignNode assignNode) {
-            }
+        if (assignNode.expression instanceof BaseType) {
+            methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(assignNode.assignable.identifier));
+        } else if (assignNode.expression instanceof ReferenceType) {
+            methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(assignNode.assignable.identifier));
+        }
+    }
+
+    private void assignField(AssignNode assignNode) {
+        if (assignNode.expression instanceof BaseType) {
+            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) assignNode.expression.getType()));
+        } else if (assignNode.expression instanceof ReferenceType) {
+            ReferenceType referenceType = (ReferenceType) assignNode.expression.getType();
+            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), "L"+referenceType.getIdentifier()+";");
         }
     }
 
@@ -433,13 +437,13 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     public void visit(NewDeclarationNode newDeclarationNode) {
         methodVisitor.visitTypeInsn(NEW, newDeclarationNode.identifier);
         methodVisitor.visitInsn(DUP);
+        List<ParameterNode> parameterNodes = new ArrayList<>();
         for (IExpressionNode expressionNode : newDeclarationNode.expressions) {
             expressionNode.accept(this);
+            parameterNodes.add(new ParameterNode(expressionNode.getType(), ""));
         }
-        // TODO
+        methodVisitor.visitMethodInsn(INVOKESPECIAL, newDeclarationNode.identifier, "<init>", mapper.generateMethodDescriptor(new BaseType(TypeEnum.VOID),parameterNodes), false);
-        //methodVisitor.visitMethodInsn(INVOKESPECIAL, class name, "<init>", mapper.generateMethodDescriptor(), false);
+        localVariables.add(newDeclarationNode.identifier);
-        // TODO: kann ein Field auch definiert werden? Abfrage ob local var oder field
-        localVaribales.add(newDeclarationNode.identifier);
     }
 
     @Override
@@ -505,13 +509,6 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         whileNode.expression.accept(this);
         methodVisitor.visitJumpInsn(IFEQ, endOfLoopLabel); // if condition is false, jump out of loop
 
-        // TODO: Unterscheidung bei increment/decrement der for Schleife
-        if (whileNode.block.statements.size() == 2) { // For loop
-            whileNode.block.statements.get(0).accept(this);
-
-        } else {
-            whileNode.block.statements.get(0).accept(this);
-        }
         whileNode.block.accept(this);
         methodVisitor.visitJumpInsn(GOTO, loopLabel);
 
@@ -520,16 +517,17 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     @Override
     public void visit(ChainedMethodNode chainedMethodNode) {
-
+        // TODO: Erstmal abwarten
     }
 
     @Override
     public void visit(MethodCallNode methodCallNode) {
-
+        List<ParameterNode> parameterNodes = new ArrayList<>();
-    }
+        for(IExpressionNode expressionNode : methodCallNode.parameters) {
-
+            expressionNode.accept(this);
-    @Override
+            parameterNodes.add(new ParameterNode(expressionNode.getType(), ""));
-    public void visit(TargetNode targetNode) {
+        }
-
+        // TODO: Klassenname und Returntype
+        //methodVisitor.visitMethodInsn(INVOKEVIRTUAL, classname, methodCallNode.identifier, mapper.generateMethodDescriptor(returntype, parameterNodes), false);
     }
 }

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

@@ -8,47 +8,54 @@ 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(DotSubstractionNode dotSubstractionNode);
+
+    void visit(DotSubtractionNode dotSubtractionNode);
+
     void visit(NonCalculationNode nonCalculationNode);
 
     // Unary expressions
     void visit(MemberAccessNode memberAccessNode);
+
     void visit(NotNode notExpressionNode);
+
     void visit(UnaryNode unaryExpressionNode);
 
     // statements
     void visit(IfElseNode ifElseNode);
 
     void visit(LocalVariableDeclarationNode localVariableDeclarationNode);
+
     void visit(ReturnNode returnNode);
+
     void visit(WhileNode whileNode);
 
     // statement expression
     void visit(ChainedMethodNode chainedMethodNode);
+
     void visit(MethodCallNode methodCallNode);
-    void visit(TargetNode targetNode);
 
     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

@@ -13,16 +13,17 @@ import org.antlr.v4.runtime.tree.ParseTree;
 
 import java.io.IOException;
 import java.nio.file.Paths;
+import java.util.Optional;
 
 
 /**
- * Start Raupenpiler using make:
+ * Start miniCompiler using make:
  * <p> <code> cd .\src\test\ </code>
- * <p> <code> make clean compile-raupenpiler </code>
+ * <p> <code> make clean compile-miniCompiler </code>
- * <p> Start Raupenpiler using jar:
+ * <p> Start miniCompiler using jar:
- * <p> <code> java.exe -jar path_to_jar\JavaCompiler-1.0-jar-with-dependencies.jar 'path_to_input_file.java' 'path_to_output_directory' </code>
+ * <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 -jar .\target\JavaCompiler-1.0-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' </code>
+ * <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>
  */
 public class Main {
     public static void main(String[] args) throws Exception {
@@ -39,16 +40,6 @@ 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());
-            }
-        }
-        */
     }
 
     /**
@@ -65,7 +56,7 @@ public class Main {
      */
     static void compileFile(CharStream inputCharStream, String outputDirectoryPath) {
         // Initialize the logger
-        new RaupenLogger();
+        new MiniCompilerLogger();
 
         /* ------------------------- Scanner -> tokens ------------------------- */
         // Use the SimpleJavaLexer to tokenize the input CharStream
@@ -73,34 +64,46 @@ public class Main {
         CommonTokenStream tokenStream = new CommonTokenStream(lexer);
         tokenStream.fill();
         // Log the tokens
-        RaupenLogger.logScanner(tokenStream);
+        MiniCompilerLogger.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
-        RaupenLogger.logParser(parseTree, parser);
+        MiniCompilerLogger.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
-        RaupenLogger.logAST(abstractSyntaxTree);
+        MiniCompilerLogger.logAST(abstractSyntaxTree);
 
         /*------------------------- Semantic Analyzer -> typed AST -------------------------*/
         // Use the SemanticAnalyzer to generate a typed AST
-        //ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
         // Log the typed AST
-        RaupenLogger.logSemanticAnalyzer(abstractSyntaxTree);
+        MiniCompilerLogger.logSemanticAnalyzer(typedAst);
+
+        if(SemanticAnalyzer.errors.isEmpty()){
+            /*------------------------- Bytecode Generator -> Bytecode -------------------------*/
+            // Use the ByteCodeGenerator to generate bytecode from the typed AST and output it to the specified directory
+
+            final boolean genJar = Optional.ofNullable(System.getProperty("genJar")).map(String::toLowerCase).map(Boolean::parseBoolean).orElse(true);
+            final boolean genClass = Optional.ofNullable(System.getProperty("genClass")).map(String::toLowerCase).map(Boolean::parseBoolean).orElse(true);
+
+            ByteCodeGenerator byteCodeGenerator = new ByteCodeGenerator(outputDirectoryPath, genJar, genClass);
+            assert typedAst != null;
+            byteCodeGenerator.visit((ProgramNode) typedAst);
+            // Log the bytecode generation
+            MiniCompilerLogger.logBytecodeGenerator();
+        } else {
+            for(Exception exception : SemanticAnalyzer.errors){
+                exception.printStackTrace();
+            }
+        }
+
 
-        /*------------------------- Bytecode Generator -> Bytecode -------------------------*/
-        // Use the ByteCodeGenerator to generate bytecode from the typed AST and output it to the specified directory
-        ByteCodeGenerator byteCodeGenerator = new ByteCodeGenerator(outputDirectoryPath, true, true);
-        assert abstractSyntaxTree != null;
-        byteCodeGenerator.visit((ProgramNode) abstractSyntaxTree);
-        // Log the bytecode generation
-        RaupenLogger.logBytecodeGenerator();
     }
 }

src/main/java/main/MiniCompilerLogger.java

@@ -29,11 +29,11 @@ import java.util.logging.*;
  * <code>consoleHandler.setLevel(Level.OFF);</code>
  * <code>fileHandler.setLevel(Level.ALL);</code>
  */
-public class RaupenLogger {
+public class MiniCompilerLogger {
 
-    static Logger logger = Logger.getLogger("RaupenLogs");
+    static Logger logger = Logger.getLogger("miniCompilerLogs");
 
-    public RaupenLogger() {
+    public MiniCompilerLogger() {
         // ------------------------- Logging -------------------------
         logger.setLevel(Level.ALL);
         logger.getParent().getHandlers()[0].setLevel(Level.ALL);
@@ -66,7 +66,7 @@ public class RaupenLogger {
             logger.addHandler(consoleHandler);
 
             // Configure file handler
-            Handler fileHandler = new FileHandler("src/main/resources/logs/RaupenLog.log");
+            Handler fileHandler = new FileHandler("src/main/resources/logs/miniCompiler.log");
             // Toggle file logging on/off
             fileHandler.setLevel(Level.ALL);
             fileHandler.setFormatter(new CustomFormatter());
@@ -117,7 +117,7 @@ public class RaupenLogger {
     public static void logBytecodeGenerator() {
         // Printing the bytecode
         logger.info("-------------------- Bytecode Generator -> Bytecode  --------------------");
-        logger.info("Bytecode generated");
+        logger.info("Bytecode generated without errors.");
         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((IStatementNode) doBlock);
+        resultBlock.addStatement(doBlock);
-        resultBlock.addStatement((IStatementNode) While);
+        resultBlock.addStatement(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((IStatementNode) crement);
+            whileBody.addStatement(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((IStatementNode) crement);
+            whileBody.addStatement(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((IStatementNode) statement);
+            resultBlock.addStatement(statement);
         }
 
         return resultBlock;
@@ -281,8 +281,13 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
     @Override
     public ASTNode visitIfElseStatement(SimpleJavaParser.IfElseStatementContext ctx) {
-        IfElseNode ifElseStatementNode =  new IfElseNode((IfNode) visit(ctx.ifStatement()),
+        IfElseNode ifElseStatementNode;
-                (ElseNode) visit(ctx.elseStatement()));
+        if(ctx.elseStatement() != null) {
+            ifElseStatementNode =  new IfElseNode((IfNode) visit(ctx.ifStatement()),
+                    (ElseNode) visit(ctx.elseStatement()));
+        } else {
+            ifElseStatementNode =  new IfElseNode((IfNode) visit(ctx.ifStatement()), null);
+        }
 
         for (SimpleJavaParser.ElseIfStatementContext elseIf : ctx.elseIfStatement()){
             ifElseStatementNode.addElseIfStatement(((IfNode) visit(elseIf)));
@@ -554,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(), (DotSubstractionNode) visit(ctx.dotSubtractionExpression()));
+            return new DotNode((DotNode) visit(ctx.dotExpression()), ctx.DotOperator().getText(), (DotSubtractionNode) visit(ctx.dotSubtractionExpression()));
         } else if(ctx.dotSubtractionExpression() != null) {
-            return new DotNode((DotSubstractionNode) visit(ctx.dotSubtractionExpression()));
+            return new DotNode((DotSubtractionNode) visit(ctx.dotSubtractionExpression()));
         }
         return null;
     }
@@ -564,13 +569,13 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
     @Override
     public ASTNode visitDotSubtractionExpression(SimpleJavaParser.DotSubtractionExpressionContext ctx) {
         if(ctx.IntValue() != null) {
-            return new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, ctx.IntValue().getText()));
+            return new DotSubtractionNode(new ValueNode(EnumValueNode.INT_VALUE, ctx.IntValue().getText()));
         } else if(ctx.Identifier() != null) {
-            return new DotSubstractionNode(ctx.Identifier().getText());
+            return new DotSubtractionNode(ctx.Identifier().getText());
         } else if(ctx.memberAccess() != null) {
-            return new DotSubstractionNode((MemberAccessNode) visit(ctx.memberAccess()));
+            return new DotSubtractionNode((MemberAccessNode) visit(ctx.memberAccess()));
         } else if(ctx.methodCall() != null && ctx.calculationExpression() != null) {
-            return new DotSubstractionNode((MethodCallNode) visit(ctx.methodCall()), (CalculationNode) visit(ctx.calculationExpression()));
+            return new DotSubtractionNode((MethodCallNode) visit(ctx.methodCall()), (CalculationNode) visit(ctx.calculationExpression()));
         }
         return null;
     }
@@ -599,6 +604,4 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
             default -> new ReferenceType(identifier);
         };
     }
-
+}
-}
-

src/main/java/parser/generated/SimpleJavaBaseListener.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 
 import org.antlr.v4.runtime.ParserRuleContext;

src/main/java/parser/generated/SimpleJavaBaseVisitor.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
 

src/main/java/parser/generated/SimpleJavaLexer.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.CharStream;

src/main/java/parser/generated/SimpleJavaListener.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 

src/main/java/parser/generated/SimpleJavaVisitor.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 

src/main/java/semantic/Scope.java

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

src/main/java/semantic/SemanticAnalyzer.java

@@ -21,6 +21,7 @@ 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.*;
@@ -29,9 +30,10 @@ 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;
+import semantic.TypeCheckResult;
 
 public class SemanticAnalyzer implements SemanticVisitor {
 
@@ -163,6 +165,11 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
     @Override
     public TypeCheckResult analyze(FieldNode toCheck) {
+        if (toCheck.type instanceof ReferenceType referenceType) {
+            if (!context.containsClass(referenceType.getIdentifier())) {
+                errors.add(new NotDeclaredException(referenceType.getIdentifier() + " not declared"));
+            }
+        }
         if (currentFields.get(toCheck.identifier) != null) {
             errors.add(new AlreadyDeclaredException("Already declared " + toCheck.identifier));
             return new TypeCheckResult(false, null);
@@ -170,6 +177,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
             currentFields.put(toCheck.identifier, toCheck.type);
         }
         return new TypeCheckResult(true, null);
+
+
     }
 
     @Override
@@ -224,7 +233,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
         }
         for (IStatementNode statementNode : blockNode.statements) {
             var result = statementNode.accept(this);
-            if(!(statementNode instanceof IncrementNode) && !(statementNode instanceof DecrementNode)){
+            if (!(statementNode instanceof IncrementNode) && !(statementNode instanceof DecrementNode)) {
                 if (result.getType() != null) {
                     if (blockReturnType == null) {
                         blockReturnType = result.getType();
@@ -244,11 +253,16 @@ 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 {
             if (currentFields.get(toCheck.identifier) != null) {
                 var type = currentFields.get(toCheck.identifier);
+                MemberAccessNode memberAccessNode = new MemberAccessNode(false);
+                memberAccessNode.identifiers.add(currentClass.identifier);
+                memberAccessNode.identifiers.add(toCheck.identifier);
+                toCheck.memberAccess = memberAccessNode;
                 toCheck.setTypeNode(type);
                 return new TypeCheckResult(true, type);
             } else if (currentScope.getLocalVar(toCheck.identifier) != null) {
@@ -275,13 +289,6 @@ public class SemanticAnalyzer implements SemanticVisitor {
         currentNullType = oldNullType;
         var valid = true;
 
-        // This check currently handles things like :
-        /**
-         * private int i;
-         * void foo(int i){
-         * i = i;
-         * }
-         */
         if (assignable.equals(rExpression)) {
             errors.add(new TypeMismatchException("Cannot assign to self"));
             valid = false;
@@ -310,41 +317,84 @@ public class SemanticAnalyzer implements SemanticVisitor {
     @Override
     public TypeCheckResult analyze(IfElseNode toCheck) {
         var resultIf = toCheck.ifStatement.accept(this);
-        var resultElse = toCheck.elseStatement.accept(this);
+        if(toCheck.elseStatement != null){
+            var resultElse = toCheck.elseStatement.accept(this);
+            return new TypeCheckResult(resultIf.isValid() && resultElse.isValid(), new BaseType(TypeEnum.VOID));
+        }
 
-        return new TypeCheckResult(resultIf.isValid() && resultElse.isValid(), new BaseType(TypeEnum.VOID));
+
+        return new TypeCheckResult(resultIf.isValid(), new BaseType(TypeEnum.VOID));
     }
 
     @Override
     public TypeCheckResult analyze(MethodCallNode toCheck) {
 
-        if (toCheck.target.identifier != null) {
+        if (toCheck.target != null) {
-            var targetType = currentScope.getLocalVar(toCheck.target.identifier);
+            if(toCheck.target.memberAccess == null){
-            if (targetType == null) {
+                MemberAccessNode memberAccessNode = new MemberAccessNode(false);
-                targetType = currentFields.get(toCheck.target.identifier);
+                memberAccessNode.identifiers.add(currentClass.identifier);
+                memberAccessNode.identifiers.add(toCheck.target.identifier);
+                toCheck.target.memberAccess = memberAccessNode;
             }
-            if (targetType instanceof ReferenceType reference) {
+            if (toCheck.target.identifier != null) {
-                var type = getTypeFromMethod(toCheck, reference);
+                var targetType = currentScope.getLocalVar(toCheck.target.identifier);
-                if (type != null) {
+                if (targetType == null) {
-                    return new TypeCheckResult(true, type);
+                    targetType = currentFields.get(toCheck.target.identifier);
-                } else {
-                    return new TypeCheckResult(false, null);
                 }
+                if (targetType instanceof ReferenceType reference) {
+                    if (!toCheck.chainedMethods.isEmpty()) {
+                        for (ChainedMethodNode chainedMethod : toCheck.chainedMethods) {
+                            var type = getTypeFromMethod(chainedMethod, reference);
+                            if (type instanceof ReferenceType referenceType)
+                                reference = referenceType;
+                            else
+                                errors.add(new TypeMismatchException("Ein Basetyp hat keine funktionen"));
+                        }
+                    }
+                    var type = getTypeFromMethod(toCheck, reference);
+                    if (type != null) {
+                        return new TypeCheckResult(true, type);
+                    } else {
+                        return new TypeCheckResult(false, null);
+                    }
 
-            }
-        } else {
-            if (toCheck.target.thisTar) {
-                var type = getTypeFromMethod(toCheck, new ReferenceType(currentClass.identifier));
-                if (type != null) {
-                    return new TypeCheckResult(true, type);
                 }
             } else {
-                var result = toCheck.target.accept(this);
+                if (toCheck.target.thisTar != null) {
-                if (result.getType() instanceof ReferenceType reference) {
+                    if (toCheck.target.thisTar) {
-                    return new TypeCheckResult(true, getTypeFromMethod(toCheck, reference));
+                        var type = getTypeFromMethod(toCheck, new ReferenceType(currentClass.identifier));
+                        if (type != null) {
+                            return new TypeCheckResult(true, type);
+                        }
+                    }
+                } else {
+                    var result = toCheck.target.accept(this);
+                    if (result.getType() instanceof ReferenceType reference) {
+                        return new TypeCheckResult(true, getTypeFromMethod(toCheck, reference));
+                    }
                 }
             }
+        } else {
+
+            ReferenceType reference = new ReferenceType(currentClass.identifier);
+            if (!toCheck.chainedMethods.isEmpty()) {
+                for (ChainedMethodNode chainedMethod : toCheck.chainedMethods) {
+                    var type = getTypeFromMethod(chainedMethod, reference);
+                    if (type instanceof ReferenceType referenceType)
+                        reference = referenceType;
+                    else
+                        errors.add(new TypeMismatchException("Ein Basetyp hat keine funktionen"));
+                }
+            }
+            var type = getTypeFromMethod(toCheck, reference);
+            if (type != null) {
+                return new TypeCheckResult(true, type);
+            } else {
+                return new TypeCheckResult(false, null);
+            }
+
         }
+
         return new TypeCheckResult(false, null);
     }
 
@@ -383,9 +433,9 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
         if (context.containsClass(toCheck.identifier)) {
             return new TypeCheckResult(true, new ReferenceType(toCheck.identifier));
+        } else {
+            throw new RuntimeException("Cannot find class " + toCheck.identifier);
         }
-
-        return null;
     }
 
     @Override
@@ -409,6 +459,7 @@ 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;
@@ -416,10 +467,12 @@ 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);
@@ -427,28 +480,46 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
     @Override
     public TypeCheckResult analyze(DotNode toCheck) {
-        if (toCheck.dotSubstractionExpression != null) {
+        if (toCheck.dotSubtractionExpression != null) {
-            return toCheck.dotSubstractionExpression.accept(this);
+            var result = toCheck.dotSubtractionExpression.accept(this);
+            toCheck.setType(result.getType());
+            return result;
         }
         return new TypeCheckResult(false, null);
     }
 
     @Override
-    public TypeCheckResult analyze(DotSubstractionNode toCheck) {
+    public TypeCheckResult analyze(DotSubtractionNode toCheck) {
         if (toCheck.value != null) {
-            return toCheck.value.accept(this);
+            var result = toCheck.value.accept(this);
+            toCheck.setType(result.getType());
+            return result;
         } else if (toCheck.memberAccess != null) {
-            return toCheck.memberAccess.accept(this);
+            var result = toCheck.memberAccess.accept(this);
+            toCheck.setType(result.getType());
+            return result;
         } else if (toCheck.methodCall != null) {
-            return toCheck.methodCall.accept(this);
+            var result = toCheck.methodCall.accept(this);
+            toCheck.setType(result.getType());
+            return result;
         } else if (toCheck.identifier != null) {
             if (currentScope.contains(toCheck.identifier)) {
-                return new TypeCheckResult(true, currentScope.getLocalVar(toCheck.identifier));
+                var type = currentScope.getLocalVar(toCheck.identifier);
+                toCheck.setType(type);
+                return new TypeCheckResult(true, type);
             } else if (currentFields.get(toCheck.identifier) != null) {
-                return new TypeCheckResult(true, currentFields.get(toCheck.identifier));
+                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);
             }
         } else if (toCheck.calculationExpression != null) {
-            return toCheck.calculationExpression.accept(this);
+            var result = toCheck.calculationExpression.accept(this);
+            toCheck.setType(result.getType());
+            return result;
         }
         return null;
     }
@@ -468,8 +539,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 }
                 break;
             case OR, AND:
-                if (expResult.getType() instanceof BaseType expResultType && expResultType.getTypeEnum().equals(TypeEnum.INT) &&
+                if (expResult.getType() instanceof BaseType expResultType && expResultType.getTypeEnum().equals(TypeEnum.BOOL) &&
-                        unaryResult.getType() instanceof BaseType unaryResultType && unaryResultType.getTypeEnum().equals(TypeEnum.INT)) {
+                        unaryResult.getType() instanceof BaseType unaryResultType && unaryResultType.getTypeEnum().equals(TypeEnum.BOOL)) {
                     return new TypeCheckResult(true, new BaseType(TypeEnum.BOOL));
                 } else {
                     errors.add(new TypeMismatchException("Both types must be Boolean"));
@@ -493,9 +564,17 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
         if (unary.identifier != null) {
             if (currentScope.contains(unary.identifier)) {
-                return new TypeCheckResult(valid, currentScope.getLocalVar(unary.identifier));
+                var type = currentScope.getLocalVar(unary.identifier);
+                unary.setType(type);
+                return new TypeCheckResult(valid, type);
             } else if (currentFields.get(unary.identifier) != null) {
-                return new TypeCheckResult(valid, currentFields.get(unary.identifier));
+                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.statement != null) {
                 var result = unary.statement.accept(this);
                 unary.setType(result.getType());
@@ -505,15 +584,19 @@ 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());
         }
 
@@ -524,8 +607,20 @@ public class SemanticAnalyzer implements SemanticVisitor {
     public TypeCheckResult analyze(MemberAccessNode memberAccessNode) {
 
         ITypeNode currentType = null;
+        int start = 0;
+        if(!memberAccessNode.identifiers.isEmpty()){
+            if(currentFields.get(memberAccessNode.identifiers.getFirst()) != null){
+                memberAccessNode.identifiers.addFirst(currentClass.identifier);
+                start++;
+            }
+        }
+        if(context.getClasses().get(memberAccessNode.identifiers.getFirst()) == null){
+            memberAccessNode.identifiers.addFirst(currentClass.identifier);
+            start++;
+        }
+        for (int i = start; i < memberAccessNode.identifiers.size(); i++) {
 
-        for (String s : memberAccessNode.identifiers) {
+            String s = memberAccessNode.identifiers.get(i);
             if (currentType == null) {
                 if (currentScope.getLocalVar(s) != null) {
                     currentType = currentScope.getLocalVar(s);
@@ -540,7 +635,8 @@ 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();
@@ -561,6 +657,11 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
         if (targetNode.memberAccess != null) {
             return targetNode.memberAccess.accept(this);
+        } else if(targetNode.identifier != null) {
+            MemberAccessNode memberAccessNode = new MemberAccessNode(false);
+            memberAccessNode.identifiers.add(currentClass.identifier);
+            memberAccessNode.identifiers.add(targetNode.identifier);
+            targetNode.memberAccess = memberAccessNode;
         }
         return null;
     }
@@ -620,4 +721,37 @@ public class SemanticAnalyzer implements SemanticVisitor {
         return null;
     }
 
+    private ITypeNode getTypeFromMethod(ChainedMethodNode toCheck, ReferenceType reference) {
+        var classContext = context.getClass(reference.getIdentifier());
+
+        var methods = classContext.getMethods();
+        for (var method : methods) {
+            if (toCheck.identifier.equals(method.getIdentifier())) {
+                if (method.getParameters().size() == toCheck.expressions.size() && !(method instanceof ConstructorNode)) {
+                    boolean same = true;
+                    for (int i = 0; i < method.getParameters().size(); i++) {
+                        var result1 = method.getParameters().get(i).accept(this);
+                        var result2 = toCheck.expressions.get(i).accept(this);
+                        if (!Objects.equals(result1.getType(), result2.getType())) {
+                            same = false;
+                        }
+                    }
+                    if (same) {
+                        if (method.accesModifier.accessType == EnumAccessModifierNode.PUBLIC) {
+                            if (method.getType() == null) {
+                                return new BaseType(TypeEnum.VOID);
+                            }
+                            return method.getType();
+                        } else {
+                            errors.add(new NotVisibleException("This Method is not Visible"));
+                        }
+
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
 }

src/main/java/semantic/SemanticVisitor.java

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

src/main/java/semantic/TypeCheckResult.java

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

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

@@ -9,8 +9,8 @@ import java.util.HashMap;
 
 public class ClassContext {
 
-  private HashMap<String, FieldContext> fields;
+  private final HashMap<String, FieldContext> fields;
-  private ArrayList<MethodNode> methods = new ArrayList<>();
+  private final 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 HashMap<String, ClassContext> classes;
+  private final HashMap<String, ClassContext> classes;
 
   public Context(ProgramNode programNode) {
     classes = new HashMap<>();
@@ -21,6 +21,10 @@ public class Context {
     return classes.get(identifier);
   }
 
+  public HashMap<String, ClassContext> getClasses() {
+    return classes;
+  }
+
   public boolean containsClass(String identifier) {
     return classes.containsKey(identifier);
   }

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

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

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 typechecker.TypeCheckResult;
+import semantic.TypeCheckResult;
 
 public interface Visitable {
     default void accept(ProgramVisitor programVisitor) {

src/main/resources/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: main.Main
+

src/main/resources/input/CompilerInput.java

@@ -2,9 +2,6 @@ public class Compiler {
     public int add(int i, int j) {
         return i+j;
     }
-    public static void main(String[] args) {
-        int a = 1;
-    }
 }
 
 public class Node {

src/test/Makefile

@@ -2,23 +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-raupenpiler
+all: compile-javac compile-miniCompiler
 
 compile-javac:
 	javac -d .\resources\output\javac .\resources\input\CompilerInput.java
 
-compile-raupenpiler:
+compile-miniCompiler:
 	cd ../.. ; mvn -DskipTests install
-	cd ../.. ; mvn exec:java -Dexec.mainClass="main.Main"  -Dexec.args="'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' "
+	cd ../.. ; mvn exec:java -DgenJar=true -DgenClass=true -Dexec.mainClass="main.Main"  -Dexec.args="'src/main/resources/input/CompilerInput.java' 'src/main/resources/output'"
-	# cp ../main/resources/output/CompilerInput.class .java/resources/output/raupenpiler
+	# cp ../main/resources/output/CompilerInput.class .java/resources/output/miniCompiler
 
-test: compile-javac compile-raupenpiler test-javac test-raupenpiler
+test-miniCompiler:
-
-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
@@ -29,15 +23,19 @@ test-raupenpiler:
 
 
 clean:
-	# clean output folders
+	# clean main 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/raupenpiler/*.class
+	rm -f ./resources/output/miniCompiler/*.class
+	rm -f ./resources/output/miniCompiler/*.jar
 	# clean logs
-	rm -f ../main/resources/logs/*.log
+	rm -f ../main/resources/logs/*
-	# clean test/main folders from .class files for End-to-End tests
+	# clean test/java/main folders from .class files for End-to-End tests
 	rm -f ./java/main/*.class
-	# clean javac output from featureTests
+	# clean javac output from every folder
-	rm -f ./resources/input/featureTests/*.class
+	rm -f ./resources/input/*/*.class
+	# clean test results from maven surefire plugin
+	rm -f ../../target/surefire-reports/*.txt
 

src/test/java/main/EndToEndTester.java

@@ -11,8 +11,6 @@ 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/FailureTest.java

@@ -1,48 +0,0 @@
-package main;
-
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import org.junit.jupiter.api.Test;
-
-import javax.tools.JavaCompiler;
-import javax.tools.ToolProvider;
-import java.io.File;
-
-public class FailureTest {
-    /**
-     * This test method checks if invalid Java files fail to compile as expected.
-     * It uses the JavaCompiler from the ToolProvider to compile the files.
-     * The test passes if all the files fail to compile.
-     */
-    @Test
-    public void areTestFilesActuallyFailTest() {
-        // Get the system Java compiler
-        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
-        // Assert that the compiler is available
-        assertNotNull(javac, "Java Compiler is not available");
-
-        String directoryPath = "src/test/resources/input/failureTests";
-        File folder = new File(directoryPath);
-
-        if (folder.isDirectory()) {
-            File[] files = folder.listFiles((dir, name) -> name.endsWith(".java"));
-
-            if (files != null) {
-                for (File file : files) {
-                    // Try to compile the file and get the result
-                    // The run method returns 0 if the compilation was successful, and non-zero otherwise
-                    int result = javac.run(null, null, null, file.getPath());
-
-                    // Assert that the compilation failed (i.e., the result is non-zero)
-                    assertTrue(result != 0, "Expected compilation failure for " + file.getName());
-                }
-            } else {
-                System.out.println("No files found in the directory.");
-            }
-        } else {
-            System.out.println("The provided path is not a directory.");
-        }
-    }
-}
-

src/test/java/main/FeatureTest.java

@@ -1,46 +0,0 @@
-package main;
-
-import org.junit.jupiter.api.Test;
-
-import javax.tools.JavaCompiler;
-import javax.tools.ToolProvider;
-import java.io.File;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-public class FeatureTest {
-    /**
-     * This test method checks if valid Java files compile successfully.
-     * It uses the JavaCompiler from the ToolProvider to compile the files.
-     * The test passes if all the files compile without errors.
-     */
-    @Test
-    public void areTestFilesActuallyValid() {
-        // Get the system Java compiler
-        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
-        // Assert that the compiler is available
-        assertNotNull(javac, "Java Compiler is not available");
-
-        String directoryPath = "src/test/resources/input/featureTests";
-        File folder = new File(directoryPath);
-
-        if (folder.isDirectory()) {
-            File[] files = folder.listFiles((dir, name) -> name.endsWith(".java"));
-
-            if (files != null) {
-                for (File file : files) {
-                    // Try to compile the file and get the result
-                    // The run method returns 0 if the compilation was successful, and non-zero otherwise
-                    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 directory.");
-            }
-        } else {
-            System.out.println("The provided path is not a directory.");
-        }
-    }
-}

src/test/java/main/InputFilesTest.java

@@ -0,0 +1,236 @@
+package main;
+
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class InputFilesTest {
+
+    /**
+     * This test method checks if valid Java files compile successfully.
+     * It uses the JavaCompiler from the ToolProvider to compile the files.
+     * The test passes if all the files compile without errors.
+     */
+    @Test
+    public void areTestFilesActuallyValid() 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");
+        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");
+
+        List<File> files = getJavaFilesFromDirectory(combinedFeatureTests);
+        // files.addAll(getJavaFilesFromDirectory(endabgabeTests));
+        // files.addAll(getJavaFilesFromDirectory(singleFeatureSemanticTests));
+        files.addAll(getJavaFilesFromDirectory(singleFeatureTests));
+        // files.addAll(getJavaFilesFromDirectory(typedAstFeatureTests));
+
+        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
+    @Disabled
+    public void areEndabgabeTestsActuallyValid() 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 endabgabeTests = new File("src/test/resources/input/endabgabeTests");
+
+        List<File> files = getJavaFilesFromDirectory(endabgabeTests);
+
+        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
+    @Disabled
+    public void areSingleFeatureSemanticTestsActuallyValid() 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 singleFeatureSemanticTests = new File("src/test/resources/input/singleFeatureSemanticTests");
+
+        List<File> files = getJavaFilesFromDirectory(singleFeatureSemanticTests);
+
+        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);
+
+        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
+    @Disabled
+    public void areTypedAstFeatureTestsActuallyValid() 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 typedAstFeatureTests = new File("src/test/resources/input/typedAstFeatureTests");
+
+        List<File> files = getJavaFilesFromDirectory(typedAstFeatureTests);
+
+        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.");
+        }
+    }
+
+
+
+
+    /**
+     * This test method checks if invalid Java files fail to compile as expected.
+     * It uses the JavaCompiler from the ToolProvider to compile the files.
+     * The test passes if all the files fail to compile.
+     */
+    @Test
+    public void areTestFilesActuallyFails() 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 folder1 = new File("src/test/resources/input/failureTests");
+        File folder2 = new File("src/test/resources/input/typedAstExceptionsTest");
+
+        List<File> files = getJavaFilesFromDirectory(folder1);
+        files.addAll(getJavaFilesFromDirectory(folder2));
+
+
+        if (!files.isEmpty()) {
+            for (File file : files) {
+                // Try to compile the file and get the result
+                // The run method returns 0 if the compilation was successful, and non-zero otherwise
+                int result = javac.run(null, null, null, file.getPath());
+
+                // Assert that the compilation failed (i.e., the result is non-zero)
+                assertTrue(result != 0, "Expected compilation failure for " + file.getName());
+            }
+        } else {
+            System.out.println("No files found in the directory.");
+        }
+
+    }
+
+    /**
+     * Helper method to get all .java files from a directory.
+     *
+     * @param directory the directory to search for .java files
+     * @return a list of .java files
+     * @throws IOException if an I/O error occurs
+     */
+    private List<File> getJavaFilesFromDirectory(File directory) throws IOException {
+        if (directory.isDirectory()) {
+            return Files.list(directory.toPath())
+                    .filter(path -> path.toString().endsWith(".java"))
+                    .map(java.nio.file.Path::toFile)
+                    .collect(Collectors.toList());
+        } else {
+            System.out.println("The provided path is not a directory: " + directory.getPath());
+            return List.of();
+        }
+    }
+}

src/test/java/main/MainTest.java

@@ -1,28 +1,21 @@
 package main;
 
-import org.junit.jupiter.api.Test;
+import org.junit.runner.RunWith;
-import org.antlr.v4.runtime.CharStream;
+import org.junit.runners.Suite;
-import org.antlr.v4.runtime.CharStreams;
+import semantic.EndToTypedAstTest;
-
+import semantic.SemanticTest;
-import java.io.IOException;
-import java.nio.file.Paths;
-
 
 /**
- * run every test: mvn test
+ * This class is a test suite that runs all the test classes in the project.
- * Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen
+ * <p> run: <code> mvn test </code>
+ * <p> check results in console or <code> target/surefire-reports </code>
  */
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+        InputFilesTest.class,
+        SemanticTest.class,
+        EndToTypedAstTest.class
+})
 public class MainTest {
-    @Test
+    // This class remains empty, it is used only as a holder for the above annotations
-    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/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.DotSubstractionNode;
+import ast.expressions.binaryexpressions.DotSubtractionNode;
 import ast.expressions.binaryexpressions.NonCalculationNode;
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.expressions.unaryexpressions.UnaryNode;
@@ -14,23 +14,19 @@ import ast.members.*;
 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.NewDeclarationNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
-import ast.statements.*;
 import ast.statementexpressions.methodcallstatementnexpressions.TargetNode;
-import ast.statements.BlockNode;
+import ast.statements.*;
-import ast.statements.LocalVariableDeclarationNode;
-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.ReferenceType;
 import ast.type.type.TypeEnum;
-
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
@@ -39,104 +35,106 @@ import static org.assertj.core.api.Assertions.assertThat;
 @DisplayName("Untyped Abstract Syntax Tree")
 class AstBuilderTest {
 
+    private final static String directoryPath = "src/test/resources/input/singleFeatureTests/";
+
     @Test
     @DisplayName("Empty Class Test")
-    public void emptyClassTest(){
+    public void emptyClassTest() {
-        ClassNode emptyClass = Helper.generateEmptyClass("TestClass");
+        ClassNode emptyClass = Helper.generateEmptyClass("EmptyClass");
         ProgramNode expected = new ProgramNode();
         expected.addClass(emptyClass);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/EmptyClass.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "EmptyClass.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Multiple Empty Classes Test")
     public void multipleEmptyClassesTest() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass1");
+        ClassNode class1 = Helper.generateEmptyClass("MultipleClasses");
         ClassNode class2 = Helper.generateEmptyClass("TestClass2");
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
         expected.addClass(class2);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/MultipleClasses.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "MultipleClasses.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Empty Class Test with Constructor")
     public void emptyClassWithConstructorTest() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("EmptyClassWithConstructor");
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/EmptyClassWithConstructor.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "EmptyClassWithConstructor.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Field Test")
     public void fieldTest() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("Field");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/Field.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "Field.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Field Test with Accessmodifier")
     public void fieldTestWithModifier() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("FieldWithAccessModifier");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/FieldWithAccessModifier.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "FieldWithAccessModifier.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
-    @DisplayName("Commments Ignore Test")
+    @DisplayName("Comments Ignore Test")
-    public void commmentsIgnoreTest(){
+    public void commentsIgnoreTest() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("Comments");
         class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a"));
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/Comments.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "Comments.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
-    @DisplayName("Constructor Paramerter Test")
+    @DisplayName("Constructor Parameter Test")
-    public void constructorParameterTest(){
+    public void constructorParameterTest() {
         BlockNode block = new BlockNode();
         block.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", block);
+        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", "TestClass");
+        ClassNode class1 = new ClassNode("public", "ConstructorParameter");
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorParameter.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "ConstructorParameter.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("This Dot Test")
-    public void thisDotTest(){
+    public void thisDotTest() {
         BlockNode block = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -148,23 +146,23 @@ class AstBuilderTest {
 
         block.addStatement(new AssignNode(assignable, expression));
         block.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", block);
+        ConstructorNode constructor = new ConstructorNode("public", "ThisDot", block);
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "ThisDot");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ThisDot.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "ThisDot.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Constructor This Dot Test")
-    public void constructorThisDotTest(){
+    public void constructorThisDotTest() {
         BlockNode block = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -175,25 +173,25 @@ class AstBuilderTest {
 
         block.addStatement(new AssignNode(assignable, expression));
         block.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", block);
+        ConstructorNode constructor = new ConstructorNode("public", "ConstructorThisDot", block);
         constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "ConstructorThisDot");
         class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a"));
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorThisDot.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "ConstructorThisDot.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Void Methoden Test")
-    public void voidMethodenTest(){
+    public void voidMethodenTest() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("VoidMethod");
         BlockNode block = new BlockNode();
         block.addStatement(new ReturnNode(null));
         class1.addMember(new MethodNode("public", null, true, "test", block));
@@ -201,14 +199,14 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/VoidMethod.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "VoidMethod.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Constructor Method call Test")
-    public void constructorMethodCallTest(){
+    public void constructorMethodCallTest() {
         BlockNode blockCon = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -219,13 +217,13 @@ class AstBuilderTest {
 
         blockCon.addStatement(new AssignNode(assignable, expression));
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
+        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", "TestClass");
+        ClassNode class1 = new ClassNode("public", "ConstructorMethodCall");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
         class1.addMember(constructor);
         class1.addMember(method);
@@ -233,14 +231,14 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorMethodCall.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "ConstructorMethodCall.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Constructor Method call Parameters Test")
-    public void constructorMethodCallParametersTest(){
+    public void constructorMethodCallParametersTest() {
         BlockNode blockCon = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -253,7 +251,7 @@ class AstBuilderTest {
 
         blockCon.addStatement(new AssignNode(assignable, expression));
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
+        ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCallParameters", blockCon);
         constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
 
         BlockNode blockMethod = new BlockNode();
@@ -261,7 +259,7 @@ class AstBuilderTest {
         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", "TestClass");
+        ClassNode class1 = new ClassNode("public", "ConstructorMethodCallParameters");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
         class1.addMember(constructor);
         class1.addMember(method);
@@ -269,14 +267,14 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorMethodCallParameters.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "ConstructorMethodCallParameters.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Char Test")
-    public void charTest(){
+    public void charTest() {
         BlockNode blockCon = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -289,7 +287,7 @@ class AstBuilderTest {
 
         blockCon.addStatement(new AssignNode(assignable, expression));
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
+        ConstructorNode constructor = new ConstructorNode("public", "Char", blockCon);
         constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a"));
 
         BlockNode blockMethod = new BlockNode();
@@ -297,7 +295,7 @@ class AstBuilderTest {
         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", "TestClass");
+        ClassNode class1 = new ClassNode("public", "Char");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.CHAR), "a"));
         class1.addMember(constructor);
         class1.addMember(method);
@@ -305,14 +303,14 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/Char.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "Char.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Null Test")
-    public void nullTest(){
+    public void nullTest() {
         BlockNode blockCon = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -321,16 +319,102 @@ class AstBuilderTest {
 
         blockCon.addStatement(new AssignNode(assignable, new UnaryNode(new ValueNode(EnumValueNode.NULL_VALUE, "null"))));
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
+        ConstructorNode constructor = new ConstructorNode("public", "Null", blockCon);
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "Null");
-        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
+        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("src/test/resources/input/javaCases/Null.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "Null.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("If Test")
+    public void ifTest() {
+        BlockNode block = new BlockNode();
+        block.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "intValue", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))));
+
+        BlockNode ifBlock = new BlockNode();
+        ifBlock.addStatement(new DecrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
+        block.addStatement(new IfElseNode(new IfNode(new NonCalculationNode(new UnaryNode("intValue"), "==", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))), ifBlock), null));
+
+        block.addStatement(new ReturnNode(null));
+
+        ConstructorNode constructor = new ConstructorNode("public", "If", block);
+
+        ClassNode class1 = new ClassNode("public", "If");
+        class1.addMember(constructor);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST(directoryPath + "If.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("If Else Test")
+    public void ifElseTest() {
+        BlockNode block = new BlockNode();
+        block.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "intValue", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))));
+
+        BlockNode ifBlock = new BlockNode();
+        ifBlock.addStatement(new DecrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
+        BlockNode elseBlock = new BlockNode();
+        elseBlock.addStatement(new IncrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
+        block.addStatement(new IfElseNode(new IfNode(new NonCalculationNode(new UnaryNode("intValue"), "==", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))), ifBlock), new ElseNode(elseBlock)));
+
+        block.addStatement(new ReturnNode(null));
+
+        ConstructorNode constructor = new ConstructorNode("public", "IfElse", block);
+
+        ClassNode class1 = new ClassNode("public", "IfElse");
+        class1.addMember(constructor);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST(directoryPath + "IfElse.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("If Else If ElseTest")
+    public void ifElseIfElseTest() {
+        BlockNode block = new BlockNode();
+        block.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "intValue", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))));
+
+        BlockNode ifBlock = new BlockNode();
+        ifBlock.addStatement(new DecrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
+        BlockNode elseBlock = new BlockNode();
+        elseBlock.addStatement(new IncrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
+
+        IfElseNode ifElseStatement = new IfElseNode(new IfNode(new NonCalculationNode(new UnaryNode("intValue"), "==", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "5"))), ifBlock), new ElseNode(elseBlock));
+
+        BlockNode ifElseBlock = new BlockNode();
+        ifElseBlock.addStatement(new IncrementNode(CrementType.SUFFIX, new AssignableNode("intValue")));
+        ifElseStatement.addElseIfStatement(new IfNode(new NonCalculationNode(new UnaryNode("intValue"), "==", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "4"))), ifElseBlock));
+
+        block.addStatement(ifElseStatement);
+
+        block.addStatement(new ReturnNode(null));
+
+        ConstructorNode constructor = new ConstructorNode("public", "IfElseIfElse", block);
+
+        ClassNode class1 = new ClassNode("public", "IfElseIfElse");
+        class1.addMember(constructor);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST(directoryPath + "IfElseIfElse.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
@@ -339,9 +423,9 @@ class AstBuilderTest {
     @DisplayName("Self Reference Test")
     public void selfReferneceTest(){
 
-        ClassNode testClass = Helper.generateEmptyClass("TestClass");
+        ClassNode testClass = Helper.generateEmptyClass("SelfReference");
 
-        MemberNode testClassObject = new FieldNode(new AccessModifierNode("public"), new ReferenceType("TestClass"),"testClass");
+        MemberNode testClassObject = new FieldNode(new AccessModifierNode("public"), new ReferenceType("SelfReference"),"selfReference");
 
         BlockNode testMethod1Block = new BlockNode();
         testMethod1Block.addStatement(new ReturnNode(new UnaryNode(new MethodCallNode(new TargetNode(true), "testMethod2"))));
@@ -352,10 +436,10 @@ class AstBuilderTest {
         MethodNode testMethod2 = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod2", testMethod2Block);
 
         BlockNode testMethod3Block = new BlockNode();
-        testMethod3Block.addStatement(new LocalVariableDeclarationNode(new ReferenceType("TestClass"),"testClass1", "=", new UnaryNode(new NewDeclarationNode("TestClass")))); // Assing einfach "=" ?
+        testMethod3Block.addStatement(new LocalVariableDeclarationNode(new ReferenceType("SelfReference"),"selfReference1", "=", new UnaryNode(new NewDeclarationNode("SelfReference")))); // Assing einfach "=" ?
         MemberAccessNode methodAccess = new MemberAccessNode(false);
-        methodAccess.addIdentifier("testClass1");
+        methodAccess.addIdentifier("selfReference1");
-        methodAccess.addIdentifier("testClass");
+        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);
@@ -368,7 +452,7 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(testClass);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/SelfReference.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "SelfReference.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
@@ -376,7 +460,7 @@ class AstBuilderTest {
     @Test
     @DisplayName("Variable Compare Test")
     public void variableCompareTest(){
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("VariableCompare");
         UnaryNode trueValue = new UnaryNode(new ValueNode(EnumValueNode.BOOLEAN_VALUE,"true"));
         UnaryNode falseValue = new UnaryNode(new ValueNode(EnumValueNode.BOOLEAN_VALUE,"false"));
 
@@ -419,7 +503,7 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/variableCompare.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "VariableCompare.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
@@ -427,34 +511,34 @@ class AstBuilderTest {
     @Test
     @DisplayName("Variable Calculation Test")
     public void variableCalculationTest(){
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("VariableCalculation");
 
         BlockNode aPlusBBlock = new BlockNode();
-        aPlusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubstractionNode("a"))), "+", new DotNode(new DotSubstractionNode("b")))));
+        aPlusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubtractionNode("a"))), "+", new DotNode(new DotSubtractionNode("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 DotSubstractionNode("a"))), "-", new DotNode(new DotSubstractionNode("b")))));
+        aMinusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubtractionNode("a"))), "-", new DotNode(new DotSubtractionNode("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 DotSubstractionNode("a")), "*", new DotSubstractionNode("b")))));
+        aTimeBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubtractionNode("a")), "*", new DotSubtractionNode("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 DotSubstractionNode("a")), "/", new DotSubstractionNode("b")))));
+        aDivBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubtractionNode("a")), "/", new DotSubtractionNode("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 DotSubstractionNode("a")), "*", new DotSubstractionNode("b")), "/", new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, "1"))), "*", new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, "3"))))));
+        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"))))));
         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"));
@@ -489,7 +573,7 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/variableCalculation.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "VariableCalculation.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
@@ -497,7 +581,7 @@ class AstBuilderTest {
     @Test
     @DisplayName("Main Method Test")
     public void mainMethodTest(){
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("MainMethod");
 
         BlockNode block = new BlockNode();
         block.addStatement(new ReturnNode(null));
@@ -507,7 +591,7 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/MainMethod.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "MainMethod.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
@@ -528,13 +612,13 @@ class AstBuilderTest {
         blockCon.addStatement(new ReturnNode(null));
         ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "While");
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/While.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "While.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
@@ -559,13 +643,13 @@ class AstBuilderTest {
         blockCon.addStatement(new ReturnNode(null));
         ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "DoWhile");
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/DoWhile.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "DoWhile.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
@@ -595,13 +679,13 @@ class AstBuilderTest {
         blockCon.addStatement(new ReturnNode(null));
         ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "For");
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/For.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "For.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }

src/test/java/parser/Helper.java

@@ -2,12 +2,10 @@ 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;
@@ -39,7 +37,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

@@ -1,138 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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/EndToTypedAstTest.java

@@ -26,6 +26,8 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import org.junit.jupiter.api.Test;
+import semantic.exceptions.*;
+import semantic.exceptions.NotDeclaredException;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -38,17 +40,14 @@ public class EndToTypedAstTest {
 
         CharStream codeCharStream = null;
         try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/input/typedAstFeaturesTests/CorrectTest.java"));
+            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/input/typedAstFeatureTests/CorrectTest.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
+        ParseTree parseTree = parser.program();
-
-        /* ------------------------- AST builder -> AST ------------------------- */
         ASTBuilder astBuilder = new ASTBuilder();
         ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
 
@@ -115,7 +114,7 @@ public class EndToTypedAstTest {
 
     @Test
     public void featureTest() {
-        String directoryPath = "src/test/resources/input/typedAstFeaturesTests";
+        String directoryPath = "src/test/resources/input/typedAstFeatureTests";
         File folder = new File(directoryPath);
         if (folder.isDirectory()) {
             File[] files = folder.listFiles((_, name) -> name.endsWith(".java"));
@@ -155,6 +154,200 @@ public class EndToTypedAstTest {
         }
     }
 
+    /*
+    @Test
+    public void notDeclared() {
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/johnsTests/NotDeclared.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof NotDeclaredException));
+    }*/
+
+    @Test
+    public void typeMismatchTest() {
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/TypeMismatchIntBool.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof TypeMismatchException));
+    }
+
+    @Test
+    public void parameterAlreadyDecleared() {
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/ParameterAlreadyDecleared.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof AlreadyDeclaredException));
+    }
+
+    @Test
+    public void fieldAlreadyDecleared(){
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/FieldAlreadyDecleared.java");
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof AlreadyDeclaredException));
+
+    }
+
+    @Test
+    public void typeMismatchRefType(){
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/TypeMismatchRefType.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof TypeMismatchException));
+    }
+
+    @Test
+    public void correctRetType(){
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/CorrectRetType.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+    }
+
+    @Test
+    public void retTypeMismatch(){
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/RetTypeMismatch.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof TypeMismatchException));
+    }
+
+    @Test
+    public void multipleRetType(){
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/MultipleRetTypes.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof MultipleReturnTypes));
+    }
+
+    @Test
+    public void BothTypesMustBeSameGreaterSmallerEqual(){
+
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/BothTypesMustBeSame.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof TypeMismatchException));
+
+    }
+
+    @Test
+    public void NoSuchType(){
+
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/ClassNotDeclared.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof NotDeclaredException));
+
+    }
+
+    @Test
+    public void FieldIsNotVisible(){
+
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/FieldIsNotVisible.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof NotVisibleException));
+
+    }
+
+    @Test
+    public void ChainedMethods(){
+
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/singleFeatureSemanticTests/ChainedMethods.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+
+    }
+
+    @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

@@ -0,0 +1,35 @@
+package semantic;
+
+import ast.ASTNode;
+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 parser.astBuilder.ASTBuilder;
+import parser.generated.SimpleJavaLexer;
+import parser.generated.SimpleJavaParser;
+
+import java.io.IOException;
+
+public class SemanticHelper {
+    public static ASTNode generateTypedASTFrom(String filePath) {
+
+        SemanticAnalyzer.clearAnalyzer();
+
+        CharStream testFile = null;
+        try {
+            testFile = CharStreams.fromFileName(filePath);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        SimpleJavaLexer lexer = new SimpleJavaLexer(testFile);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+        tokenStream.fill();
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTree = parser.program();
+        ASTBuilder astBuilder = new ASTBuilder();
+
+        return astBuilder.visit(parseTree);
+    }
+}

src/test/java/semantic/SemanticTest.java

@@ -1,113 +1,441 @@
 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();
+    }
 
-    public void test(){
+    @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("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 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("Self Reference Test")
+    public void selfReferenceTest() {
 
     }
 
-    public void test(int a, boolean b){
+    @Test
+    @DisplayName("Variable Compare Test")
+    public void variableCompareTest() {
 
     }
 
-    public void test(boolean b, int a){
+    @Test
+    @DisplayName("Variable Calculation Test")
+    public void variableCalculationTest() {
 
     }
 
-//    @Test
+    @Test
-//    public void alreadyDeclaredLocalFieldVar() {
+    @DisplayName("Main Method Test")
-//        ProgramNode programNode = new ProgramNode();
+    public void mainMethodTest() {
-//        List<ClassNode> classList = new ArrayList<>();
+
-//        AccessTypeNode accessTypeNode = new AccessTypeNode(EnumAccessTypeNode.PUBLIC);
+    }
-//        ClassNode classNode = new ClassNode(accessTypeNode, "testClass");
+
-//
+    @Test
-//        SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
+    @DisplayName("While Test")
-//        ASTNode tast = semanticAnalyzer.generateTast(ast);
+    public void whileTest() {
-//
+
-//        MemberNode memberNode2 = new FieldNode(accessTypeNode, new BaseTypeNode(EnumTypeNode.INT), "testVar");
+    }
-//        classNode.members.add(memberNode2);
+
-//
+    @Test
-//        classList.add(classNode);
+    @DisplayName("Do While Test")
-//        programNode.classes = classList;
+    public void doWhileTest() {
-//
+
-//        ASTNode typedAst = SemanticAnalyzer.generateTast(programNode);
+    }
-//
+
-//        assertEquals(1, SemanticAnalyzer.errors.size());
+    @Test
-//        assertInstanceOf(AlreadyDeclaredException.class, SemanticAnalyzer.errors.getFirst());
+    @DisplayName("For Test")
-//        assertNull(typedAst);
+    public void forTest() {
-//    }
+
-//
+    }
-//    @Test
+
-//    public void shouldWorkWithNoError() {
+    @Test
-//        ProgramNode programNode = new ProgramNode();
+    @DisplayName("Increment Test")
-//        List<ClassNode> classList = new ArrayList<>();
+    public void incrementTest() {
-//        AccessTypeNode accessTypeNode = new AccessTypeNode(EnumAccessTypeNode.PUBLIC);
+        ClassNode classNode = Helper.generateEmptyClass("Increment");
-//        ClassNode classNode = new ClassNode(accessTypeNode, "testClass");
+        classNode.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
-//
+
-//        SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
+        ProgramNode abstractSyntaxTree = new ProgramNode();
-//        ASTNode tast = semanticAnalyzer.generateTast(ast);
+        abstractSyntaxTree.addClass(classNode);
-//
+
-//        assertEquals(semanticAnalyzer.errors.size(), 0);
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-//        assertNotNull(tast);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
-//
+            runtimeException.printStackTrace();
-//        MemberNode memberNode3 = getMemberNode(accessTypeNode);
+        }
-//        classNode.members.add(memberNode3);
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
-//
+        assertNotNull(typedAst);
-//        classList.add(classNode);
+    }
-//        programNode.classes = classList;
+}
-//
-//        ASTNode typedAst = SemanticAnalyzer.generateTast(programNode);
-//
-//        assertEquals(0, SemanticAnalyzer.errors.size());
-//        assertEquals(programNode, typedAst);
-//    }
-//
-//    /**
-// * This method is used to create a MemberNode representing a method.
-// * It first creates a list of ParameterNodes and adds a ParameterNode to it.
-// * Then, it creates a ParameterListNode using the list of ParameterNodes.
-// * After that, it creates a list of StatementNodes and adds a StatementNode to it by calling the getStatementNode method.
-// * Finally, it creates a MethodNode using the provided AccessTypeNode, a BaseTypeNode representing the return type of the method,
-// * the method name, the ParameterListNode, and the list of StatementNodes, and returns this MethodNode.
-// *
-// * @param accessTypeNode The AccessTypeNode representing the access type of the method.
-// * @return The created MemberNode representing the method.
-// */
-//private static MemberNode getMemberNode(AccessTypeNode accessTypeNode) {
-//    List<ParameterNode> parameterNodeList = new ArrayList<>();
-//    ParameterNode parameterNode1 = new ParameterNode(new BaseTypeNode(EnumTypeNode.INT), "param1");
-//    parameterNodeList.add(parameterNode1);
-//    ParameterListNode parameterListNode = new ParameterListNode(parameterNodeList);
-//
-//    List<StatementNode> statementNodeList = new ArrayList<>();
-//
-//    StatementNode statementNode1 = getStatementNode();
-//    statementNodeList.add(statementNode1);
-//
-//    return new MethodNode(accessTypeNode, new BaseTypeNode(EnumTypeNode.INT), "testVar2", parameterListNode, statementNodeList);
-//}
-//
-//    /**
-// * This method is used to create a StatementNode for an assignment operation.
-// * It first creates two IdentifierExpressionNodes for 'this' and 'objectVar'.
-// * Then, it creates a BinaryExpressionNode to represent the operation 'this.objectVar'.
-// * After that, it creates a LiteralNode to represent the integer value 1.
-// * Finally, it creates another BinaryExpressionNode to represent the assignment operation 'this.objectVar = 1',
-// * and wraps this expression in an AssignmentStatementNode.
-// *
-// * @return The created AssignmentStatementNode representing the assignment operation 'this.objectVar = 1'.
-// */
-//private static StatementNode getStatementNode() {
-//    ExpressionNode expressionNodeObjectVariableLeft = new IdentifierExpressionNode("this");
-//    ExpressionNode expressionNodeObjectVariableRight = new IdentifierExpressionNode("objectVar");
-//
-//    ExpressionNode expressionNodeLeft = new BinaryExpressionNode(expressionNodeObjectVariableLeft, expressionNodeObjectVariableRight, ExpresssionOperator.DOT);
-//
-//    ExpressionNode expressionNodeRight = new LiteralNode(1);
-//
-//    BinaryExpressionNode expressionNode = new BinaryExpressionNode(expressionNodeLeft, expressionNodeRight, ExpresssionOperator.ASSIGNMENT);
-//
-//    return new AssignmentStatementNode(expressionNode);
-//}
-}

src/test/resources/input/CombinedExample.java

@@ -1,23 +0,0 @@
-public class CombinedExample {
-    int number;
-    boolean flag;
-    char letter;
-
-    public CombinedExample(int number, boolean flag, char letter) {
-        this.number = number;
-        this.flag = flag;
-        this.letter = letter;
-    }
-
-    public void displayValues() {
-        System.out.println("Number: " + number);
-        System.out.println("Flag: " + flag);
-        System.out.println("Letter: " + letter);
-    }
-
-    public static void main(String[] args) {
-        CombinedExample obj = new CombinedExample(10, true, 'X');
-        obj.displayValues();
-    }
-}
-

src/test/resources/input/CompilerInput.java

@@ -1,16 +0,0 @@
-public class CompilerInput {
-
-    public int a;
-
-    public static int testMethod(char x){
-        return 0;
-    }
-
-    public class Test {
-
-        public static int testMethod(char x, int a){
-            return 0;
-        }
-    }
-}
-

src/test/resources/input/MoreFeaturesClassExample.java

@@ -1,6 +0,0 @@
-public class MoreFeaturesClassExample {
-    int hallo;
-    private class Inner {
-        int hallo2;
-    }
-}

src/test/resources/input/combinedFeatureTests/AllFeaturesClassExample.java

@@ -4,7 +4,7 @@ public class AllFeaturesClassExample {
     char c;
 
     // Konstruktor
-    AllFeaturesClassExample(int a, boolean b, char c) {
+    public AllFeaturesClassExample(int a, boolean b, char c) {
         this.a = a;
         this.b = b;
         this.c = c;
@@ -14,47 +14,54 @@ public class AllFeaturesClassExample {
     void controlStructures() {
         // if-else Anweisung
         if (a > 10) {
-           // System.out.println("a ist größer als 10");
         } else {
-           // System.out.println("a ist nicht größer als 10");
         }
 
         // while Schleife
         while (a > 0) {
-          //  System.out.println("a ist " + a);
             a--;
         }
-
+        int c = 0;
         // for Schleife
         for (int i = 0; i < 5; i++) {
-           // System.out.println("for Schleife Iteration: " + i);
+            c++;
         }
+
     }
 
     // Methode zur Arbeit mit logischen Operatoren
     void logicalOperations() {
         // Logische UND-Operation
         if (b && a > 5) {
-          //  System.out.println("a ist größer als 5 und b ist wahr");
         }
 
         // Logische ODER-Operation
         if (b || a < 5) {
-           // System.out.println("b ist wahr oder a ist kleiner als 5");
         }
     }
 
-    void mathOperations() {
+    int add(int a, int b) {
-        // Addition
+        return a + b;
-        int sum = a + 5;
+    }
-        // Subtraktion
+
-        int difference = a - 5;
+    int subtract(int a, int b) {
-        // Multiplikation
+        return a - b;
-        int product = a * 5;
+    }
-        // Division
+
-        int quotient = a / 5;
+    int multiply(int a, int b) {
-        // Modulo
+        return a * b;
-        int remainder = a % 5;
+    }
+
+    int divide(int a, int b) {
+        return a / b;
+    }
+
+    int modulo(int a, int b) {
+        return a % b;
+    }
+
+    boolean greaterThan(int a, int b) {
+        return a > b;
     }
 
     public static void main(String[] args) {

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);
+    }
+}