added semantic tests of group 5

semantic/AcceptableConstants.valid.mj

+/* OK but maybe warnings */
+
+class Main {
+	public static void main(String[] args) {
+		int i = -2147483648;
+		i = 2147483647;
+
+		i = -2147483648 - 1;
+		i = 2147483647 + 1;
+
+		i = 1000000000 * 10000000;
+		i = -1000000000 * -10000000;
+		i = 1000000000 * -10000000;
+
+		i = 1000 / 0;
+		i = 1000 % 0;
+		
+		i = 0 * 1000000000 * 1000000000;
+	}
+}

semantic/ArgsUsageInBody.invalid.mj

+/* `args` may not be used in the main body. */
+class main {
+    public void foo(String[] args) {
+
+    }
+
+    public static void main(String[] args) {
+        main main = new main();
+        main.foo(args);
+    }
+}

semantic/ArrayAccessInExpressionStatement.invalid.mj

+/* Array access is not allowed in expression statements. */
+
+class Main {
+	public static void main(String[] args) {
+		int[] i = new int[10];
+
+		i[123];
+	}
+}

semantic/ArrayLengthIsNotAllowed.invalid.mj

+/* This should fail because array objects don't have an length attribute. */
+
+class Main {
+	public static void main(String[] args) {
+		int[] foo = new int[123];
+
+		int length = foo.length;
+	}
+}

semantic/BoolAssignmentInIf.valid.mj

+/* OK */
+
+class Main {
+	public static void main(String[] args) {
+		boolean b;
+
+		if (b = true) System.out.println(123);
+	}
+}

semantic/CompilerBuiltins.valid.mj

+/* OK */
+
+class Main {
+	public static void main(String[] args) {
+		int x = System.in.read();
+		System.out.println(x);
+		System.out.write(x);
+		System.out.flush();
+	}
+}

semantic/CompilerBuiltinsOverriding1.valid.mj

+/* OK */
+
+class System {
+
+}
+
+class Main {
+	public Main in;
+	public Main out;
+
+	public int read(int x) {
+		return x;
+	}
+
+	public int println(int x) {
+		return x;
+	}
+
+	public int write(int x) {
+		return x;
+	}
+
+	public void flush(int x) {
+
+	}
+
+	public static void main(String[] args) {
+		Main System = new Main();
+		int x = System.in.read(0);
+		x = System.out.println(x);
+		x = System.out.write(x);
+		System.out.flush(x);
+	}
+}

semantic/CompilerBuiltinsOverriding2.valid.mj

+/* OK */
+
+class System {
+
+}
+
+class Main {
+	public Main System;
+	public Main in;
+	public Main out;
+
+	public int read(int x) {
+		return x;
+	}
+
+	public int println(int x) {
+		return x;
+	}
+
+	public int write(int x) {
+		return x;
+	}
+
+	public void flush(int x) {
+
+	}
+
+	public void foo() {
+		int x = System.in.read(0);
+		x = System.out.println(x);
+		x = System.out.write(x);
+		System.out.flush(x);
+	}
+
+	public static void main(String[] args) {
+		Main System = new Main();
+		System.in = new Main();
+		System.in.foo();
+	}
+}

semantic/CompilerBuiltinsOverriding3.valid.mj

+/* OK */
+
+class System {
+
+}
+
+class Main {
+	public Main in;
+	public Main out;
+
+	public int read(int x) {
+		return x;
+	}
+
+	public int println(int x) {
+		return x;
+	}
+
+	public int write(int x) {
+		return x;
+	}
+
+	public void flush(int x) {
+
+	}
+
+	public void foo(Main System) {
+		int x = System.in.read(0);
+		x = System.out.println(x);
+		x = System.out.write(x);
+		System.out.flush(x);
+	}
+
+	public static void main(String[] args) {
+		Main System = new Main();
+		System.in = new Main();
+		System.in.foo(System.in);
+	}
+}

semantic/CompilerBuiltinsOverriding4.invalid.mj

+/* When a System type is present, System.in refers to a static field within System
+* (which does not exist in Mini-Java), and should hence fail instead of succeed
+* like if the builtin method was used instead. */
+
+class System {
+
+}
+
+class Main {
+	public static void main(String[] args) {
+		int x = System.in.read();
+	}
+}

semantic/ConstantTooLarge.invalid.mj

+/* largest int constant is 2147483647 */
+
+class Main {
+	public static void main(String[] args) {
+		int i = 2147483648;
+	}
+}

semantic/ConstantTooSmall.invalid.mj

+/* smallest integer constant is -2147483648 */
+
+class Main {
+	public static void main(String[] args) {
+		int i = -2147483649;
+	}
+}

semantic/DisallowedMethodOverloading.invalid.mj

+/* Method overloading is not allowed */
+
+class Foo {
+	public int i;
+
+	public void bar() {
+
+	}
+
+	public void bar(int x) {
+
+	}
+}
+
+class Main {
+	public static void main(String[] args) {
+		Foo foo = new Foo();
+	}
+}

semantic/DuplicateFields.invalid.mj

+/* Duplicate fields are not allowed. */
+
+class Main {
+
+	public int foo;
+	public int foo;
+
+	public static void main(String[] args) {
+
+	}
+}

semantic/DuplicateParams.invalid.mj

+/* Duplicate parameters are not allowed. */
+
+class Main {
+
+	public void foo(int foobar, int foobar) {
+
+	}
+
+	public static void main(String[] args) {
+
+	}
+}

semantic/FlushWithArg.invalid.mj

+/* flush takes no arguments */
+
+class Main {
+	public static void main(String[] args) {
+		System.out.flush(234);
+	}
+}

semantic/IndefiniteAssignment.valid.mj

+/* OK */
+
+class Main {
+	public Main m;
+	public int foobar1;
+	public boolean foobar2;
+
+	public void foo() {
+		System.out.println(foobar1);
+		System.out.println(m.foobar1);
+		if (foobar2) {
+			foobar1 = 1;
+		} else {
+			foobar1 = 2;
+		}
+		System.out.println(foobar1);
+	}
+
+	public static void main(String[] args) {
+		int foo;
+		boolean bar;
+		Main m;
+		System.out.println(foo);
+		System.out.println(m.foobar1);
+		if (bar) {
+			foo = 1;
+		} else {
+			foo = 2;
+		}
+		System.out.println(foo);
+	}
+}

semantic/IntAssignmentInIf.invalid.mj

+/* This should fail because int expression in if condition. */
+
+class Main {
+	public static void main(String[] args) {
+		int x;
+
+		if (x = 22) System.out.println(123);
+	}
+}

semantic/InvalidAssignment1.invalid.mj

+/* Some assignments are not allowed. */
+
+class Main {
+	public static void main(String[] args) {
+		boolean x = true;
+		x || x = true;
+	}
+}

semantic/InvalidAssignment10.invalid.mj

+/* Some assignments are not allowed. */
+
+class Main {
+	public void foo() {
+		this = new Main();
+	}
+
+	public static void main(String[] args) {
+
+	}
+}