Revert "Merge branch 'NewParser' into johns-branch"

This reverts commit 84ecf316cd, reversing
changes made to 7ddea8f18d.

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,6 +30,7 @@ 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;
@@ -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
@@ -275,13 +284,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;
@@ -324,6 +326,15 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 targetType = currentFields.get(toCheck.target.identifier);
             }
             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);
@@ -620,4 +631,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/context/Context.java

@@ -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/test/java/main/MainTest.java

@@ -12,11 +12,16 @@ import java.nio.file.Paths;
  * run every test: mvn test
  * Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen
  */
-@Deprecated
 public class MainTest {
     @Test
     void test() {
-        System.out.println("MainTest");
+        CharStream codeCharStream = null;
+        try {
+            codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/CompilerInput.java"));
+            Main.compileFile(codeCharStream, "src/main/test/resources/output");
+        } catch (IOException e) {
+            System.err.println("Error reading the file: " + e.getMessage());
+        }
     }
 }
 

src/test/java/main/ReflectionsTest.java

@@ -11,7 +11,7 @@ import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.*;
 
-@Deprecated
+
 public class ReflectionsTest {
 
     @Test

src/test/java/parser/AstBuilderTest.java

@@ -9,20 +9,34 @@ import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.expressions.unaryexpressions.UnaryNode;
 import ast.members.ConstructorNode;
 import ast.members.FieldNode;
+import ast.members.MemberNode;
 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.IStatementNode;
 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.ITypeNode;
 import ast.type.type.TypeEnum;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
+import parser.astBuilder.ASTBuilder;
+import parser.generated.SimpleJavaLexer;
+import parser.generated.SimpleJavaParser;
+
+import java.io.IOException;
+import java.lang.reflect.Member;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -329,7 +343,7 @@ class AstBuilderTest {
 
     @Test
     @DisplayName("Self Reference Test")
-    public void selfReferenceTest() {
+    public void selfReferneceTest() {
 
         //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }

src/test/java/semantic/SemanticTest.java

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

src/test/resources/input/typedAstExceptionsTests/ClassNotDeclared.java

@@ -0,0 +1,12 @@
+// @expected: NotDeclaredException
+public class Test {
+
+    public House1 h;
+
+
+}
+
+public class House {
+
+
+}