diff --git a/src/main/java/semantic/SemanticAnalyzer.java b/src/main/java/semantic/SemanticAnalyzer.java index 6ebd124..9878989 100644 --- a/src/main/java/semantic/SemanticAnalyzer.java +++ b/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; + } + } \ No newline at end of file diff --git a/src/main/java/semantic/context/Context.java b/src/main/java/semantic/context/Context.java index 39e279a..4b20c8f 100644 --- a/src/main/java/semantic/context/Context.java +++ b/src/main/java/semantic/context/Context.java @@ -21,6 +21,10 @@ public class Context { return classes.get(identifier); } + public HashMap getClasses() { + return classes; + } + public boolean containsClass(String identifier) { return classes.containsKey(identifier); } diff --git a/src/test/java/main/MainTest.java b/src/test/java/main/MainTest.java index 54ab8be..24389bc 100644 --- a/src/test/java/main/MainTest.java +++ b/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()); + } } } diff --git a/src/test/java/main/ReflectionsTest.java b/src/test/java/main/ReflectionsTest.java index 3b4cffd..d47d95a 100644 --- a/src/test/java/main/ReflectionsTest.java +++ b/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 diff --git a/src/test/java/parser/AstBuilderTest.java b/src/test/java/parser/AstBuilderTest.java index 15403d3..2810e55 100644 --- a/src/test/java/parser/AstBuilderTest.java +++ b/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); } diff --git a/src/test/java/semantic/SemanticTest.java b/src/test/java/semantic/SemanticTest.java index db86fe9..f406580 100644 --- a/src/test/java/semantic/SemanticTest.java +++ b/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); - } } \ No newline at end of file diff --git a/src/test/resources/input/typedAstExceptionsTests/ClassNotDeclared.java b/src/test/resources/input/typedAstExceptionsTests/ClassNotDeclared.java new file mode 100644 index 0000000..6e2b81e --- /dev/null +++ b/src/test/resources/input/typedAstExceptionsTests/ClassNotDeclared.java @@ -0,0 +1,12 @@ +// @expected: NotDeclaredException +public class Test { + + public House1 h; + + +} + +public class House { + + +}