Merge branch 'main' of https://gitea.hb.dhbw-stuttgart.de/i22005/NichtHaskell2.0 into parser

 Conflicts:

	.idea/misc.xml

	src/main/java/Main.java

	src/main/java/ast/expression/ExpressionNode.java

	src/main/java/ast/member/ConstructorNode.java

	src/main/java/ast/member/FieldNode.java

	src/main/java/ast/member/MemberNode.java

	src/main/java/ast/member/MethodNode.java

	src/main/java/ast/parameter/ParameterNode.java

	src/main/java/ast/statement/AssignmentStatementNode.java

	src/main/java/ast/statement/StatementNode.java

	src/main/java/ast/type/AccessTypeNode.java

	src/main/java/ast/type/TypeNode.java

	src/main/java/bytecode/ClassCodeGen.java

	src/main/java/bytecode/FieldCodeGen.java

	src/main/java/bytecode/Mapper.java

	src/main/java/bytecode/MethodCodeGen.java

	src/main/java/classFileOutput/Example.class

	src/main/java/parser/ASTBuilder.java

	src/main/java/parser/generated/SimpleJava.interp

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

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

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

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

	src/main/java/parser/generated/SimpleJavaParser.java

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

	src/main/java/semantic/SemanticAnalyzer.java

.idea/misc.xml

@@ -6,10 +6,10 @@
         <PerGrammarGenerationSettings>
           <option name="fileName" value="$PROJECT_DIR$/src/main/java/parser/SimpleJava.g4" />
           <option name="autoGen" value="true" />
-          <option name="outputDir" value="C:\Users\Maxi\Documents\DHBW\Compilerbau\NichtHaskell2.0\src\main\java\parser" />
+          <option name="outputDir" value="C:\Users\Johannes\Documents\Github\JavaCompiler\src\main\java" />
           <option name="libDir" value="" />
           <option name="encoding" value="" />
-          <option name="pkg" value="generated" />
+          <option name="pkg" value="parser.generated" />
           <option name="language" value="" />
           <option name="generateVisitor" value="true" />
         </PerGrammarGenerationSettings>
@@ -40,7 +40,7 @@
       </list>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_22" default="true" project-jdk-name="openjdk-22" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="openjdk-21" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

src/main/java/CompilerInput.txt

