Handling Merge

src/main/antlr/Decaf.g4

@@ -88,6 +88,6 @@ CHAR : 'char';
 
 BOOLEANLITERAL : 'true' | 'false' ;
 CHARLITERAL : ['][a-zA-Z]['];
-IDENTIFIER : [a-zA-Z]+;
+IDENTIFIER : ([a-zA-Z]+[0-9]*)+;
 NUMBER : [0-9]+;
 WS : [ \t\r\n] -> skip;

src/main/java/de/maishai/Compiler.java

@@ -3,9 +3,12 @@ package de.maishai;
 import de.maishai.antlr.DecafLexer;
 import de.maishai.antlr.DecafParser;
 import de.maishai.ast.records.Class;
-import org.antlr.v4.runtime.CharStream;
+import de.maishai.typedast.CodeGenUtils;
-import org.antlr.v4.runtime.CharStreams;
+import de.maishai.typedast.typedclass.TypedClass;
-import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.*;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
 
 /**
  * Decaf language Compiler
@@ -22,5 +25,45 @@ public class Compiler {
         return ast;
     }
 
+    public static TypedClass generateTypedASTFromAst(Class ast) {
+        TypedClass typedAST = new TypedClass();
+        typedAST.startConversion(ast);
+        return typedAST;
+    }
 
+    public static byte[] generateByteCodeArrayFromTypedAst(TypedClass typedAST) {
+        return typedAST.codeGen();
+    }
+
+    public static byte[] generateByteCodeArray(String fromSource) {
+        Class ast = generateAST(fromSource);
+        TypedClass typedAST = generateTypedASTFromAst(ast);
+        return generateByteCodeArrayFromTypedAst(typedAST);
+    }
+
+    public static byte[] generateByteCodeArrayFromFile(String sourcePath) {
+        ANTLRInputStream antlrInputStream;
+        try {
+            antlrInputStream = new ANTLRFileStream(sourcePath);
+        } catch (IOException e) {
+            System.out.println("Ungültiger Dateipfad D:");
+            throw new RuntimeException("Ungültiger Dateipfad D:");
+        }
+        DecafLexer lexer = new DecafLexer(antlrInputStream);
+        CommonTokenStream tokens = new CommonTokenStream(lexer);
+        DecafParser parser = new DecafParser(tokens);
+        DecafParser.ClassContext tree = parser.class_(); //Parsen
+        Class ast = ASTGenerator.generateAST(tree);
+        TypedClass typedAST = generateTypedASTFromAst(ast);
+        return generateByteCodeArrayFromTypedAst(typedAST);
+    }
+
+    public static void generateByteCodeFileFromFile(String sourcePath, String classname) {
+        byte[] bytes = generateByteCodeArrayFromFile(sourcePath);
+        CodeGenUtils.writeClassfile(bytes, classname);
+    }
+
+    public static void main(String[] args) {
+        generateByteCodeFileFromFile("src/main/resources/JavaTestfiles/PublicClass.java", "OnlyClass");
+    }
 }

src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithConstructor.java

@@ -29,7 +29,6 @@ public class AbstractSyntax_ClassWithConstructor {
         List<Method> methods = List.of();
         List<Constructor> constructors = getConstructors();
         return new Class(
-                true,
                 new Id("ClassWithConstructor"),
                 fields,
                 methods,

src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithConstructorAndMethodCall.java

@@ -37,7 +37,6 @@ public class AbstractSyntax_ClassWithConstructorAndMethodCall {
         List<Method> methodList = getMethods();
         List<Constructor> constructorList = getConstructors();
         return new Class(
-                true,
                 new Id("ClassWithConstructorAndMethodCall"),
                 fieldList,
                 methodList,
@@ -95,7 +94,6 @@ public class AbstractSyntax_ClassWithConstructorAndMethodCall {
 
     private static Method getMethod1() {
         return new Method(
-                true,
                 ReturnType.BOOL,
                 new Id("methodCall"),
                 List.of(),

src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithConstructorWithParameters.java

@@ -30,7 +30,6 @@ public class AbstractSyntax_ClassWithConstructorWithParameters {
         );
         List<Constructor> constructors = getConstructors();
         return new Class(
-                true,
                 new Id("ClassWithConstructorWithParameters"),
                 fields,
                 List.of(),
@@ -98,7 +97,6 @@ public class AbstractSyntax_ClassWithConstructorWithParameters {
                                                                         ),
                                                                         new Assignment(
                                                                                 new Id("innerRepetitions"),
-                                                                                AssignSign.SUB_ASSIGN,
                                                                                 new Binary(new Id("innerRepetitions"),
                                                                                         Operator.SUB,
                                                                                         new IntLiteral(1))
@@ -110,9 +108,9 @@ public class AbstractSyntax_ClassWithConstructorWithParameters {
                                                 new Assignment(
                                                         new Id("repetitions"),
                                                         new Binary(new Id("repetitions"),
-                                                                new Op)
+                                                                Operator.SUB,
                                                         new IntLiteral(1)
-
+                                                        )
                                                 )
                                         )
                                 )

src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithField.java

@@ -22,7 +22,6 @@ public class AbstractSyntax_ClassWithField {
         List<Method> methods = List.of();
         List<Constructor> constructors = List.of();
         return new Class(
-                true,
                 new Id("ClassWithAssignment"),
                 fields,
                 methods,

src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithMethod.java

@@ -14,7 +14,6 @@ public class AbstractSyntax_ClassWithMethod {
     public static Class get() {
         List<Method> methods = getMethods();
         return new Class(
-                true,
                 new Id("ClassWithMethod"),
                 List.of(),
                 methods,
@@ -29,7 +28,6 @@ public class AbstractSyntax_ClassWithMethod {
 
     private static Method getMethod1() {
         return new Method(
-                true,
                 ReturnType.BOOL,
                 new Id("method"),
                 List.of(),

src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithMethodAndField.java

@@ -27,7 +27,6 @@ class AbstractSyntax_ClassWithMethodAndField {
         List<Method> methods = getMethods();
         List<Constructor> constructors = getConstructors();
         return new Class(
-                false,
                 new Id("ClassWithMethodAndField"),
                 fields,
                 methods,
@@ -68,7 +67,6 @@ class AbstractSyntax_ClassWithMethodAndField {
 
     private static Method getMethod1() {
         return new Method(
-                true,
                 ReturnType.BOOL,
                 new Id("method"),
                 List.of(),

src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithMoreComplexMethodAndMain.java

@@ -37,7 +37,6 @@ public class AbstractSyntax_ClassWithMoreComplexMethodAndMain {
         List<Method> methods = getMethods();
         List<Constructor> constructors = List.of();
         return new Class(
-                true,
                 new Id("ClassWithMoreComplexMethodAndMain"),
                 fields,
                 methods,
@@ -103,7 +102,6 @@ public class AbstractSyntax_ClassWithMoreComplexMethodAndMain {
                 )
         );
         return new Method(
-                true,
                 ReturnType.BOOL,
                 new Id("moreComplexMethod"),
                 List.of(),

src/main/resources/AbstractSyntax/AbstractSyntax_OnlyClass.java

@@ -9,7 +9,6 @@ import java.util.List;
 public class AbstractSyntax_OnlyClass {
     public static Class get() {
         return new Class(
-                false,
                 new Id("OnlyClass"),
                 List.of(),
                 List.of(),

src/main/resources/AbstractSyntax/AbstractSyntax_PublicClass.java

@@ -9,7 +9,6 @@ import java.util.List;
 public class AbstractSyntax_PublicClass {
     public static Class get() {
         return new Class(
-                true,
                 new Id("PublicClass"),
                 List.of(),
                 List.of(),

src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithConstructor.java

@@ -0,0 +1,154 @@
+//public class ClassWithConstructor {
+//    int x;
+//    public classWithConstructor() {
+//        this.x = 10;
+//        int i;
+//        for (i = 0; i < 6; i = i + 1) {
+//            int j;
+//            for (j = 0; j < this.x; j += 1) {
+//                this.x = this.x * this.x;
+//            }
+//        }
+//    }
+//}
+
+import de.maishai.ast.AssignSign;
+import de.maishai.ast.Operator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class TypedAbstractSyntax_ClassWithConstructor {
+    public static TypedClass get() {
+        TypedClass typedClass = new TypedClass();
+        typedClass.setIsPublic(true);
+        typedClass.setTypedId(new TypedId("ClassWithConstructor"));
+
+        TypedField typedField = new TypedField();
+        typedField.setTypedId(new TypedId("x"));
+        typedField.setType(Type.INT);
+
+        typedClass.setTypedFields(List.of(typedField));
+        typedClass.setTypedMethods(List.of());
+        typedClass.setTypedMainMethod(null);
+        typedClass.setTypedConstructors(getConstructors());
+        return typedClass;
+    }
+
+    private static List<TypedConstructor> getConstructors() {
+        return List.of(getConstructor1());
+    }
+
+    private static TypedConstructor getConstructor1() {
+        TypedConstructor typedConstructor = new TypedConstructor();
+        typedConstructor.setIsPublic(true);
+        typedConstructor.setTypedId(new TypedId("ClassWithConstructor"));
+        typedConstructor.setTypedParameters(List.of());
+
+        TypedBlock typedBlock = new TypedBlock();
+
+            TypedLocalVariable typedLocalVariable = new TypedLocalVariable();
+            typedLocalVariable.setTypedId(new TypedId("i"));
+            typedLocalVariable.setType(Type.INT);
+
+        typedBlock.setVars(List.of(typedLocalVariable));
+
+            TypedAssignment typedAssignment = new TypedAssignment();
+            typedAssignment.setLoc(new TypedId("x"));
+//            typedAssignment.setAssignSign(AssignSign.ASSIGN);
+            typedAssignment.setValue(new TypedIntLiteral(10));
+
+            TypedFor typedFor = new TypedFor();
+
+                TypedAssignment typedAssignmentFor = new TypedAssignment();
+                typedAssignmentFor.setLoc(new TypedId("i"));
+//                typedAssignmentFor.setAssignSign(AssignSign.ASSIGN);
+                typedAssignmentFor.setValue(new TypedIntLiteral(0));
+
+//            typedFor.setAssign(typedAssignmentFor);
+
+                TypedBinary typedBinaryFor = new TypedBinary();
+                typedBinaryFor.setLeft(new TypedId("i"));
+                typedBinaryFor.setOp(Operator.LT);
+                typedBinaryFor.setRight(new TypedIntLiteral(6));
+
+            typedFor.setCond(typedBinaryFor);
+
+                TypedBinary typedBinaryForIncr = new TypedBinary();
+                typedBinaryForIncr.setLeft(new TypedId("i"));
+                typedBinaryForIncr.setOp(Operator.ADD);
+                typedBinaryForIncr.setRight(new TypedIntLiteral(1));
+
+                TypedAssignment typedAssignmentForIncr = new TypedAssignment();
+                typedAssignmentForIncr.setLoc(new TypedId("i"));
+//                typedAssignmentForIncr.setAssignSign(AssignSign.ASSIGN);
+                typedAssignmentForIncr.setValue(typedBinaryForIncr);
+
+//            typedFor.setInc(typedAssignmentForIncr);
+
+                TypedBlock typedBlockFor = new TypedBlock();
+
+                    TypedLocalVariable typedLocalVariableFor = new TypedLocalVariable();
+                    typedLocalVariableFor.setTypedId(new TypedId("j"));
+                    typedLocalVariableFor.setType(Type.INT);
+
+                typedBlockFor.setVars(List.of(typedLocalVariableFor));
+
+                    TypedFor typedInnerFor = new TypedFor();
+
+                        TypedAssignment typedAssignmentInnerFor = new TypedAssignment();
+                        typedAssignmentInnerFor.setLoc(new TypedId("j"));
+//                        typedAssignmentInnerFor.setAssignSign(AssignSign.ASSIGN);
+                        typedAssignmentInnerFor.setValue(new TypedIntLiteral(0));
+
+//                    typedInnerFor.setAssign(typedAssignmentInnerFor);
+
+                        TypedBinary typedBinaryInnerFor = new TypedBinary();
+                        typedBinaryInnerFor.setLeft(new TypedId("j"));
+                        typedBinaryInnerFor.setOp(Operator.LT);
+                        typedBinaryInnerFor.setRight(new TypedId("x"));
+
+                    typedInnerFor.setCond(typedBinaryInnerFor);
+
+                        TypedAssignment typedAssignmentInnerForIncr = new TypedAssignment();
+                        typedAssignmentInnerForIncr.setLoc(new TypedId("j"));
+//                        typedAssignmentInnerForIncr.setAssignSign(AssignSign.ADD_ASSIGN);
+                        typedAssignmentInnerForIncr.setValue(new TypedIntLiteral(1));
+
+//                    typedInnerFor.setInc(typedAssignmentInnerForIncr);
+
+                        TypedBlock typedBlockInnerFor = new TypedBlock();
+                        typedBlockInnerFor.setVars(List.of());
+
+                            TypedAssignment typedAssignmentInnerForBlock = new TypedAssignment();
+                            typedAssignmentInnerForBlock.setLoc(new TypedId("x"));
+//                            typedAssignmentInnerForBlock.setAssignSign(AssignSign.ASSIGN);
+
+                                TypedBinary typedBinaryInnerForBlock = new TypedBinary();
+                                typedBinaryInnerForBlock.setLeft(new TypedId("x"));
+                                typedBinaryInnerForBlock.setOp(Operator.MUL);
+                                typedBinaryInnerForBlock.setRight(new TypedId("x"));
+
+                            typedAssignmentInnerForBlock.setValue(typedBinaryInnerForBlock);
+
+                        typedBlockInnerFor.setStmts(List.of(typedAssignmentInnerForBlock));
+
+                    typedInnerFor.setTypedBlock(typedBlockInnerFor);
+
+                typedBlockFor.setStmts(List.of(typedInnerFor));
+
+            typedFor.setTypedBlock(typedBlockFor);
+
+        typedBlock.setStmts(
+                List.of(
+                        typedAssignment,
+                        typedFor
+                )
+        );
+
+        typedConstructor.setTypedBlock(typedBlock);
+
+        return typedConstructor;
+    }
+}

src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithConstructorAndMethodCall.java

@@ -0,0 +1,134 @@
+//public class ClassWithConstructorAndMethodCall {
+//    int x;
+//
+//    public ClassWithConstructorAndMethodCall() {
+//        this.x = 10;
+//        while (methodCall()) {
+//            this.x = this.x * this.x;
+//        }
+//    }
+//
+//    public boolean methodCall() {
+//        if (this.x > 100) {
+//            return false;
+//        } else {
+//            return true;
+//        }
+//    }
+//}
+
+
+import de.maishai.ast.AssignSign;
+import de.maishai.ast.Operator;
+import de.maishai.ast.ReturnType;
+import de.maishai.ast.Type;
+import de.maishai.ast.records.*;
+import de.maishai.ast.records.Class;
+
+import java.util.List;
+
+public class TypedAbstractSyntax_ClassWithConstructorAndMethodCall {
+//    public static Class get() {
+//        List<Field> fieldList = List.of(
+//                new Field(
+//                        new Id("x"),
+//                        Type.INT
+//                )
+//        );
+//        List<Method> methodList = getMethods();
+//        List<Constructor> constructorList = getConstructors();
+//        return new Class(
+//                new Id("ClassWithConstructorAndMethodCall"),
+//                fieldList,
+//                methodList,
+//                null,
+//                constructorList
+//        );
+//    }
+//
+//    private static List<Constructor> getConstructors() {
+//        return List.of(getConstructor1());
+//    }
+//
+//    private static Constructor getConstructor1() {
+//        Block block = new Block(
+//                List.of(),
+//                List.of(
+//                        new Assignment(
+//                                new Id("x"),
+//                                AssignSign.ASSIGN,
+//                                new IntLiteral(10)
+//                        ),
+//                        new While(
+//                                new MethodCall(
+//                                        false,
+//                                        null,
+//                                        new Id("methodCall"),
+//                                        List.of()
+//                                ),
+//                                new Block(
+//                                        List.of(),
+//                                        List.of(
+//                                                new Assignment(
+//                                                        new Id("x"),
+//                                                        AssignSign.ASSIGN,
+//                                                        new Binary(
+//                                                                new Id("x"),
+//                                                                Operator.MUL,
+//                                                                new Id("x")
+//                                                        )
+//                                                )
+//                                        )
+//                                )
+//                        )
+//                )
+//        );
+//        return new Constructor(
+//                true,
+//                new Id("ClassWithConstructorAndMethodCall"),
+//                List.of(),
+//                block
+//        );
+//    }
+//
+//    private static List<Method> getMethods() {
+//        return List.of(getMethod1());
+//    }
+//
+//    private static Method getMethod1() {
+//        return new Method(
+//                true,
+//                ReturnType.BOOL,
+//                new Id("methodCall"),
+//                List.of(),
+//                new Block(
+//                        List.of(),
+//                        List.of(
+//                                new IfElse(
+//                                        new Binary(
+//                                                new Id("x"),
+//                                                Operator.GT,
+//                                                new IntLiteral(100)
+//                                        ),
+//                                        new Block(
+//                                                List.of(),
+//                                                List.of(
+//                                                        new Return(
+//                                                                new BoolLiteral(false)
+//                                                        )
+//                                                )
+//                                        ),
+//                                        new Block(
+//                                                List.of(),
+//                                                List.of(
+//                                                        new Return(
+//                                                                new BoolLiteral(true)
+//                                                        )
+//                                                )
+//                                        )
+//                                )
+//                        )
+//                )
+//        );
+//    }
+}

src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithConstructorWithParameters.java

@@ -0,0 +1,130 @@
+//public class ClassWithConstructorWithParameters {
+//    int x;
+//    public classWithConstructorWithParameters(int startValue, int repetitions) {
+//        this.x = startValue;
+//        while (repetitions > 0) {
+//            int innerRepetitions;
+//            innerRepetitions = this.x;
+//            while (innerRepetitions > 0) {
+//                this.x = this.x * this.x;
+//                innerRepetitions -= 1;
+//            }
+//            repetitions -= 1;
+//        }
+//    }
+//}
+import de.maishai.ast.AssignSign;
+import de.maishai.ast.Operator;
+import de.maishai.ast.records.*;
+import de.maishai.ast.Type;
+import de.maishai.ast.records.Class;
+
+import java.util.List;
+
+public class TypedAbstractSyntax_ClassWithConstructorWithParameters {
+//    public static Class get() {
+//        List<Field> fields = List.of(
+//                new Field(
+//                        new Id("x"),
+//                        Type.INT
+//                )
+//        );
+//        List<Constructor> constructors = getConstructors();
+//        return new Class(
+//                true,
+//                new Id("ClassWithConstructorWithParameters"),
+//                fields,
+//                List.of(),
+//                null,
+//                constructors
+//        );
+//    }
+//
+//    private static List<Constructor> getConstructors() {
+//        return List.of(getConstructor1());
+//    }
+//
+//    private static Constructor getConstructor1() {
+//        List<Parameter> parameters = List.of(
+//                new Parameter(
+//                        "startValue",
+//                        Type.INT
+//                ),
+//                new Parameter(
+//                        "repetitions",
+//                        Type.INT
+//                )
+//        );
+//        Block block = new Block(
+//                List.of(),
+//                List.of(
+//                        new Assignment(
+//                                new Id("x"),
+//                                AssignSign.ASSIGN,
+//                                new Id("startValue")
+//                        ),
+//                        new While(
+//                                new Binary(
+//                                        new Id("repetitions"),
+//                                        Operator.GT,
+//                                        new IntLiteral(0)
+//                                ),
+//                                new Block(
+//                                        List.of(
+//                                                new LocalVariable(
+//                                                        new Id("innerRepetitions"),
+//                                                        Type.INT
+//                                                )
+//                                        ),
+//                                        List.of(
+//                                                new Assignment(
+//                                                        new Id("innerRepetitions"),
+//                                                        AssignSign.ASSIGN,
+//                                                        new Id("x")
+//                                                ),
+//                                                new While(
+//                                                        new Binary(
+//                                                                new Id("repetitions"),
+//                                                                Operator.GT,
+//                                                                new IntLiteral(0)
+//                                                        ),
+//                                                        new Block(
+//                                                                List.of(),
+//                                                                List.of(
+//                                                                        new Assignment(
+//                                                                                new Id("x"),
+//                                                                                AssignSign.ASSIGN,
+//                                                                                new Binary(
+//                                                                                        new Id("x"),
+//                                                                                        Operator.MUL,
+//                                                                                        new Id("x")
+//                                                                                )
+//                                                                        ),
+//                                                                        new Assignment(
+//                                                                                new Id("innerRepetitions"),
+//                                                                                AssignSign.SUB_ASSIGN,
+//                                                                                new IntLiteral(1)
+//                                                                        )
+//                                                                )
+//                                                        )
+//                                                ),
+//                                                new Assignment(
+//                                                        new Id("repetitions"),
+//                                                        AssignSign.SUB_ASSIGN,
+//                                                        new IntLiteral(1)
+//
+//                                                )
+//                                        )
+//                                )
+//                        )
+//                )
+//        );
+//        return new Constructor(
+//                true,
+//                new Id("classWithConstructorWithParameters"),
+//                parameters,
+//                block
+//        );
+//    }
+
+}

src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithField.java

@@ -0,0 +1,26 @@
+//public class ClassWithField {
+//    int x;
+//}
+
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class TypedAbstractSyntax_ClassWithField {
+    public static TypedClass get() {
+        TypedClass typedClass = new TypedClass();
+        typedClass.setIsPublic(true);
+        typedClass.setTypedId(new TypedId("ClassWithField"));
+        typedClass.setTypedFields(
+                List.of(
+                        new TypedField(new TypedId("x"), Type.INT)
+                )
+        );
+        typedClass.setTypedMethods(List.of());
+        typedClass.setTypedMainMethod(null);
+        typedClass.setTypedConstructors(List.of());
+        return typedClass;
+    }
+}

src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithMethod.java

@@ -0,0 +1,46 @@
+//public class ClassWithMethod {
+//    public boolean method() {
+//        return false;
+//    }
+//}
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class TypedAbstractSyntax_ClassWithMethod {
+    public static TypedClass get() {
+        TypedClass typedClass = new TypedClass();
+        typedClass.setIsPublic(true);
+        typedClass.setTypedId(new TypedId("ClassWithMethod"));
+        typedClass.setTypedFields(List.of());
+        typedClass.setTypedMethods(getMethods());
+        return typedClass;
+    }
+
+    private static List<TypedMethod> getMethods() {
+        return List.of(getMethod1());
+    }
+
+    private static TypedMethod getMethod1() {
+        TypedMethod typedMethod = new TypedMethod();
+        typedMethod.setIsPublic(true);
+        typedMethod.setTypedId(new TypedId("method"));
+        typedMethod.setReturnType(Type.BOOL);
+        typedMethod.setTypedParameters(List.of());
+
+        TypedBoolLiteral typedBoolLiteral = new TypedBoolLiteral();
+        typedBoolLiteral.setValue(false);
+
+        TypedReturn typedReturn = new TypedReturn();
+        typedReturn.setRet(typedBoolLiteral);
+
+        TypedBlock typedBlock = new TypedBlock();
+        typedBlock.setVars(List.of());
+        typedBlock.setStmts(List.of(typedReturn));
+
+        typedMethod.setTypedBlock(typedBlock);
+        return typedMethod;
+    }
+}

src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithMethodAndField.java

@@ -0,0 +1,86 @@
+//public class ClassWithMethodAndField {
+//    char c;
+//
+//    public ClassWithMethodAndField(char character) {
+//        this.c = character;
+//    }
+//
+//    public boolean method() {
+//        return true;
+//    }
+//}
+
+import de.maishai.ast.*;
+import de.maishai.ast.records.*;
+import de.maishai.ast.records.Class;
+
+import java.util.List;
+
+class TypedAbstractSyntax_ClassWithMethodAndField {
+//    public static Class get() {
+//        List<Field> fields = List.of(
+//                new Field(
+//                        new Id("c"),
+//                        Type.CHAR
+//                )
+//        );
+//        List<Method> methods = getMethods();
+//        List<Constructor> constructors = getConstructors();
+//        return new Class(
+//                false,
+//                new Id("ClassWithMethodAndField"),
+//                fields,
+//                methods,
+//                null,
+//                constructors
+//        );
+//    }
+//
+//    private static List<Constructor> getConstructors() {
+//        return List.of(getConstructor1());
+//    }
+//
+//    private static Constructor getConstructor1() {
+//        return new Constructor(
+//                true,
+//                new Id("ClassWithMethodAndField"),
+//                List.of(
+//                        new Parameter(
+//                                "character",
+//                                Type.CHAR
+//                        )
+//                ),
+//                new Block(
+//                        List.of(),
+//                        List.of(
+//                                new Assignment(
+//                                        new Id("c"),
+//                                        AssignSign.ASSIGN,
+//                                        new Id("character")
+//                                )
+//                        )
+//                )
+//        );
+//    }
+//
+//    private static List<Method> getMethods() {
+//        return List.of(getMethod1());
+//    }
+//
+//    private static Method getMethod1() {
+//        return new Method(
+//                true,
+//                ReturnType.BOOL,
+//                new Id("method"),
+//                List.of(),
+//                new Block(
+//                        List.of(),
+//                        List.of(
+//                                new Return(
+//                                        new BoolLiteral(true)
+//                                )
+//                        )
+//                )
+//        );
+//    }
+}

src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithMoreComplexMethodAndMain.java

@@ -0,0 +1,137 @@
+//public class ClassWithMoreComplexMethodAndMain {
+//    ClassWithMoreComplexMethodAndMain instance;
+//
+//    public boolean moreComplexMethod() {
+//        int i;
+//        i = 11;
+//        boolean returnValue;
+//        returnValue = false;
+//        while (i > 0) {
+//            i -= 1;
+//            returnValue = !returnValue;
+//        }
+//        return returnValue;
+//    }
+//
+//    public static void main(String[] args) {
+//        instance = new ClassWithMoreComplexMethodAndMain()
+//    }
+//}
+
+import de.maishai.ast.*;
+import de.maishai.ast.records.*;
+import de.maishai.ast.records.Class;
+
+import java.util.List;
+
+public class TypedAbstractSyntax_ClassWithMoreComplexMethodAndMain {
+//    public static Class get() {
+//        Type TypeClassWithMoreComplexMethodAndMain = Type.OBJECT;
+//        TypeClassWithMoreComplexMethodAndMain.setObjectType(new Id("ClassWithMoreComplexMethodAndMain"));
+//        List<Field> fields = List.of(
+//                new Field(
+//                        new Id("instance"),
+//                        TypeClassWithMoreComplexMethodAndMain
+//                )
+//        );
+//        List<Method> methods = getMethods();
+//        List<Constructor> constructors = List.of();
+//        return new Class(
+//                true,
+//                new Id("ClassWithMoreComplexMethodAndMain"),
+//                fields,
+//                methods,
+//                getMainMethod(),
+//                constructors
+//        );
+//    }
+//
+//    private static List<Method> getMethods() {
+//        return List.of(getMethod1());
+//    }
+//
+//    private static Method getMethod1() {
+//        Block block = new Block(
+//                List.of(
+//                        new LocalVariable(
+//                                new Id("i"),
+//                                Type.INT
+//                        ),
+//                        new LocalVariable(
+//                                new Id("returnValue"),
+//                                Type.BOOL
+//                        )
+//                ),
+//                List.of(
+//                        new Assignment(
+//                                new Id("i"),
+//                                AssignSign.ASSIGN,
+//                                new IntLiteral(11)
+//                        ),
+//                        new Assignment(
+//                                new Id("returnValue"),
+//                                AssignSign.ASSIGN,
+//                                new BoolLiteral(false)
+//                        ),
+//                        new While(
+//                                new Binary(
+//                                        new Id("i"),
+//                                        Operator.GT,
+//                                        new IntLiteral(0)
+//                                ),
+//                                new Block(
+//                                        List.of(),
+//                                        List.of(
+//                                                new Assignment(
+//                                                        new Id("i"),
+//                                                        AssignSign.SUB_ASSIGN,
+//                                                        new IntLiteral(1)
+//                                                ),
+//                                                new Assignment(
+//                                                        new Id("returnValue"),
+//                                                        AssignSign.ASSIGN,
+//                                                        new Unary(
+//                                                                UnaryOperator.NOT,
+//                                                                new Id("returnValue")
+//                                                        )
+//                                                )
+//                                        )
+//                                )
+//                        ),
+//                        new Return(
+//                                new Id("returnValue")
+//                        )
+//                )
+//        );
+//        return new Method(
+//                true,
+//                ReturnType.BOOL,
+//                new Id("moreComplexMethod"),
+//                List.of(),
+//                block
+//        );
+//    }
+//
+//
+//    private static MainMethod getMainMethod() {
+//        Type TypeClassWithMoreComplexMethodAndMain = Type.OBJECT;
+//        TypeClassWithMoreComplexMethodAndMain.setObjectType(new Id("ClassWithMoreComplexMethodAndMain"));
+//        List<Statement> statementList = List.of(
+//                new Assignment(
+//                        new Id("instance"),
+//                        AssignSign.ASSIGN,
+//                        new New(
+//                                TypeClassWithMoreComplexMethodAndMain,
+//                                List.of()
+//                        )
+//                )
+//        );
+//        Block block = new Block(
+//                List.of(),
+//                statementList
+//        );
+//        return new MainMethod(
+//                block
+//        );
+//    }
+}

src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_OnlyClass.java

@@ -0,0 +1,19 @@
+//class OnlyClass {
+//}
+
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class TypedAbstractSyntax_OnlyClass {
+    public static TypedClass get() {
+        TypedClass typedClass = new TypedClass();
+        typedClass.setIsPublic(false);
+        typedClass.setTypedId(new TypedId("OnlyClass"));
+        typedClass.setTypedFields(List.of());
+        typedClass.setTypedMethods(List.of());
+        typedClass.setTypedMainMethod(null);
+        typedClass.setTypedConstructors(List.of());
+        return typedClass;
+    }
+}

src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_PublicClass.java

@@ -0,0 +1,19 @@
+//public class PublicClass {
+//}
+
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class TypedAbstractSyntax_PublicClass {
+    public static TypedClass get() {
+        TypedClass typedClass = new TypedClass();
+        typedClass.setIsPublic(true);
+        typedClass.setTypedId(new TypedId("PublicClass"));
+        typedClass.setTypedFields(List.of());
+        typedClass.setTypedMethods(List.of());
+        typedClass.setTypedMainMethod(null);
+        typedClass.setTypedConstructors(List.of());
+        return typedClass;
+    }
+}

src/test/java/E2ETests.java

@@ -0,0 +1,5 @@
+public class E2ETests {
+    public static void main(String[] args) {
+
+    }
+}

src/test/java/Test.java

@@ -1,2 +0,0 @@
-public class Test {
-}