Add test cases for semantic analysis

semantic/array_access.java

+class ArrayAccess {
+
+    public static void main(String[] args) {
+        int[] array = new int[3];
+        array[2] = 42;
+        int elem = array[2];
+    }
+}

semantic/array_summation.mj

+class Summator {
+
+    public int sum(int[] array, int len) {
+        int sum = 0;
+        int i = 0;
+        while(i < len) {
+            sum = sum + array[i];
+            i = i + 1;
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+
+        Summator acc = new Summator();
+
+        int arrayLen = System.in.read();
+        int[] array = new int[arrayLen];
+
+        int i = 0;
+        while(i < arrayLen) {
+            array[i] = System.in.read();
+            i = i + 1;
+        }
+
+        int arraySum = acc.sum(array, arrayLen);
+        System.out.write(arraySum);
+        System.out.flush();
+    }
+}

semantic/duplicate_class.invalid.mj

+class DuplicateClass {}
+class DuplicateClass {}

semantic/duplicate_field.invalid.mj

+class DuplicateField {
+
+    public int duplicate;
+    public int duplicate;
+
+    public static void main(String[] args) {}
+}

semantic/empty_while.java

+class EmptyWhile {
+    public static void main(String[] args) {
+        while(true);
+    }
+}

semantic/field_shadowing.java

+class FieldShadowing {
+
+    public int x;
+
+    public static void main(String[] args) {}
+
+    public void test() {
+        int x = 42;
+        this.x = x;
+    }
+}

semantic/invalid_arithmetic_comparison.invalid.mj

+class MismatchingTypeComparison {
+    public static void main(String[] args) {
+        boolean x = false;
+        boolean y = true;
+
+        boolean a;
+
+        a = x < y;
+        a = x <= y;
+        a = x > y;
+        a = x >= y;
+    }
+}

semantic/minimal_valid_program.java

+class MyClass {
+    public static void main(String[] args) {}
+}

semantic/mismatching_return_type.invalid.mj

+class DeepThought {
+    public static void main(String[] args) {
+        DeepThought a = new DeepThought();
+
+        boolean b = a.returnTheAnswer();
+    }
+
+    public int returnTheAnswer() {
+        return 42;
+    }
+}

semantic/mismatching_type_comparison.invalid.mj

+class MismatchingTypeComparison {
+    public static void main(String[] args) {
+        int a = 10;
+        int b = 42;
+
+        boolean x = false;
+        boolean y = true;
+
+        boolean z;
+
+        z = a < x;
+        z = a <= x;
+        z = a > x;
+        z = a >= x;
+
+        z = a != x;
+        z = b != y;
+    }
+}

semantic/missing_static_method.invalid.java

+class MissingStaticMethod {
+    public void test() {
+        int a = 42;
+    }
+}

semantic/multiple_static_methods.invalid.java

+class MultipleStaticMethods {
+    public static void main(String[] args) {}
+    public static void test(String[] args) {}
+}

semantic/redeclaration_parameter.invalid.mj

+class Test {
+    public static void main(String[] args) { }
+
+    public void test(int a) {
+        int a = 23;
+    }
+}

semantic/redeclaration_same_scope.invalid.mj

+class RedeclarationSameScope {
+    public static void main(String[] args) {
+        int a = 0;
+        int a = 42;
+    }
+}

semantic/redeclaration_shadowing.invalid.mj

+class Test {
+    public static void main(String[] args) {
+
+    }
+
+    public void test() {
+        int a = 0;
+
+        {
+            int a = 42;
+        }
+    }
+}

semantic/renamed_main_method.invalid.java

+class Test {
+    public static void test(String[] params) {}
+}

semantic/simple_nested_if_else.java

+class Test {
+    public static void main(String[] args) {}
+
+    public boolean test() {
+        int a = 10;
+        if(a > 0)
+            if(a > 5)
+                return true;
+            else return false;
+        else return true;
+    }
+}

semantic/special_param_usage.invalid.mj

+class SpecialParamUsage {
+    public static void main(String[] args) {
+        String[] myArgs = args;
+    }
+}

semantic/standard_library_calls.mj

+class StandardLibraryCalls {
+    public static void main(String[] args) {
+        int a = 42;
+
+        int b = System.in.read();
+
+        System.out.println(a);
+        System.out.write(a);
+        System.out.flush();
+    }
+}

semantic/static_method_call.invalid.mj

+class StaticMethodCall {
+    public static void main(String[] args) {}
+
+    public void test() {
+        int arg = 10;
+        main(arg);
+    }
+}
+

semantic/static_method_throws.java

+class StaticMethodThrows {
+    public static void main(String[] args) throws RuntimeException {}
+}

semantic/string_usage.invalid.mj

+class StringUsage {
+    public String test;
+    public static void main(String[] args) {}
+}

semantic/usage_before_declaration_field.java

+class UsageBeforeDeclarationField {
+    public static void main(String[] args) {
+        UsageBeforeDeclarationField x = new UsageBeforeDeclarationField();
+        x.test();
+    }
+
+    public void test() {
+        a = 42;
+    }
+
+    public int a;
+}

semantic/usage_before_declaration_method.java

+class UsageBeforeDeclarationMethod {
+    public static void main(String[] args) {}
+
+    public void methodA() {
+        methodB();
+    }
+
+    public void methodB() {
+        methodA();
+    }
+}