@@ -1,21 +1,15 @@
 public class Example {
 
-    public int test;
+    public int testVar;
+
+    public static int testMethod(char b){
+
+         int a;
+         boolean b;
+         char c;
+         b = 3;
 
-    public Example(int conInput) {
 
     }
 
-    public static int test(char b){
-
-        test = 3;
-
-    }
-
-}
-
-public class Test {
-
-    public char test;
-
 }

src/main/java/Main.java

@@ -15,11 +15,8 @@ import java.nio.file.Paths;
 
 public class Main {
     public static void main(String[] args) throws Exception {
-
-        CharStream codeCharStream = null;
-
         try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/main/java/CompilerInput.txt"));
+            CharStream codeCharStream = CharStreams.fromPath(Paths.get("src/main/java/CompilerInput.txt"));
             parsefile(codeCharStream);
         } catch (IOException e) {
             System.err.println("Error reading the file: " + e.getMessage());
@@ -28,7 +25,6 @@ public class Main {
 
 
     static void parsefile(CharStream codeCharStream){
-        // CharStream codeCharStream = CharStreams.fromString("class javaFileInput.Example { } class Example2 { }");
         SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
         CommonTokenStream tokens = new CommonTokenStream(lexer);
         SimpleJavaParser parser = new SimpleJavaParser(tokens);
@@ -38,16 +34,9 @@ public class Main {
         ASTBuilder builder = new ASTBuilder();
         ProgramNode ast = (ProgramNode) builder.visit(tree); // build the AST
 
-        // Optionally print or process the AST
-        System.out.println("Parsed " + ast.classes.size() + " classes with identifiers/names:");
-        for (ClassNode classNode : ast.classes) {
-            System.out.println(classNode.identifier.getName());
-        }
-
-        SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
-        semanticAnalyzer.analyze(ast);
+        SemanticAnalyzer.generateTast(ast);
 
         ByteCodeGenerator byteCodeGenerator = new ByteCodeGenerator();
-        byteCodeGenerator.generateByteCode(ast);
+        byteCodeGenerator.visit(ast);
     }
 }

src/main/java/ast/ASTNode.java

@@ -1,8 +1,7 @@
 package ast;
 
-import java.util.ArrayList;
-import java.util.List;
+public interface ASTNode {
 
-public abstract class ASTNode { }
+}
 
 

src/main/java/ast/ClassNode.java

@@ -8,16 +8,20 @@ import ast.type.EnumAccessTypeNode;
 import java.util.ArrayList;
 import java.util.List;
 
-public class ClassNode extends ASTNode{
-    public IdentifierNode identifier;
+import bytecode.visitor.ClassVisitor;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
+import typechecker.Visitable;
+
+public class ClassNode implements ASTNode, Visitable {
+    public String identifier;
     public AccessTypeNode accessType;
-    public String name;
     public List<MemberNode> members = new ArrayList<>();
     public boolean hasConstructor = false;
 
-    public ClassNode(AccessTypeNode accessType, String name){
+    public ClassNode(AccessTypeNode accessType, String identifier){
         this.accessType = accessType;
-        this.name = name;
+        this.identifier = identifier;
     }
 
     public void addMember(MemberNode member) {
@@ -29,8 +33,18 @@ public class ClassNode extends ASTNode{
 
     public void ensureConstructor(){
         if(!hasConstructor) {
-            ConstructorNode constructor = new ConstructorNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), name);
+            ConstructorNode constructor = new ConstructorNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), identifier);
             members.add(0,constructor);
         }
     }
+
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
+
+    @Override
+    public void accept(ClassVisitor classVisitor) {
+        classVisitor.visit(this);
+    }
 }

src/main/java/ast/LiteralNode.java

@@ -0,0 +1,23 @@
+package ast;
+
+import ast.expression.ExpressionNode;
+
+public class LiteralNode extends ExpressionNode {
+
+  int value;
+  private String type;
+
+  public LiteralNode(int value) {
+    this.value = value;
+  }
+
+  public String getType() {
+    return type;
+  }
+
+  public void setType(String type) {
+    this.type = type;
+  }
+
+
+}

src/main/java/ast/ProgramNode.java

@@ -3,10 +3,25 @@ package ast;
 import java.util.ArrayList;
 import java.util.List;
 
-public class ProgramNode extends ASTNode {
+import bytecode.visitor.ProgramVisitor;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
+import typechecker.Visitable;
+
+public class ProgramNode implements ASTNode, Visitable{
     public List<ClassNode> classes = new ArrayList<>();
 
     public void addClass(ClassNode classNode) {
         classes.add(classNode);
     }
+
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
+
+    @Override
+    public void accept(ProgramVisitor programVisitor) {
+        programVisitor.visit(this);
+    }
 }

src/main/java/ast/VarNode.java

@@ -0,0 +1,21 @@
+package ast;
+
+public class VarNode implements ASTNode{
+
+  private String identifier;
+  private String type;
+
+  public VarNode(String type, String identifier){
+    this.type = type;
+    this.identifier = identifier;
+  }
+
+  public String getType(){
+    return type;
+  }
+
+  public String getIdentifier(){
+    return identifier;
+  }
+
+}

src/main/java/ast/expression/ExpressionNode.java

@@ -2,6 +2,8 @@ package ast.expression;
 
 import ast.ASTNode;
 
-public class ExpressionNode extends ASTNode {
+public class ExpressionNode implements ASTNode {
+
+
 
 }

src/main/java/ast/member/ConstructorNode.java

@@ -1,9 +1,16 @@
 package ast.member;
 
 import ast.type.AccessTypeNode;
+import bytecode.visitor.MethodVisitor;
+import typechecker.Visitable;
 
-public class ConstructorNode extends MethodNode {
+public class ConstructorNode extends MethodNode implements Visitable {
     public ConstructorNode(AccessTypeNode visibility, String name) {
         super(visibility, name);
     }
+
+    @Override
+    public void accept(MethodVisitor methodVisitor) {
+        methodVisitor.visit(this);
+    }
 }

src/main/java/ast/member/FieldNode.java

@@ -1,18 +1,30 @@
 package ast.member;
 
-import ast.IdentifierNode;
 import ast.type.AccessTypeNode;
 import ast.type.TypeNode;
+import bytecode.visitor.ClassVisitor;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
+import typechecker.Visitable;
 
-public class FieldNode extends MemberNode {
+public class FieldNode implements MemberNode, Visitable {
     public AccessTypeNode accessTypeNode;
     public TypeNode type;
-    public IdentifierNode identifier;
+    public String identifier;
 
     public FieldNode(AccessTypeNode accessTypeNode, TypeNode type, String name){
         this.accessTypeNode = accessTypeNode;
         this.type = type;
-        this.identifier = new IdentifierNode(name);
+        this.identifier = name;
     }
 
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
+
+    @Override
+    public void accept(ClassVisitor classVisitor) {
+        classVisitor.visit(this);
+    }
 }

src/main/java/ast/member/MemberNode.java

@@ -2,5 +2,5 @@ package ast.member;
 
 import ast.ASTNode;
 
-public class MemberNode extends ASTNode {
+public interface MemberNode extends ASTNode {
 }

src/main/java/ast/member/MethodNode.java

@@ -1,6 +1,5 @@
 package ast.member;
 
-import ast.IdentifierNode;
 import ast.parameter.ParameterListNode;
 import ast.statement.StatementNode;
 import ast.type.AccessTypeNode;
@@ -9,28 +8,41 @@ import ast.type.TypeNode;
 import java.util.ArrayList;
 import java.util.List;
 
-public class MethodNode extends MemberNode {
-    public IdentifierNode identifier;
+import bytecode.visitor.MethodVisitor;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
+import typechecker.Visitable;
+
+public class MethodNode implements MemberNode, Visitable {
     public AccessTypeNode visibility;
     public TypeNode type;
-    public String name;
+    public String identifier;
 
     public ParameterListNode parameters;
 
     public List<StatementNode> statements = new ArrayList<>();
 
-    public MethodNode(AccessTypeNode visibility, TypeNode type, String name, ParameterListNode parameters,
+    public MethodNode(AccessTypeNode visibility, TypeNode type, String identifier, ParameterListNode parameters,
                       List<StatementNode> statements){
         this.visibility = visibility;
-        this.identifier = new IdentifierNode(name);
         this.type = type;
-        this.name = name;
+        this.identifier = identifier;
         this.parameters = parameters;
         this.statements = statements;
     }
 
-    public MethodNode(AccessTypeNode visibility, String name){
+    public MethodNode(AccessTypeNode visibility, String identifier){
         this.visibility = visibility;
-        this.identifier = new IdentifierNode(name);
+        this.identifier = identifier;
+    }
+
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
+
+    @Override
+    public void accept(MethodVisitor methodVisitor) {
+        methodVisitor.visit(this);
     }
 }

src/main/java/ast/parameter/ParameterListNode.java

@@ -5,7 +5,7 @@ import ast.ASTNode;
 import java.util.ArrayList;
 import java.util.List;
 
-public class ParameterListNode extends ASTNode {
+public class ParameterListNode implements ASTNode {
     List<ParameterNode> parameters = new ArrayList<>();
 
     public ParameterListNode(List<ParameterNode> parameters){

src/main/java/ast/parameter/ParameterNode.java

@@ -3,7 +3,7 @@ package ast.parameter;
 import ast.ASTNode;
 import ast.type.TypeNode;
 
-public class ParameterNode extends ASTNode {
+public class ParameterNode implements ASTNode {
     public TypeNode type;
     public String identifier;
 

src/main/java/ast/statement/AssignmentStatementNode.java

@@ -1,13 +1,22 @@
 package ast.statement;
 
+import ast.VarNode;
 import ast.expression.ExpressionNode;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
+import typechecker.Visitable;
 
-public class AssignmentStatementNode extends StatementNode {
-  public String identifier;
+public class AssignmentStatementNode extends StatementNode implements Visitable {
+  public VarNode varNode;
   public ExpressionNode expression;
 
-  public AssignmentStatementNode(String identifier, ExpressionNode expression) {
-    this.identifier = identifier;
+  public AssignmentStatementNode(VarNode varNode, ExpressionNode expression) {
+    this.varNode = varNode;
     this.expression = expression;
   }
+
+  @Override
+  public TypeCheckResult accept(SemanticVisitor visitor) {
+    return visitor.analyze(this);
+  }
 }

src/main/java/ast/statement/StatementNode.java

@@ -2,6 +2,6 @@ package ast.statement;
 
 import ast.ASTNode;
 
-public abstract class StatementNode extends ASTNode {
+public abstract class StatementNode implements ASTNode {
 }
 

src/main/java/ast/type/AccessTypeNode.java

@@ -2,7 +2,7 @@ package ast.type;
 
 import ast.ASTNode;
 
-public class AccessTypeNode extends ASTNode {
+public class AccessTypeNode implements ASTNode {
     public EnumAccessTypeNode enumAccessTypeNode;
 
     public AccessTypeNode(EnumAccessTypeNode enumAccessTypeNode) {

src/main/java/ast/type/BaseTypeNode.java

@@ -0,0 +1,11 @@
+package ast.type;
+
+public class BaseTypeNode implements TypeNode{
+
+    public EnumTypeNode enumType;
+
+    public BaseTypeNode(EnumTypeNode enumType) {
+        this.enumType = enumType;
+    }
+
+}

src/main/java/ast/type/ReferenceTypeNode.java

@@ -0,0 +1,4 @@
+package ast.type;
+
+public class ReferenceTypeNode implements TypeNode{
+}

src/main/java/ast/type/TypeNode.java

@@ -2,10 +2,5 @@ package ast.type;
 
 import ast.ASTNode;
 
-public class TypeNode extends ASTNode {
-    public EnumTypeNode enumTypeNode;
-
-    public TypeNode(EnumTypeNode enumTypeNode) {
-        this.enumTypeNode = enumTypeNode;
-    }
+public interface TypeNode extends ASTNode {
 }

src/main/java/bytecode/ByteCodeGenerator.java

@@ -2,13 +2,15 @@ package bytecode;
 
 import ast.ProgramNode;
 import ast.ClassNode;
+import bytecode.visitor.ProgramVisitor;
 
-public class ByteCodeGenerator {
+public class ByteCodeGenerator implements ProgramVisitor {
 
-  public void generateByteCode(ProgramNode ast) {
-    for (ClassNode classDeclarationNode : ast.classes) {
+  @Override
+  public void visit(ProgramNode programNode) {
+    for (ClassNode classDeclarationNode : programNode.classes) {
       ClassCodeGen classCodeGen = new ClassCodeGen();
-      classCodeGen.generateClassCode(classDeclarationNode);
+      classDeclarationNode.accept(classCodeGen);
     }
   }
 }

src/main/java/bytecode/ClassCodeGen.java

@@ -4,6 +4,7 @@ import ast.ClassNode;
 import ast.member.FieldNode;
 import ast.member.MemberNode;
 import ast.member.MethodNode;
+import bytecode.visitor.ClassVisitor;
 import java.io.File;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
@@ -11,29 +12,37 @@ import org.objectweb.asm.Opcodes;
 import java.io.FileOutputStream;
 import java.io.IOException;
 
-public class ClassCodeGen {
-    public void generateClassCode(ClassNode classNode) {
-        ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
-        Mapper mapper = new Mapper();
-        classWriter.visit(Opcodes.V1_8, mapper.mapAccesTypeToOpcode(classNode.accessType), classNode.name, null,
+public class ClassCodeGen implements ClassVisitor {
+    Mapper mapper = new Mapper();
+    ClassWriter classWriter;
+
+    @Override
+    public void visit(ClassNode classNode) {
+        classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
+        classWriter.visit(Opcodes.V1_8, mapper.mapAccesTypeToOpcode(classNode.accessType), classNode.identifier, null,
                 "java/lang/Object", null);
 
         for (MemberNode memberNode : classNode.members) {
             if (memberNode instanceof FieldNode) {
-                FieldCodeGen fieldCodeGen = new FieldCodeGen();
-                fieldCodeGen.generateFieldCode(classWriter, (FieldNode) memberNode);
+                visit((FieldNode) memberNode);
             } else if (memberNode instanceof MethodNode) {
-                MethodCodeGen methodCodeGen = new MethodCodeGen();
-                methodCodeGen.generateMethodCode(classWriter, (MethodNode) memberNode);
+                MethodCodeGen methodCodeGen = new MethodCodeGen(classWriter);
+                ((MethodNode) memberNode).accept(methodCodeGen);
             }
         }
 
         classWriter.visitEnd();
-        printIntoClassFile(classWriter.toByteArray(), classNode.identifier.getName());
+        printIntoClassFile(classWriter.toByteArray(), classNode.identifier);
 
         classWriter.visitEnd();
     }
 
+    @Override
+    public void visit(FieldNode fieldNode) {
+        classWriter.visitField(mapper.mapAccesTypeToOpcode(fieldNode.accessTypeNode), fieldNode.identifier, mapper.getTypeChar(fieldNode.type.enumTypeNode), null, null );
+        classWriter.visitEnd();
+    }
+
     private void printIntoClassFile(byte[] byteCode, String name) {
         String directoryPath = "src/main/java/classFileOutput";
         File directory = new File(directoryPath);

src/main/java/bytecode/FieldCodeGen.java

@@ -8,6 +8,6 @@ public class FieldCodeGen {
 
     public void generateFieldCode(ClassWriter classWriter, FieldNode fieldNode) {
         Mapper mapper = new Mapper();
-        FieldVisitor fieldVisitor = classWriter.visitField(mapper.mapAccesTypeToOpcode(fieldNode.accessTypeNode), fieldNode.identifier.getName(), "", null, null);
+        FieldVisitor fieldVisitor = classWriter.visitField(mapper.mapAccesTypeToOpcode(fieldNode.accessTypeNode), fieldNode.identifier, "", null, null);
     }
 }

src/main/java/bytecode/Mapper.java

@@ -2,6 +2,8 @@ package bytecode;
 
 import ast.type.AccessTypeNode;
 import ast.type.EnumAccessTypeNode;
+import ast.type.EnumTypeNode;
+import ast.type.TypeNode;
 import org.objectweb.asm.Opcodes;
 
 public class Mapper {
@@ -14,4 +16,26 @@ public class Mapper {
         }
         return 0;
     }
+
+    public String generateMethodDescriptor(TypeNode typeNode) {
+        String descriptor = "()";
+        descriptor += getTypeChar(typeNode.enumTypeNode);
+        return descriptor;
+    }
+
+    public String getTypeChar(EnumTypeNode enumTypeNode) {
+        String typeChar = "";
+        switch (enumTypeNode) {
+            case EnumTypeNode.INT:
+                typeChar = "I";
+                break;
+            case EnumTypeNode.CHAR:
+                typeChar = "C";
+                break;
+            case EnumTypeNode.BOOLEAN:
+                typeChar = "Z";
+                break;
+        }
+        return typeChar;
+    }
 }

src/main/java/bytecode/MethodCodeGen.java

@@ -1,17 +1,38 @@
 package bytecode;
 
+import ast.member.ConstructorNode;
 import ast.member.MethodNode;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.MethodVisitor;
 
-public class MethodCodeGen {
-    public void generateMethodCode(ClassWriter classWriter, MethodNode methodNode) {
-        Mapper mapper = new Mapper();
+public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
+
+    private ClassWriter classWriter;
+    Mapper mapper = new Mapper();
+
+    public MethodCodeGen(ClassWriter classWriter) {
+        this.classWriter = classWriter;
+    }
+
+    @Override
+    public void visit(ConstructorNode constructorNode) {
         MethodVisitor constructor =
-                classWriter.visitMethod(mapper.mapAccesTypeToOpcode(methodNode.visibility),
+                classWriter.visitMethod(mapper.mapAccesTypeToOpcode(constructorNode.visibility),
                         "<init>",
                         "()V",
                         null,
                         null);
+        constructor.visitEnd();
+    }
+
+    @Override
+    public void visit(MethodNode methodNode) {
+        MethodVisitor method = classWriter.visitMethod(mapper.mapAccesTypeToOpcode(methodNode.visibility),
+                methodNode.identifier,
+                mapper.generateMethodDescriptor(methodNode.type),
+                null,
+                null);
+
+        method.visitEnd();
     }
 }

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

@@ -0,0 +1,10 @@
+package bytecode.visitor;
+
+import ast.ClassNode;
+import ast.member.FieldNode;
+import org.objectweb.asm.ClassWriter;
+
+public interface ClassVisitor {
+  void visit(ClassNode classNode);
+  void visit(FieldNode fieldNode);
+}

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

@@ -0,0 +1,9 @@
+package bytecode.visitor;
+
+import ast.member.ConstructorNode;
+import ast.member.MethodNode;
+
+public interface MethodVisitor {
+    void visit(ConstructorNode constructorNode);
+    void visit(MethodNode methodNode);
+}

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

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

src/main/java/parser/ASTBuilder.java

@@ -11,16 +11,12 @@ import ast.member.MethodNode;
 import ast.parameter.ParameterListNode;
 import ast.parameter.ParameterNode;
 import ast.statement.*;
-import ast.type.AccessTypeNode;
-import ast.type.EnumAccessTypeNode;
-import ast.type.EnumTypeNode;
-import ast.type.TypeNode;
+import ast.type.*;
 import org.antlr.v4.runtime.tree.TerminalNode;
-import parser.generated.SimpleJavaBaseVisitor;
-import parser.generated.SimpleJavaParser;
-
 import java.util.ArrayList;
 import java.util.List;
+import parser.generated.*;
+import parser.generated.SimpleJavaParser.LiteralContext;
 
 public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
     @Override
@@ -35,7 +31,7 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
     @Override
     public ASTNode visitClassDeclaration(SimpleJavaParser.ClassDeclarationContext ctx) {
         ClassNode classNode = new ClassNode((AccessTypeNode) visit(ctx.accessType()),ctx.IDENTIFIER().getText());
-        classNode.identifier = new IdentifierNode(ctx.IDENTIFIER().getText());
+        classNode.identifier = ctx.IDENTIFIER().getText();
         for (SimpleJavaParser.MemberDeclarationContext member : ctx.memberDeclaration()) {
             classNode.addMember((MemberNode) visit(member));
         }
@@ -88,11 +84,11 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
         String typeStr = ctx.getText();
         switch (typeStr) {
             case "int":
-                return new TypeNode(EnumTypeNode.INT);
+                return new BaseTypeNode(EnumTypeNode.INT);
             case "boolean":
-                return new TypeNode(EnumTypeNode.BOOLEAN);
+                return new BaseTypeNode(EnumTypeNode.BOOLEAN);
             case "char":
-                return new TypeNode(EnumTypeNode.CHAR);
+                return new BaseTypeNode(EnumTypeNode.CHAR);
             default:
                 throw new IllegalArgumentException("Unsupported type: " + typeStr);
         }
@@ -135,9 +131,14 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
     @Override
     public ASTNode visitAssignmentStatement(SimpleJavaParser.AssignmentStatementContext ctx) {
-        String identifier = ctx.IDENTIFIER().getText();
+        VarNode varNode = (VarNode) visit(ctx.var());
         ExpressionNode expression = (ExpressionNode) visit(ctx.expression());
-        return new AssignmentStatementNode(identifier, expression);
+        return new AssignmentStatementNode(varNode, expression);
+    }
+
+    @Override
+    public ASTNode visitVar(SimpleJavaParser.VarContext ctx) {
+        return new VarNode("int", ctx.getText());
     }
 
     @Override
@@ -196,4 +197,18 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
         return null;  // Return null or throw an exception if no valid expression found
     }
+
+    @Override
+    public ASTNode visitLiteral(SimpleJavaParser.LiteralContext ctx) {
+        LiteralContext literalContext = (LiteralContext) ctx;
+        try {
+            int intValue = Integer.parseInt(literalContext.getText());
+            LiteralNode literalNode = new LiteralNode(intValue);
+            literalNode.setType("int");
+            return literalNode;
+        } catch (NumberFormatException ignored) {}
+
+        return null;  // Return null or throw an exception if no valid expression found
+    }
+
 }

src/main/java/parser/SimpleJava.g4

@@ -29,7 +29,9 @@ statement
 
 variableDeclarationStatement : type IDENTIFIER ('=' expression)? ';' ;
 
-assignmentStatement : IDENTIFIER '=' expression ';' ;
+assignmentStatement : var '=' expression ';' ;
+
+var: IDENTIFIER;
 
 ifStatement : 'if' '(' expression ')' statement ('else' statement)? ;
 

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

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/Johannes/Documents/Github/JavaCompiler/src/main/java/parser/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 
 import org.antlr.v4.runtime.ParserRuleContext;
@@ -168,6 +168,18 @@ public class SimpleJavaBaseListener implements SimpleJavaListener {
 	 * <p>The default implementation does nothing.</p>
 	 */
 	@Override public void exitAssignmentStatement(SimpleJavaParser.AssignmentStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterVar(SimpleJavaParser.VarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitVar(SimpleJavaParser.VarContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *

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

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/Johannes/Documents/Github/JavaCompiler/src/main/java/parser/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
 
@@ -103,6 +103,13 @@ public class SimpleJavaBaseVisitor<T> extends AbstractParseTreeVisitor<T> implem
 	 * {@link #visitChildren} on {@code ctx}.</p>
 	 */
 	@Override public T visitAssignmentStatement(SimpleJavaParser.AssignmentStatementContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitVar(SimpleJavaParser.VarContext ctx) { return visitChildren(ctx); }
 	/**
 	 * {@inheritDoc}
 	 *

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

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/Johannes/Documents/Github/JavaCompiler/src/main/java/parser/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/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/Johannes/Documents/Github/JavaCompiler/src/main/java/parser/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 
@@ -137,6 +137,16 @@ public interface SimpleJavaListener extends ParseTreeListener {
 	 * @param ctx the parse tree
 	 */
 	void exitAssignmentStatement(SimpleJavaParser.AssignmentStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link SimpleJavaParser#var}.
+	 * @param ctx the parse tree
+	 */
+	void enterVar(SimpleJavaParser.VarContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link SimpleJavaParser#var}.
+	 * @param ctx the parse tree
+	 */
+	void exitVar(SimpleJavaParser.VarContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link SimpleJavaParser#ifStatement}.
 	 * @param ctx the parse tree

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

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/Johannes/Documents/Github/JavaCompiler/src/main/java/parser/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 
@@ -88,6 +88,12 @@ public interface SimpleJavaVisitor<T> extends ParseTreeVisitor<T> {
 	 * @return the visitor result
 	 */
 	T visitAssignmentStatement(SimpleJavaParser.AssignmentStatementContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link SimpleJavaParser#var}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitVar(SimpleJavaParser.VarContext ctx);
 	/**
 	 * Visit a parse tree produced by {@link SimpleJavaParser#ifStatement}.
 	 * @param ctx the parse tree

src/main/java/semantic/SemanticAnalyzer.java

@@ -2,60 +2,91 @@ package semantic;
 
 
 import ast.*;
+import ast.expression.ExpressionNode;
 import ast.member.ConstructorNode;
 import ast.member.FieldNode;
 import ast.member.MemberNode;
 
+import ast.member.MethodNode;
+import ast.statement.AssignmentStatementNode;
+import ast.statement.StatementNode;
 import java.util.ArrayList;
 import java.util.List;
+import typechecker.TypeCheckResult;
 
-public class SemanticAnalyzer {
+public class SemanticAnalyzer implements SemanticVisitor {
 
-    List<IdentifierNode> usedIdentifier = new ArrayList<>();
+  private ArrayList<String> currentFields = new ArrayList<>();
 
-    public void analyze(ASTNode node) {
-        if (node == null) return;
+  public static ASTNode generateTast(ASTNode node) throws RuntimeException {
+    SemanticAnalyzer semanticCheck = new SemanticAnalyzer();
+    ProgramNode programNode = (ProgramNode) node;
+    var result = programNode.accept(semanticCheck);
+    if (result.isValid()) {
+      return node;
+    } else {
+      throw new RuntimeException("Not Valid");
+    }
+  }
 
-        if (node instanceof ClassNode) {
+  @Override
+  public TypeCheckResult analyze(ProgramNode node) {
 
-            ClassNode classNode = (ClassNode) node;
-            if(classNode.identifier == null){
-                System.out.println("Klasse besitzt keinen Identifier");
-            }
+    var valid = true;
 
-            List<MemberNode> memberNodes = classNode.members;
-            for (MemberNode member: memberNodes) {
-                analyze(member);
-            }
-
-
-        }else if (node instanceof ConstructorNode) {
-
-        }else if (node instanceof FieldNode) {
-
-            FieldNode fieldNode = (FieldNode) node;
-            if(identifierAlreadyUsed(fieldNode.identifier)){
-                //throw new RuntimeException("Error: Identifier already used");
-                System.out.println("Error: Identifier already used");
-            }
-            usedIdentifier.add(fieldNode.identifier);
-
-        }else if (node instanceof ProgramNode) {
-            ProgramNode programNode = (ProgramNode) node;
-            List<ClassNode> classes = programNode.classes;
-            for (ClassNode classNode: classes) {
-                analyze(classNode);
-            }
-        }
+    List<ClassNode> classes = node.classes;
+    for (ClassNode classNode : classes) {
+      classNode.accept(this);
+    }
+    return new TypeCheckResult(valid, null);
+  }
 
+  @Override
+  public TypeCheckResult analyze(ClassNode classNode) {
+    List<MemberNode> members = classNode.members;
+    for (MemberNode memberNode : members) {
+      if (memberNode instanceof FieldNode fieldNode) {
+        fieldNode.accept(this);
+      } else if (memberNode instanceof MethodNode methodNode) {
+        methodNode.accept(this);
+      }
     }
 
-    public boolean identifierAlreadyUsed(IdentifierNode identifier){
-        if(usedIdentifier.contains(identifier)){
-            return true;
-        } else {
-            return false;
-        }
+    return null;
+  }
+
+  @Override
+  public TypeCheckResult analyze(MethodNode methodNode) {
+    List<StatementNode> statements = methodNode.statements;
+    for (StatementNode statement : statements) {
+      if(statement instanceof AssignmentStatementNode assignmentStatementNode) {
+        assignmentStatementNode.accept(this);
+      }
     }
+    return null;
+  }
+
+  @Override
+  public TypeCheckResult analyze(FieldNode toCheck) {
+    if(currentFields.contains(toCheck.identifier)){
+      throw new RuntimeException(toCheck.identifier + " Is Already Declared");
+    }else {
+      currentFields.add(toCheck.identifier);
+    }
+    return null;
+  }
+
+  @Override
+  public TypeCheckResult analyze(AssignmentStatementNode assignmentStatementNode) {
+    if(assignmentStatementNode.expression instanceof LiteralNode literalNode) {
+      VarNode varNode = assignmentStatementNode.varNode;
+      if(varNode.getType().equals(literalNode.getType())) {
+        System.out.println("Type is same");
+      } else {
+        throw new RuntimeException("Type mismatch");
+      }
+    }
+    return null;
+  }
 
 }

src/main/java/semantic/SemanticVisitor.java

@@ -0,0 +1,62 @@
+package semantic;
+
+
+import ast.ClassNode;
+import ast.ProgramNode;
+import ast.member.FieldNode;
+import ast.member.MethodNode;
+import ast.statement.AssignmentStatementNode;
+import typechecker.TypeCheckResult;
+
+public interface SemanticVisitor {
+//    TypeCheckResult typeCheck(ASTNode toCheck);
+
+    TypeCheckResult analyze(ProgramNode toCheck);
+
+    TypeCheckResult analyze(ClassNode toCheck);
+
+    TypeCheckResult analyze(MethodNode toCheck);
+
+    TypeCheckResult analyze(FieldNode toCheck);
+
+    TypeCheckResult analyze(AssignmentStatementNode toCheck);
+//
+//    TypeCheckResult typeCheck(MethodParameter toCheck);
+//
+//    TypeCheckResult typeCheck(ForStmt forStmt);
+//
+//    TypeCheckResult typeCheck(WhileStmt whileStmt);
+//
+//    TypeCheckResult typeCheck(ReturnStmt returnStmt);
+//
+//    TypeCheckResult typeCheck(LocalVarDecl localVarDecl);
+//
+//    TypeCheckResult typeCheck(IfStmt ifStmt);
+//
+//    TypeCheckResult typeCheck(Block block);
+//
+//    TypeCheckResult typeCheck(NewDecl newDecl);
+//
+//    TypeCheckResult typeCheck(MethodCall methodCall);
+//
+//    TypeCheckResult typeCheck(Unary unary);
+//
+//    TypeCheckResult typeCheck(This aThis);
+//
+//    TypeCheckResult typeCheck(Null aNull);
+//
+//    TypeCheckResult typeCheck(LocalOrFieldVar localOrFieldVar);
+//
+//    TypeCheckResult typeCheck(IntegerExpr integerExpr);
+//
+//    TypeCheckResult typeCheck(InstVar instVar);
+//
+//    TypeCheckResult typeCheck(CharExpr charExpr);
+//
+//    TypeCheckResult typeCheck(BoolExpr boolExpr);
+//
+//    TypeCheckResult typeCheck(Binary binary);
+//
+//    TypeCheckResult typeCheck(StringExpr instVar);
+
+}

src/main/java/typechecker/Type.java

@@ -0,0 +1,5 @@
+package typechecker;
+
+public interface Type {
+    boolean equals(Object obj);
+}

src/main/java/typechecker/TypeCheckResult.java

@@ -0,0 +1,21 @@
+package typechecker;
+
+
+public class TypeCheckResult {
+
+  private boolean valid;
+  private Type type;
+
+  public TypeCheckResult(boolean valid, Type type) {
+    this.valid = valid;
+    this.type = type;
+  }
+
+  public boolean isValid() {
+    return valid;
+  }
+
+  public Type getType() {
+    return type;
+  }
+}

src/main/java/typechecker/Visitable.java

@@ -0,0 +1,20 @@
+package typechecker;
+
+import bytecode.visitor.ClassVisitor;
+import bytecode.visitor.MethodVisitor;
+import bytecode.visitor.ProgramVisitor;
+import semantic.SemanticVisitor;
+
+public interface Visitable {
+    default void accept(ProgramVisitor programVisitor) {
+
+    }
+    default void accept(ClassVisitor classVisitor) {
+
+    }
+    default void accept(MethodVisitor methodVisitor) {
+
+    }
+
+    TypeCheckResult accept(SemanticVisitor visitor);
+}