diff --git a/CharArgument.class b/CharArgument.class deleted file mode 100644 index cc8c57d..0000000 Binary files a/CharArgument.class and /dev/null differ diff --git a/ClassFields.class b/ClassFields.class deleted file mode 100644 index 9f70823..0000000 Binary files a/ClassFields.class and /dev/null differ diff --git a/ClassOne.class b/ClassOne.class deleted file mode 100644 index 6c40c2f..0000000 Binary files a/ClassOne.class and /dev/null differ diff --git a/ClassTwo.class b/ClassTwo.class deleted file mode 100644 index b943fe7..0000000 Binary files a/ClassTwo.class and /dev/null differ diff --git a/ConstructorParams.class b/ConstructorParams.class deleted file mode 100644 index 7c2a9ec..0000000 Binary files a/ConstructorParams.class and /dev/null differ diff --git a/ConstructorThisDot.class b/ConstructorThisDot.class deleted file mode 100644 index 402b19a..0000000 Binary files a/ConstructorThisDot.class and /dev/null differ diff --git a/DivMethod.class b/DivMethod.class deleted file mode 100644 index e11ee7f..0000000 Binary files a/DivMethod.class and /dev/null differ diff --git a/Fakultaet.class b/Fakultaet.class deleted file mode 100644 index 117327b..0000000 Binary files a/Fakultaet.class and /dev/null differ diff --git a/FieldVar.class b/FieldVar.class deleted file mode 100644 index 5844709..0000000 Binary files a/FieldVar.class and /dev/null differ diff --git a/FieldWithExpr.class b/FieldWithExpr.class deleted file mode 100644 index aa8d31f..0000000 Binary files a/FieldWithExpr.class and /dev/null differ diff --git a/GetterFunction.class b/GetterFunction.class deleted file mode 100644 index 05a02e8..0000000 Binary files a/GetterFunction.class and /dev/null differ diff --git a/Grammatik.txt b/Grammatik.txt deleted file mode 100644 index 91c85f5..0000000 --- a/Grammatik.txt +++ /dev/null @@ -1,166 +0,0 @@ -Grammatik: - -1. Ausdrücke - -Primary: - Literal - Variable - IncDecExpression - ( Expression ) - MethodInvocation - -Variable: - Identifier { [ Expression ] } - -Identifier: - [ Identifier . ] Name - -IncDecExpression: - Variable IncDec - IncDec Variable - -IncDec: - ++ | -- - -Expression: - UnaryExpression - BinaryExpression - AssignmentExpression - MethodInvocation - CreationExpression - -UnaryExpression: - Primary - UnaryExpression - UnaryOperator - + | - | ! | ... - -BinaryExpression: - Expression BinaryOperator Expression - -BinaryOperator: - == | + | - | * | / | & | && | | | || | - - -AssignmentExpression: - Variable = Expression - -MethodInvocation: - Method ( [ ActualArguments ] ) - -Method: - Identifier - -ActualArguments: - Expression { , Expression } - -CreationExpression: - new ClassIdentifier ( [ ActualArguments ] ) - - - -2. Anweisungen - -Statement: - SimpleStatement - CompositeStatement - Label : Statement - -SimpleStatement: - EmptyStatement - StatementExpression - EmptyStatement ; - ReturnStatement - -StatementExpression: - AssignmentExpression - IncDecExpression - MethodInvocation - CreationExpression - -ContinueStatement: - continue [ Name ] ; - -ReturnStatement. - return [ Expression ] ; - - -CompositeStatement: - Block - CaseStatement - -Block: - "{" { VariableDeclaration | Statement } "}" - -VariableDeclaration: - Type VariableDeclarator ; - -VariableDeclarator: - Name [ = Expression ] - -Type: - Name # konkrete Typen hinzufügen - Identifier - -CaseStatement: # Andere CaseStatements heraussuchen. Assign, MethodCall, - ConditionalStatement - WhileStatement - - -ConditionalStatement: - if ( Expression ) Statement [ else Statement ] - -ConstantExpression: - Expression - -WhileStatement: - while ( Expression ) Statement - -Initialization: - StatementExpression { , StatementExpression } - VariableDeclaration - - -3. Methoden - -MethodDeclaration: - MethodHeader Block - -MethodHeader: - { Modifier } ResultType MethodDeclarator - -Modifier: - public | static | ... - -ResultType: - Type | void - -MethodDeclarator: - Identifier "(" [ FormalArguments ] ")" - -FormalArguments: - FormalArgument { , FormalArgument } - -FormalArgument: - Type Name - - - -4. Klassen - -Start: - ClassDeclaration {ClassDeclaration} - -ClassDeclaration: - [ public ] class Name ClassBody - -ClassBody: - "{" { { Modifier } Declaration } "}" - -Declaration: - VariableDeclaration - MethodDeclaration - ConstructorDeclaration - -ConstructorDeclaration: - [ public ] Name ( [ FormalArguments ] ) Block diff --git a/IfElseIfStatement.class b/IfElseIfStatement.class deleted file mode 100644 index 34c23f7..0000000 Binary files a/IfElseIfStatement.class and /dev/null differ diff --git a/IfElseIfStatementWithOneReturn.class b/IfElseIfStatementWithOneReturn.class deleted file mode 100644 index f178e46..0000000 Binary files a/IfElseIfStatementWithOneReturn.class and /dev/null differ diff --git a/NichtHaskell.iml b/NichtHaskell.iml deleted file mode 100644 index fbfe57d..0000000 --- a/NichtHaskell.iml +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - - - - - - \ No newline at end of file diff --git a/classWithMain.class b/classWithMain.class deleted file mode 100644 index 225b708..0000000 Binary files a/classWithMain.class and /dev/null differ diff --git a/emptyClass.class b/emptyClass.class deleted file mode 100644 index 04d67f5..0000000 Binary files a/emptyClass.class and /dev/null differ diff --git a/getI.class b/getI.class deleted file mode 100644 index 2e0ab59..0000000 Binary files a/getI.class and /dev/null differ diff --git a/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java b/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java index 2c241c2..f0ca7e4 100644 --- a/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java +++ b/src/main/java/abstractSyntaxTree/Statement/BlockStatement.java @@ -140,7 +140,7 @@ public class BlockStatement extends AbstractType implements IStatement { && Objects.equals(statements, blockStatement.statements /*&& (Objects.equals(localVars, blockStatement.localVars)*/ ); - System.out.println("In ParameterList: " + result); + System.out.println("In BlockStatement: " + result); return result; } diff --git a/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java b/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java index 7190bf8..77a4b62 100644 --- a/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java +++ b/src/main/java/abstractSyntaxTree/Statement/ReturnStatement.java @@ -71,7 +71,7 @@ public class ReturnStatement extends AbstractType implements IStatement{ boolean result = (Objects.equals(expression, returnStatement.expression) && Objects.equals(expression.getTypeCheckResult(), returnStatement.expression.getTypeCheckResult()) ); - System.out.println("In PrintStatement: " + result); + System.out.println("In ReturnStatement: " + result); return result; } diff --git a/src/test/java/AST/testAll.java b/src/test/java/AST/testAll.java index 91923e4..72cee70 100644 --- a/src/test/java/AST/testAll.java +++ b/src/test/java/AST/testAll.java @@ -12,12 +12,47 @@ public class testAll { } + @Test + public void testAssignWrongType(){ + Program ast = AssignWrongTypeAST.getProgram(); + String pathToCode = "failTests/AssignWrongType.java"; + testAst(ast, pathToCode); + } + + @Test + public void testCharArgument(){ + Program ast = CharArgumentAST.getProgram(); + String pathToCode = "SimpleTests/CharArgument.java"; + testAst(ast, pathToCode); + } + @Test public void testClassWithMain(){ Program ast = ClassWithMainAST.getProgram(); String pathToCode = "basicClasses/classWithMain.java"; testAst(ast, pathToCode); } + + @Test + public void testConstructorThisDot(){ + Program ast = ConstructorThisDotAST.getProgram(); + String pathToCode = "SimpleTests/ConstructorThisDot.java"; + testAst(ast, pathToCode); + } + + @Test + public void testConstructorParams(){ + Program ast = ConstructorParamsAST.getProgram(); + String pathToCode = "SimpleTests/ConstructorParams.java"; + testAst(ast, pathToCode); + } + + @Test + public void testDivideByZero(){ + Program ast = DivideByZeroAST.getProgram(); + String pathToCode = "failTests/DivideByzero.java"; + testAst(ast, pathToCode); + } @Test public void testEmptyClass(){ Program ast = emptyClassAST.getEmptyProgramm(); @@ -40,24 +75,16 @@ public class testAll { } @Test - public void testAssignWrongType(){ - Program ast = AssignWrongTypeAST.getProgram(); - String pathToCode = "failTests/AssignWrongType.java"; - testAst(ast, pathToCode); - } - - - @Test - public void testDivideByZero(){ - Program ast = DivideByZeroAST.getProgram(); - String pathToCode = "failTests/DivideByzero.java"; + public void testFieldVariable(){ + Program ast = FieldVarAST.getProgram(); + String pathToCode = "SimpleTests/FieldVar.java"; testAst(ast, pathToCode); } @Test - public void testcharArgument(){ - Program ast = CharArgumentAST.getProgram(); - String pathToCode = "SimpleTests/CharArgument.java"; + public void testIfElseIfStatementWithOneReturne(){ + Program ast = IfElseIfStatementWithOneReturnAST.getProgram(); + String pathToCode = "SimpleTests/IfElseIfStatementWithOneReturn.java"; testAst(ast, pathToCode); } diff --git a/src/test/java/ASTs/ConstructorParamsAST.java b/src/test/java/ASTs/ConstructorParamsAST.java new file mode 100644 index 0000000..f1a2554 --- /dev/null +++ b/src/test/java/ASTs/ConstructorParamsAST.java @@ -0,0 +1,45 @@ +package ASTs; + +import abstractSyntaxTree.Class.FieldDecl; +import abstractSyntaxTree.Class.MethodDecl; +import abstractSyntaxTree.Class.RefType; +import abstractSyntaxTree.Parameter.Parameter; +import abstractSyntaxTree.Parameter.ParameterList; +import abstractSyntaxTree.Program; +import abstractSyntaxTree.Statement.BlockStatement; + +import java.util.ArrayList; +import java.util.List; + +public class ConstructorParamsAST { + + public static Program getProgram() { + List refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + List methodDeclList = new ArrayList<>(); + methodDeclList.add(method0()); + RefType refType = new RefType("ConstructorParams", fieldDeclList, methodDeclList, false); + return refType; + } + + public static MethodDecl method0() { + + Parameter parameter0 = new Parameter("int", "i"); + List parameterList = new ArrayList<>(); + parameterList.add(parameter0); + ParameterList parameterListObj = new ParameterList(parameterList); + BlockStatement blockStatement = new BlockStatement(new ArrayList<>(), null); + MethodDecl methodDecl = new MethodDecl("ConstructorParams", null, "ConstructorParams", + parameterListObj, blockStatement); + + return methodDecl; + } +} diff --git a/src/test/java/ASTs/ConstructorParamsASTTyped.java b/src/test/java/ASTs/ConstructorParamsASTTyped.java new file mode 100644 index 0000000..17c7490 --- /dev/null +++ b/src/test/java/ASTs/ConstructorParamsASTTyped.java @@ -0,0 +1,59 @@ +package ASTs; + +import Typecheck.TypingHelper; +import abstractSyntaxTree.Class.FieldDecl; +import abstractSyntaxTree.Class.MethodDecl; +import abstractSyntaxTree.Class.RefType; +import abstractSyntaxTree.Parameter.Parameter; +import abstractSyntaxTree.Parameter.ParameterList; +import abstractSyntaxTree.Program; +import abstractSyntaxTree.Statement.BlockStatement; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class ConstructorParamsASTTyped { + public static Program getProgram() { + List refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + addTyping(program); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + List methodDeclList = new ArrayList<>(); + methodDeclList.add(method0()); + RefType refType = new RefType("ConstructorParams", fieldDeclList, methodDeclList, false); + return refType; + } + + public static MethodDecl method0() { + + Parameter parameter0 = new Parameter("int", "i"); + List parameterList = new ArrayList<>(); + parameterList.add(parameter0); + ParameterList parameterListObj = new ParameterList(parameterList); + BlockStatement blockStatement = new BlockStatement(new ArrayList<>(), "void"); + MethodDecl methodDecl = new MethodDecl("ConstructorParams", null, "ConstructorParams", + parameterListObj, blockStatement); + + return methodDecl; + } + + public static void addTyping(Program program){ + // TypeContext + TypingHelper.addTypeContext(program, "ConstructorParams", new HashMap<>()); + + // MethodContext + HashMap method0 = new HashMap<>(); + //method0.put("void", new ParameterList(new ArrayList<>())); + HashMap> methods = new HashMap<>(); + //methods.put("main", method0); + TypingHelper.addMethodContext(program, "ConstructorParams", methods); + } +} diff --git a/src/test/java/ASTs/ConstructorThisDotAST.java b/src/test/java/ASTs/ConstructorThisDotAST.java new file mode 100644 index 0000000..df734a8 --- /dev/null +++ b/src/test/java/ASTs/ConstructorThisDotAST.java @@ -0,0 +1,60 @@ +package ASTs; + +import abstractSyntaxTree.Class.FieldDecl; +import abstractSyntaxTree.Class.MethodDecl; +import abstractSyntaxTree.Class.RefType; +import abstractSyntaxTree.Expression.InstVarExpression; +import abstractSyntaxTree.Expression.IntConstantExpression; +import abstractSyntaxTree.Expression.SubReceiver; +import abstractSyntaxTree.Parameter.Parameter; +import abstractSyntaxTree.Parameter.ParameterList; +import abstractSyntaxTree.Program; +import abstractSyntaxTree.Statement.BlockStatement; +import abstractSyntaxTree.Statement.IStatement; +import abstractSyntaxTree.StatementExpression.AssignStatementExpression; + +import java.util.ArrayList; +import java.util.List; + +public class ConstructorThisDotAST { + public static Program getProgram() { + List refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + fieldDeclList.add(new FieldDecl("int", "i", null)); + List methodDeclList = new ArrayList<>(); + methodDeclList.add(method0()); + RefType refType = new RefType("ConstructorThisDot", fieldDeclList, methodDeclList, false); + return refType; + } + + public static MethodDecl method0() { + + List parameterList = new ArrayList<>(); + ParameterList parameterListObj = new ParameterList(parameterList); + List iStatementList = new ArrayList<>(); + + SubReceiver subReceiver = new SubReceiver(true); + List subReceiverList = new ArrayList<>(); + subReceiverList.add(subReceiver); + InstVarExpression instVarExpressionLeft = new InstVarExpression(subReceiverList, new ArrayList<>(), "i"); + + + IntConstantExpression intConstantExpression = new IntConstantExpression(5); + AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", instVarExpressionLeft, intConstantExpression); + + iStatementList.add(assignStatementExpression); + BlockStatement blockStatement = new BlockStatement(iStatementList, null); + MethodDecl methodDecl = new MethodDecl("ConstructorThisDot", null, "ConstructorThisDot", + parameterListObj, blockStatement); + + return methodDecl; + } +} diff --git a/src/test/java/ASTs/ConstructorThisDotASTTyped.java b/src/test/java/ASTs/ConstructorThisDotASTTyped.java new file mode 100644 index 0000000..cbfa2f6 --- /dev/null +++ b/src/test/java/ASTs/ConstructorThisDotASTTyped.java @@ -0,0 +1,77 @@ +package ASTs; + +import Typecheck.TypingHelper; +import abstractSyntaxTree.Class.FieldDecl; +import abstractSyntaxTree.Class.MethodDecl; +import abstractSyntaxTree.Class.RefType; +import abstractSyntaxTree.Expression.InstVarExpression; +import abstractSyntaxTree.Expression.IntConstantExpression; +import abstractSyntaxTree.Expression.SubReceiver; +import abstractSyntaxTree.Parameter.Parameter; +import abstractSyntaxTree.Parameter.ParameterList; +import abstractSyntaxTree.Program; +import abstractSyntaxTree.Statement.BlockStatement; +import abstractSyntaxTree.Statement.IStatement; +import abstractSyntaxTree.StatementExpression.AssignStatementExpression; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class ConstructorThisDotASTTyped { + public static Program getProgram() { + List refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + addTyping(program); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + fieldDeclList.add(new FieldDecl("int", "i", null)); + List methodDeclList = new ArrayList<>(); + methodDeclList.add(method0()); + RefType refType = new RefType("ConstructorThisDot", fieldDeclList, methodDeclList, false); + return refType; + } + + public static MethodDecl method0() { + + List parameterList = new ArrayList<>(); + ParameterList parameterListObj = new ParameterList(parameterList); + List iStatementList = new ArrayList<>(); + + SubReceiver subReceiver = new SubReceiver(true); + List subReceiverList = new ArrayList<>(); + subReceiverList.add(subReceiver); + InstVarExpression instVarExpressionLeft = new InstVarExpression(subReceiverList, new ArrayList<>(), "i"); + instVarExpressionLeft.thisClass = "ConstructorThisDot"; + + IntConstantExpression intConstantExpression = new IntConstantExpression(5); + AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", instVarExpressionLeft, intConstantExpression); + + iStatementList.add(assignStatementExpression); + BlockStatement blockStatement = new BlockStatement(iStatementList, "void"); + MethodDecl methodDecl = new MethodDecl("ConstructorThisDot", null, "ConstructorThisDot", + parameterListObj, blockStatement); + + return methodDecl; + } + + public static void addTyping(Program program){ + // TypeContext + HashMap typeContextMap = new HashMap<>(); + typeContextMap.put("i", "int"); + TypingHelper.addTypeContext(program, "ConstructorThisDot", typeContextMap); + + // MethodContext + HashMap method0 = new HashMap<>(); + //method0.put("void", new ParameterList(new ArrayList<>())); + HashMap> methods = new HashMap<>(); + //methods.put("main", method0); + TypingHelper.addMethodContext(program, "ConstructorThisDot", methods); + } +} diff --git a/src/test/java/ASTs/FieldVarAST.java b/src/test/java/ASTs/FieldVarAST.java new file mode 100644 index 0000000..71b344f --- /dev/null +++ b/src/test/java/ASTs/FieldVarAST.java @@ -0,0 +1,24 @@ +package ASTs; + +import abstractSyntaxTree.Class.FieldDecl; +import abstractSyntaxTree.Class.MethodDecl; +import abstractSyntaxTree.Class.RefType; +import abstractSyntaxTree.Program; + +import java.util.ArrayList; +import java.util.List; + +public class FieldVarAST { + public static Program getProgram() { + // int variable + FieldDecl fieldDecl = new FieldDecl("int", "variable", null); + + List fieldDeclList = new ArrayList<>(); + List methodDeclList = new ArrayList<>(); + fieldDeclList.add(fieldDecl); + RefType class0 = new RefType("FieldVar", fieldDeclList, methodDeclList, false); + List refTypeList = new ArrayList<>(); + refTypeList.add(class0); + return new Program(refTypeList); + } +} diff --git a/src/test/java/ASTs/FieldVarASTTyped.java b/src/test/java/ASTs/FieldVarASTTyped.java new file mode 100644 index 0000000..7bd6aac --- /dev/null +++ b/src/test/java/ASTs/FieldVarASTTyped.java @@ -0,0 +1,43 @@ +package ASTs; + +import Typecheck.TypingHelper; +import abstractSyntaxTree.Class.FieldDecl; +import abstractSyntaxTree.Class.MethodDecl; +import abstractSyntaxTree.Class.RefType; +import abstractSyntaxTree.Parameter.ParameterList; +import abstractSyntaxTree.Program; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class FieldVarASTTyped { + public static Program getProgram() { + // int variable + FieldDecl fieldDecl = new FieldDecl("int", "variable", null); + + List fieldDeclList = new ArrayList<>(); + List methodDeclList = new ArrayList<>(); + fieldDeclList.add(fieldDecl); + RefType class0 = new RefType("FieldVar", fieldDeclList, methodDeclList, false); + List refTypeList = new ArrayList<>(); + refTypeList.add(class0); + Program program = new Program(refTypeList); + addTyping(program); + return program; + } + + public static void addTyping(Program program){ + // TypeContext + HashMap typeContextMap = new HashMap<>(); + typeContextMap.put("variable", "int"); + TypingHelper.addTypeContext(program, "FieldVar", typeContextMap); + + // MethodContext + HashMap method0 = new HashMap<>(); + //method0.put("void", new ParameterList(new ArrayList<>())); + HashMap> methods = new HashMap<>(); + //methods.put("main", method0); + TypingHelper.addMethodContext(program, "FieldVar", methods); + } +} diff --git a/src/test/java/ASTs/IfElseIfStatementWithOneReturnAST.java b/src/test/java/ASTs/IfElseIfStatementWithOneReturnAST.java new file mode 100644 index 0000000..eee31a6 --- /dev/null +++ b/src/test/java/ASTs/IfElseIfStatementWithOneReturnAST.java @@ -0,0 +1,104 @@ +package ASTs; + +import abstractSyntaxTree.Class.FieldDecl; +import abstractSyntaxTree.Class.MethodDecl; +import abstractSyntaxTree.Class.RefType; +import abstractSyntaxTree.Expression.BinaryExpression; +import abstractSyntaxTree.Expression.IntConstantExpression; +import abstractSyntaxTree.Expression.LocalVarIdentifier; +import abstractSyntaxTree.Parameter.Parameter; +import abstractSyntaxTree.Parameter.ParameterList; +import abstractSyntaxTree.Program; +import abstractSyntaxTree.Statement.*; +import abstractSyntaxTree.StatementExpression.AssignStatementExpression; + +import java.util.ArrayList; +import java.util.List; + +public class IfElseIfStatementWithOneReturnAST { + public static Program getProgram() { + + List refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + List methodDeclList = new ArrayList<>(); + methodDeclList.add(method0()); + RefType refType = new RefType("IfElseIfStatementWithOneReturn", fieldDeclList, methodDeclList, false); + + return refType; + } + + public static MethodDecl method0() { + + List parameterList = new ArrayList<>(); + parameterList.add(new Parameter("int", "i")); + ParameterList parameterListObj = new ParameterList(parameterList); + + List iStatementList = new ArrayList<>(); + iStatementList.add(statement00()); + iStatementList.add(statement01()); + iStatementList.add(statement02()); + BlockStatement blockStatement0 = new BlockStatement(iStatementList, null); + MethodDecl methodDecl = new MethodDecl("IfElseIfStatementWithOneReturn", "int", "foo", parameterListObj, blockStatement0); + + return methodDecl; + } + + public static LocalVarDecl statement00() { + LocalVarDecl localVarDecl = new LocalVarDecl("int", "result", null); + return localVarDecl; + } + + public static IfElseStatement statement01() { + + LocalVarIdentifier conditionLeft = new LocalVarIdentifier("i"); + BinaryExpression condition = new BinaryExpression("==", conditionLeft, new IntConstantExpression(1)); + + LocalVarIdentifier identifierResult = new LocalVarIdentifier("result"); + List ifStatementList = new ArrayList<>(); + ifStatementList.add(new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10))); + BlockStatement ifStatement = new BlockStatement(ifStatementList, null); + + IfElseStatement elseStatement = statement010(); + + IfElseStatement ifElseStatement = new IfElseStatement(condition, ifStatement, elseStatement); + + return ifElseStatement; + } + + public static IfElseStatement statement010() { + LocalVarIdentifier identifieri = new LocalVarIdentifier("i"); + BinaryExpression condition0 = new BinaryExpression("==", identifieri, new IntConstantExpression(2)); + + List iStatementList = new ArrayList<>(); + LocalVarIdentifier identifierResult = new LocalVarIdentifier("result"); + AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10)); + iStatementList.add(assignStatementExpression); + BlockStatement ifStatement = new BlockStatement(iStatementList, null); + + BinaryExpression condition1 = new BinaryExpression("==", identifieri, new IntConstantExpression(2)); + List iStatementList1 = new ArrayList<>(); + iStatementList1.add(new ReturnStatement(new IntConstantExpression(20))); + BlockStatement blockStatementIf = new BlockStatement(iStatementList1, null); + List iStatementList2 = new ArrayList<>(); + AssignStatementExpression assignStatementExpression1 = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(30)); + iStatementList2.add(assignStatementExpression1); + BlockStatement blockStatementElse = new BlockStatement(iStatementList2, null); + IfElseStatement ifElseStatement = new IfElseStatement(condition1, blockStatementIf, blockStatementElse); + + return new IfElseStatement(condition1, blockStatementIf, blockStatementElse); + } + + public static ReturnStatement statement02() { + LocalVarIdentifier identifierResult = new LocalVarIdentifier("result"); + return new ReturnStatement(identifierResult); + } + +} diff --git a/src/test/java/ASTs/IfElseIfStatementWithOneReturnASTTyped.java b/src/test/java/ASTs/IfElseIfStatementWithOneReturnASTTyped.java new file mode 100644 index 0000000..1a3bbac --- /dev/null +++ b/src/test/java/ASTs/IfElseIfStatementWithOneReturnASTTyped.java @@ -0,0 +1,135 @@ +package ASTs; + +import TypeCheck.TypeCheckResult; +import Typecheck.TypingHelper; +import abstractSyntaxTree.Class.FieldDecl; +import abstractSyntaxTree.Class.MethodDecl; +import abstractSyntaxTree.Class.RefType; +import abstractSyntaxTree.Expression.BinaryExpression; +import abstractSyntaxTree.Expression.IntConstantExpression; +import abstractSyntaxTree.Expression.LocalVarIdentifier; +import abstractSyntaxTree.Parameter.Parameter; +import abstractSyntaxTree.Parameter.ParameterList; +import abstractSyntaxTree.Program; +import abstractSyntaxTree.Statement.*; +import abstractSyntaxTree.StatementExpression.AssignStatementExpression; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class IfElseIfStatementWithOneReturnASTTyped { + + public static Program getProgram() { + + List refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + addTyping(program); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + List methodDeclList = new ArrayList<>(); + methodDeclList.add(method0()); + RefType refType = new RefType("IfElseIfStatementWithOneReturn", fieldDeclList, methodDeclList, false); + + return refType; + } + + public static MethodDecl method0() { + + List parameterList = new ArrayList<>(); + parameterList.add(new Parameter("int", "i")); + ParameterList parameterListObj = new ParameterList(parameterList); + + List iStatementList = new ArrayList<>(); + iStatementList.add(statement00()); + iStatementList.add(statement01()); + iStatementList.add(statement02()); + BlockStatement blockStatement0 = new BlockStatement(iStatementList, "int"); + MethodDecl methodDecl = new MethodDecl("IfElseIfStatementWithOneReturn", "int", "foo", parameterListObj, blockStatement0); + + return methodDecl; + } + + public static LocalVarDecl statement00() { + LocalVarDecl localVarDecl = new LocalVarDecl("int", "result", null); + return localVarDecl; + } + + public static IfElseStatement statement01() { + + LocalVarIdentifier conditionLeft = new LocalVarIdentifier("i"); + conditionLeft.setTypeCheckResult(new TypeCheckResult("int")); + BinaryExpression condition = new BinaryExpression("==", conditionLeft, new IntConstantExpression(1)); + condition.setTypeCheckResult(new TypeCheckResult("boolean")); + + LocalVarIdentifier identifierResult = new LocalVarIdentifier("result"); + identifierResult.setTypeCheckResult(new TypeCheckResult("int")); + List ifStatementList = new ArrayList<>(); + ifStatementList.add(new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10))); + BlockStatement ifStatement = new BlockStatement(ifStatementList, "void"); + + IfElseStatement elseStatement = statement010(); + + IfElseStatement ifElseStatement = new IfElseStatement(condition, ifStatement, elseStatement); + + return ifElseStatement; + } + + public static IfElseStatement statement010() { + LocalVarIdentifier identifieri = new LocalVarIdentifier("i"); + identifieri.setTypeCheckResult(new TypeCheckResult("int")); + BinaryExpression condition0 = new BinaryExpression("==", identifieri, new IntConstantExpression(2)); + condition0.setTypeCheckResult(new TypeCheckResult("boolean")); + + List iStatementList = new ArrayList<>(); + LocalVarIdentifier identifierResult = new LocalVarIdentifier("result"); + identifierResult.setTypeCheckResult(new TypeCheckResult("int")); + AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10)); + iStatementList.add(assignStatementExpression); + BlockStatement ifStatement = new BlockStatement(iStatementList, "void"); + + BinaryExpression condition1 = new BinaryExpression("==", identifieri, new IntConstantExpression(2)); + condition1.setTypeCheckResult(new TypeCheckResult("boolean")); + List iStatementList1 = new ArrayList<>(); + IntConstantExpression intConstantExpression20 = new IntConstantExpression(20); + intConstantExpression20.setTypeCheckResult(new TypeCheckResult("int")); + ReturnStatement return20 = new ReturnStatement(intConstantExpression20); + return20.setTypeCheckResult(new TypeCheckResult("int")); + iStatementList1.add(return20); + BlockStatement blockStatementIf = new BlockStatement(iStatementList1, "int"); + List iStatementList2 = new ArrayList<>(); + AssignStatementExpression assignStatementExpression1 = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(30)); + iStatementList2.add(assignStatementExpression1); + BlockStatement blockStatementElse = new BlockStatement(iStatementList2, "void"); + IfElseStatement ifElseStatement = new IfElseStatement(condition1, blockStatementIf, blockStatementElse); + + return new IfElseStatement(condition1, blockStatementIf, blockStatementElse); + } + + public static ReturnStatement statement02() { + LocalVarIdentifier identifierResult = new LocalVarIdentifier("result"); + identifierResult.setTypeCheckResult(new TypeCheckResult("int")); + return new ReturnStatement(identifierResult); + } + + public static void addTyping(Program program){ + // TypeContext + TypingHelper.addTypeContext(program, "IfElseIfStatementWithOneReturn", new HashMap<>()); + + // MethodContext + HashMap method0 = new HashMap<>(); + List parameterList = new ArrayList<>(); + parameterList.add(new Parameter("int", "i")); + ParameterList parameterListObj = new ParameterList(parameterList); + method0.put("int", parameterListObj); + HashMap> methods = new HashMap<>(); + methods.put("foo", method0); + TypingHelper.addMethodContext(program, "IfElseIfStatementWithOneReturn", methods); + } +} diff --git a/src/test/java/ByteCode/ByteCodeTester.java b/src/test/java/ByteCode/ByteCodeTester.java index e374316..9128e7c 100644 --- a/src/test/java/ByteCode/ByteCodeTester.java +++ b/src/test/java/ByteCode/ByteCodeTester.java @@ -77,7 +77,6 @@ public class ByteCodeTester { private Program generateAST(String pathToJavaFile){ String content = ""; try { - System.out.println("Classpath: " + Path.of(pathToJavaFile)); content = Files.readString(Path.of(pathToJavaFile)); } catch (IOException e) { System.out.println("File not found!"); @@ -115,7 +114,6 @@ public class ByteCodeTester { public void compareJarFilesFromScratch(String javaCodePath, String jarPath, String[] classNames){ String content = ""; try { - System.out.println("Classpath: " + Path.of(javaCodePath)); content = Files.readString(Path.of(javaCodePath)); } catch (IOException e) { System.out.println("File not found!"); diff --git a/src/test/java/ByteCode/CompareByteCodeBehaviour.java b/src/test/java/ByteCode/CompareByteCodeBehaviour.java index c5584db..c5f5b28 100644 --- a/src/test/java/ByteCode/CompareByteCodeBehaviour.java +++ b/src/test/java/ByteCode/CompareByteCodeBehaviour.java @@ -98,7 +98,7 @@ public class CompareByteCodeBehaviour { Method method1 = methods1[i]; Method method2 = methods2[i]; - System.out.println(method1); + System.out.println("\n" + method1); System.out.println(method2); method1.setAccessible(true); @@ -108,7 +108,7 @@ public class CompareByteCodeBehaviour { // Test with some sample inputs Object[] testInputs = getTestInputs(method1.getParameterTypes()); for(int j = 0; j < testInputs.length; j++){ - System.out.println("TestInput: " + testInputs[j]); + System.out.println("Parameter[" + i + "]: " + testInputs[j]); } Object result1 = method1.invoke(obj1, testInputs); diff --git a/src/test/java/ByteCode/TestAll.java b/src/test/java/ByteCode/TestAll.java index 24a70cf..e60a0d6 100644 --- a/src/test/java/ByteCode/TestAll.java +++ b/src/test/java/ByteCode/TestAll.java @@ -35,11 +35,11 @@ public class TestAll { @Test public void testFakultaet() { String classPath = "src/test/resources/basicClasses/Fakultaet.class"; - Program ast = FakultaetASTTyped.getProgram(); + Program ast = FakultaetAST.getProgram(); String className = "Fakultaet"; String javacode = "src/test/resources/basicClasses/Fakultaet.java"; - //byteCodeTester.testByteCodeFromTypedAst(classPath, ast ,className); - byteCodeTester.testClassFileFromScratch(classPath, javacode, className); + byteCodeTester.testByteCodeFromAst(classPath, ast ,className); + //byteCodeTester.testClassFileFromScratch(classPath, javacode, className); } @Test @@ -98,7 +98,7 @@ public class TestAll { //Program ast = ClassWithMainASTTyped.getProgram(); String className = "DivMethod"; String javacode = "src/test/resources/SimpleTests/DivMethod.java"; - //testByteCodeFromAst(classPath, ast ,className); + //byteCodeTester.testByteCodeFromAst(classPath, ast ,className); byteCodeTester.testClassFileFromScratch(classPath, javacode, className); } @@ -118,10 +118,10 @@ public class TestAll { @Test public void testFieldVar() { String classPath = "src/test/resources/SimpleTests/FieldVar.class"; - //Program ast = ClassWithMainASTTyped.getProgram(); + Program ast = FieldVarASTTyped.getProgram(); String className = "FieldVar"; String javacode = "src/test/resources/SimpleTests/FieldVar.java"; - //testByteCodeFromAst(classPath, ast ,className); + byteCodeTester.testByteCodeFromTypedAst(classPath, ast ,className); byteCodeTester.testClassFileFromScratch(classPath, javacode, className); } @@ -135,6 +135,7 @@ public class TestAll { byteCodeTester.testClassFileFromScratch(classPath, javacode, className); } + @Test public void testGetterFunction() { String classPath = "src/test/resources/SimpleTests/GetterFunction.class"; @@ -158,10 +159,10 @@ public class TestAll { @Test public void testIfElseIfStatementWithOneReturn() { String classPath = "src/test/resources/SimpleTests/IfElseIfStatementWithOneReturn.class"; - //Program ast = ClassWithMainASTTyped.getProgram(); + Program ast = IfElseIfStatementWithOneReturnAST.getProgram(); String className = "IfElseIfStatementWithOneReturn"; String javacode = "src/test/resources/SimpleTests/IfElseIfStatementWithOneReturn.java"; - //testByteCodeFromAst(classPath, ast ,className); + byteCodeTester.testByteCodeFromAst(classPath, ast ,className); byteCodeTester.testClassFileFromScratch(classPath, javacode, className); } @@ -185,17 +186,6 @@ public class TestAll { byteCodeTester.compareJarFilesFromScratch(javacode, jarPath, classNames); } - /* - @Test - public void testDijkstra() { - String jarPath = "src/test/resources/Integration/Dijkstra.jar"; - //Program ast = ClassWithMainASTTyped.getProgram(); - String[] classNames = {"FourClasses", "Test", "Test2", "Test3"}; - String javacode = "src/test/resources/Integration/Dijkstra.java"; - byteCodeTester.compareJarFilesFromScratch(javacode, jarPath, classNames); - } - */ - diff --git a/src/test/java/Typecheck/TestAll.java b/src/test/java/Typecheck/TestAll.java index 9ee8040..686f8b5 100644 --- a/src/test/java/Typecheck/TestAll.java +++ b/src/test/java/Typecheck/TestAll.java @@ -21,44 +21,44 @@ public class TestAll { @Test public void testClassWithMain() { - Program emptyClassAst = ClassWithMainAST.getProgram(); + Program astToBeTested = ClassWithMainAST.getProgram(); Program correctAST = ClassWithMainASTTyped.getProgram(); boolean expectedResult = true; - testTypeCheck(emptyClassAst, correctAST, expectedResult); + testTypeCheck(astToBeTested, correctAST, expectedResult); } @Test public void testEmptyClass() { - Program emptyClassAst = emptyClassAST.getEmptyProgramm(); + Program astToBeTested = emptyClassAST.getEmptyProgramm(); Program correctAST = emptyClassASTTyped.getEmptyProgramm(); boolean expectedResult = false; - testTypeCheck(emptyClassAst, correctAST, expectedResult); + testTypeCheck(astToBeTested, correctAST, expectedResult); } @Test public void testEmptyClassWM() { - Program emptyClassAst = emptyClassAST.getEmptyProgramm(); + Program astToBeTested = emptyClassAST.getEmptyProgramm(); Program correctAST = emptyClassASTTyped.getEmptyProgramm(); boolean expectedResult = true; - testTypeCheckWM(emptyClassAst, correctAST, expectedResult); + testTypeCheckWOM(astToBeTested, correctAST, expectedResult); } @Test public void testEmptyClassWithConstructor(){ - Program abstractSyntaxTree = EmptyClassWithConstructorAST.getProgram(); + Program astToBeTested = EmptyClassWithConstructorAST.getProgram(); Program correctAST = EmptyClassWithConstructorASTTyped.getProgram(); boolean expectedResult = false; - testTypeCheck(abstractSyntaxTree, correctAST, expectedResult); + testTypeCheck(astToBeTested, correctAST, expectedResult); } @Test public void testEmptyClassWithConstructorWM(){ - Program abstractSyntaxTree = EmptyClassWithConstructorAST.getProgram(); + Program astToBeTested = EmptyClassWithConstructorAST.getProgram(); Program correctAST = EmptyClassWithConstructorASTTyped.getProgram(); boolean expectedResult = true; - testTypeCheckWM(abstractSyntaxTree, correctAST, expectedResult); + testTypeCheckWOM(astToBeTested, correctAST, expectedResult); } /* @@ -79,44 +79,78 @@ public class TestAll { @Test public void testAssignWrongType(){ - Program assignWrongType = AssignWrongTypeAST.getProgram(); + Program astToBeTested = AssignWrongTypeAST.getProgram(); Program correctAST = AssignWrongTypeASTTyped.getProgram(); boolean expectedResult = false; - testTypeCheck(assignWrongType, correctAST,expectedResult); + testTypeCheck(astToBeTested, correctAST,expectedResult); } @Test public void testAssignWrongTypeWM(){ - Program assignWrongType = AssignWrongTypeAST.getProgram(); + Program astToBeTested = AssignWrongTypeAST.getProgram(); Program correctAST = AssignWrongTypeASTTyped.getProgram(); boolean expectedResult = false; - testTypeCheckWM(assignWrongType, correctAST, expectedResult); + testTypeCheckWOM(astToBeTested, correctAST, expectedResult); } @Test public void testFakultaet(){ - Program fakultaet = FakultaetAST.getProgram(); + Program astToBeTested = FakultaetAST.getProgram(); Program correctAST = FakultaetASTTyped.getProgram(); boolean expectedResult = true; - testTypeCheck(fakultaet, correctAST, expectedResult); + testTypeCheck(astToBeTested, correctAST, expectedResult); } @Test public void testDivideByZero(){ - Program fakultaet = DivideByZeroAST.getProgram(); + Program astToBeTested = DivideByZeroAST.getProgram(); Program correctAST = DivideByZeroASTTyped.getProgram(); boolean expectedResult = true; - testTypeCheck(fakultaet, correctAST, expectedResult); + testTypeCheck(astToBeTested, correctAST, expectedResult); } @Test public void testCharArgument(){ - Program fakultaet = CharArgumentAST.getProgram(); + Program astToBeTested = CharArgumentAST.getProgram(); Program correctAST = CharArgumentASTTyped.getProgram(); boolean expectedResult = true; - testTypeCheckWOM(fakultaet, correctAST, expectedResult); + testTypeCheckWOM(astToBeTested, correctAST, expectedResult); } + @Test + public void testFieldVar(){ + Program astToBeTested = FieldVarAST.getProgram(); + Program correctAST = FieldVarASTTyped.getProgram(); + boolean expectedResult = true; + testTypeCheckWOM(astToBeTested, correctAST, expectedResult); + } + + @Test + public void testConstructorParams(){ + Program astToBeTested = ConstructorParamsAST.getProgram(); + Program correctAST = ConstructorParamsASTTyped.getProgram(); + boolean expectedResult = true; + testTypeCheckWOM(astToBeTested, correctAST, expectedResult); + } + + @Test + public void testConstructorThisDot(){ + Program astToBeTested = ConstructorThisDotAST.getProgram(); + Program correctAST = ConstructorThisDotASTTyped.getProgram(); + boolean expectedResult = true; + testTypeCheckWOM(astToBeTested, correctAST, expectedResult); + } + + @Test + public void testIfElseIfStatementWithOneReturn(){ + Program astToBeTested = IfElseIfStatementWithOneReturnAST.getProgram(); + Program correctAST = IfElseIfStatementWithOneReturnASTTyped.getProgram(); + boolean expectedResult = true; + testTypeCheckWOM(astToBeTested, correctAST, expectedResult); + } + + + public void testTypeCheckWOM(Program abstractSyntaxTree, Program correctAST, boolean expectedResult) { try { diff --git a/src/test/resources/SimpleTests/FieldVar.java b/src/test/resources/SimpleTests/FieldVar.java index 4c83a9c..2265a3f 100644 --- a/src/test/resources/SimpleTests/FieldVar.java +++ b/src/test/resources/SimpleTests/FieldVar.java @@ -1,5 +1,5 @@ class FieldVar { - int field; + int variable; } diff --git a/src/test/resources/SimpleTests/FieldVar.tokens b/src/test/resources/SimpleTests/FieldVar.tokens index c051299..ef2cd13 100644 --- a/src/test/resources/SimpleTests/FieldVar.tokens +++ b/src/test/resources/SimpleTests/FieldVar.tokens @@ -2,7 +2,7 @@ Class: "class" Identifier: "FieldVar" OpenCurlyBracket: "{" Int: "int" -Identifier: "field" +Identifier: "variable" Semicolon: ";" ClosedCurlyBracket: "}" EOF: "" \ No newline at end of file