test_cli_transpilers.py
test-suites/regression/python/test_cli_transpilers.py · 376 line(s) · py
"""`sleela nordshrift`: the SLeeLa -> {SLeeLa, Java, C} emitters.
Three independent implementations of the same program are compared:
1. the SLeeLa VM (`sleela run`),
2. the emitted Java, compiled with javac and run on the JVM,
3. the emitted C, compiled with the system C compiler,
and, for generated arithmetic, a Python oracle as a fourth witness. Java and C
tests are skipped (visibly) when the tool is not installed.
"""
import random
import shutil
import subprocess
import unittest
import regression_support as rs
from test_cli_language import ProgramTestCase, random_expr
HAVE_JAVA = bool(shutil.which("javac") and shutil.which("java"))
HAVE_CC = bool(shutil.which(rs.CC))
def emit(directory, name, target=None, extra=()):
args = ["nordshrift", *extra]
if target:
args.append(f"--target={target}")
args.append(name)
return rs.run_sleela(args, cwd=directory)
def emitted_text(cp) -> str:
return "\n".join(rs.program_output(cp)) + "\n"
PURE = """class Pure {
static int fib(int n) { if (n < 2) { return n; } return fib(n - 1) + fib(n - 2); }
static int gcd(int a, int b) { if (b == 0) { return a; } return gcd(b, a % b); }
static int ack(int m, int n) { if (m == 0) { return n + 1; } if (n == 0) { return ack(m - 1, 1); } return ack(m - 1, ack(m, n - 1)); }
static int tri(int n) { if (n == 0) { return 0; } return n + tri(n - 1); }
static boolean even(int n) { if (n == 0) { return true; } return odd(n - 1); }
static boolean odd(int n) { if (n == 0) { return false; } return even(n - 1); }
void main() {
print(fib(15)); print(gcd(1071, 462)); print(ack(2, 3)); print(tri(100));
print(even(10)); print(odd(7)); print("tri=" + tri(10));
print(17 % 5); print(0 - 17 % 5); print(0 - 17 / 5); print(3 * 4 + 5 - 6); print(100 / 7 * 7 + 100 % 7);
print(1 < 2); print(2 <= 1); print(3 == 3); print(3 != 3); print(true && false); print(true || false); print(!true);
}
}
"""
PURE_WANT = ["610", "21", "9", "5050", "true", "true", "tri=55", "2", "-2", "-3", "11", "100",
"true", "false", "true", "false", "false", "true", "false"]
ALGO = """class Algo {
static int collatz(int n) { int s = 0; while (n != 1) { if (n % 2 == 0) { n = n / 2; } else { n = 3 * n + 1; } s++; } return s; }
static int sumTo(int n) { int t = 0; for (int i = 1; i <= n; i++) { t += i; } return t; }
static int pick(int a, int b) { return a > b ? a : b; }
static int digits(int n) { int c = 0; while (n > 0) { n = n / 10; c++; } return c; }
void main() {
int k = 0; k += 5; k *= 3; k -= 1; k <<= 2; k ^= 5; k |= 256; k &= 511; k >>= 1; print(k);
print(collatz(27)); print(sumTo(100)); print(pick(3, 9)); print(pick(9, 3)); print(digits(9876543));
int j = 10; j--; --j; ++j; print(j);
for (int i = 0; i < 3; i++) { print("i=" + i); }
int m = 7; int r = m > 5 ? m * 2 : m; print(r);
}
}
"""
def _collatz(n):
s = 0
while n != 1:
n = n // 2 if n % 2 == 0 else 3 * n + 1
s += 1
return s
_k = 0; _k += 5; _k *= 3; _k -= 1; _k <<= 2; _k ^= 5; _k |= 256; _k &= 511; _k >>= 1
ALGO_WANT = [str(_k), str(_collatz(27)), str(sum(range(1, 101))), "9", "9", "7", "9", "i=0", "i=1", "i=2", "14"]
class Emitters(ProgramTestCase):
SOURCES = {
"Hello": 'class Hello { void main() { print("hello"); print(1 + 2); } }',
"Loop": "class Loop { static int sum(int n) { if (n == 0) { return 0; } return n + sum(n - 1); } void main() { print(sum(10)); } }",
"Str": 'class Str { static String g(int n) { if (n == 0) { return "end"; } return "n" + n + "," + g(n - 1); } void main() { print(g(3)); print("a" + 1 + 2); } }',
"Pure": PURE,
"Algo": ALGO,
"Arrays": 'class Arrays { int[] g = {7, 8};\n'
' void main() { int[] a = {1, 2, 3}; int[][] m = {{1, 2}, {3, 4}}; int[] b = new int[3]; int[][] r = new int[2][3]; int[][] j = new int[2][];\n'
' b[0] = a[1] + m[1][0]; b[1] += 5; b[2]++; a[0] = r[1][2]; print(b); print(a.length); print(m[1][1]); print(g[0]); print(j.length); } }',
"DocAnnot": '@scope(system)\n@next(system/net)\npublic class DocAnnot { void main() { print("ok"); } }',
"ClassAnnot": '@scope(a)\nclass ClassAnnot { void main() { print("ok"); } }',
"Obj": 'class B { String hi() { return "b"; } }\n'
'class K extends B { String hi() { return "k"; } }\n'
'class Counter { int v = 1; static int made = 7; int get() { return this.v + 1; }\n'
' static int twice(int x) { return x * 2; } protected static int hidden = 99; static int reveal() { return hidden; } }\n'
'class Obj { void main() { B b = new K(); print(b.hi()); print(new B().hi()); Counter c = new Counter();\n'
' print(c.get()); print(Counter.twice(21)); print(Counter.made); print(Counter.reveal()); } }',
}
def write(self, name):
d = rs.fresh_dir("ns-" + name.lower())
rs.write_program(d, f"{name}.sleela", "#sleela 3.1\n" + self.SOURCES[name])
return d
def test_emitted_sleela_has_the_same_behaviour_as_the_source(self):
for name in self.SOURCES:
d = self.write(name)
run0 = rs.run_sleela(["run", f"{name}.sleela"], cwd=d)
self.assertEqual(run0.returncode, 0, f"{name} (source): {rs.diagnostics(run0)}")
direct = rs.program_output(run0)
first = emit(d, f"{name}.sleela", extra=("--emit",))
self.assertEqual(first.returncode, 0, f"{name}: {rs.diagnostics(first)}")
text = emitted_text(first)
self.assertIn("Generated by Nordshrift (Sleela target)", text)
e = rs.fresh_dir("ns-emitted-" + name.lower())
rs.write_program(e, f"{name}.sleela", "#sleela 3.1\n" + text)
again = rs.run_sleela(["run", f"{name}.sleela"], cwd=e)
self.assertEqual(again.returncode, 0, f"{name}: emitted source does not run: {rs.diagnostics(again)}")
self.assertEqual(rs.program_output(again), direct, f"{name}: emitting changed the behaviour")
def test_roundtrip_reports_structure_preserved_and_runs_identically(self):
for name in self.SOURCES:
d = self.write(name)
direct = rs.program_output(rs.run_sleela(["run", f"{name}.sleela"], cwd=d))
rt = emit(d, f"{name}.sleela", extra=("--roundtrip",))
self.assertEqual(rt.returncode, 0, f"{name}: {rs.diagnostics(rt)}")
self.assertIn("structure preserved", rt.stderr)
self.assertEqual(rs.program_output(rt), direct, f"{name}: round trip changed behaviour")
def test_emit_is_idempotent(self):
"""Regression (was NS-EMIT-BLOCKS): emit(emit(x)) == emit(x), also for if/while bodies."""
for name in self.SOURCES:
d = self.write(name)
first = emit(d, f"{name}.sleela", extra=("--emit",))
self.assertEqual(first.returncode, 0, f"{name}: {rs.diagnostics(first)}")
text = emitted_text(first)
e = rs.fresh_dir("ns-idem-" + name.lower())
rs.write_program(e, f"{name}.sleela", "#sleela 3.1\n" + text)
second = emit(e, f"{name}.sleela", extra=("--emit",))
self.assertEqual(second.returncode, 0, f"{name}: {rs.diagnostics(second)}")
self.assertEqual(emitted_text(second), text, name)
def test_emitter_preserves_modifiers_inheritance_and_member_forms(self):
"""Regression (was NS-EMIT-STATIC / NS-EMIT-QUALIFIED / NS-EMIT-SILENT-DROP)."""
d = self.write("Obj")
text = emitted_text(emit(d, "Obj.sleela", extra=("--emit",)))
for needle in ("class K extends B", "static int twice(int x)", "static int made = 7", "protected static int hidden = 99",
"new K()", "new B().hi()", "b.hi()", "Counter.twice(21)", "Counter.made", "this.v + 1"):
self.assertIn(needle, text)
self.assertNotIn("print()", text)
self.assertNotIn("= ;", text)
def test_loop_program_keeps_static(self):
d = self.write("Loop")
self.assertIn("static int sum(int n)", emitted_text(emit(d, "Loop.sleela", extra=("--emit",))))
def test_emitters_fail_closed_on_unsupported_constructs(self):
# nothing the emitters cannot print may vanish from the output: each case must fail, with no partial output
cases = [
("java", "class B { String h() { return \"b\"; } }\nclass K extends B { String h() { return \"k\"; } }\nclass M { void main() { print(1); } }", "inheritance"),
("c", "class B { String h() { return \"b\"; } }\nclass K extends B { String h() { return \"k\"; } }\nclass M { void main() { print(1); } }", "inheritance"),
("c", "class B { int f() { return 1; } }\nclass M { void main() { B b = new B(); print(b.f()); } }", "expression"),
("java", "class B { int f() { return 1; } }\nclass M { void main() { B b = new B(); print(b.f()); } }", "expression"),
("sleela", "class B { B(int x) { } }\nclass M { void main() { print(1); } }", "constructors"),
("sleela", "interface I { int f(); }\nclass M { void main() { print(1); } }", "interfaces"),
]
for target, body, why in cases:
f = rs.fresh_dir("ns-closed")
rs.write_program(f, "M.sleela", "#sleela 3.1\n" + body)
r = emit(f, "M.sleela", target)
self.assertNotEqual(r.returncode, 0, f"{target}: {why} must be rejected:\n{r.stdout[-300:]}")
self.assertIn("cannot emit", rs.diagnostics(r))
self.assertEqual([l for l in rs.program_output(r) if l.strip()], [], f"{target}: partial output for {why}")
# Arrays pass the shared lowering gate. The C and Sleela targets emit them; the Java target
# refuses: printing an array and widening int to long would not match the VM (a Java array
# prints as an identity hash), so a silent translation would change behaviour.
for target, body, why in (("java", "int[] a = {1, 2}; print(a[0]);", "array access in Java"),):
d = rs.fresh_dir("ns-more")
rs.write_program(d, "T.sleela", f"#sleela 3.1\nclass T {{ void main() {{ {body} }} }}")
cp = emit(d, "T.sleela", target)
self.assertNotEqual(cp.returncode, 0, why)
self.assertTrue("unsupported" in rs.diagnostics(cp) or "cannot emit" in rs.diagnostics(cp)
or "not supported" in rs.diagnostics(cp), why + ": " + rs.diagnostics(cp))
self.assertNotIn("int main", cp.stdout, "no partial C may be emitted")
self.assertNotIn("Generated by Nordshrift", cp.stdout, f"{why}: no partial output may be emitted")
@unittest.skipUnless(HAVE_JAVA, "javac/java not installed")
class JavaTarget(ProgramTestCase):
def java_run(self, directory, cls):
cp = emit(directory, f"{cls}.sleela", "java")
self.assertEqual(cp.returncode, 0, rs.diagnostics(cp))
(directory / f"{cls}.java").write_text(emitted_text(cp))
javac = subprocess.run(["javac", f"{cls}.java"], cwd=directory, capture_output=True, text=True, timeout=180)
self.assertEqual(javac.returncode, 0, javac.stderr)
jvm = subprocess.run(["java", "-cp", ".", cls], cwd=directory, capture_output=True, text=True, timeout=120)
self.assertEqual(jvm.returncode, 0, jvm.stderr)
return jvm.stdout.splitlines()
def test_pure_program_agrees_with_vm_and_oracle(self):
d = rs.fresh_dir("java-pure")
rs.write_program(d, "Pure.sleela", "#sleela 3.1\n" + PURE)
vm = rs.program_output(rs.run_sleela(["run", "Pure.sleela"], cwd=d))
self.assertEqual(vm, PURE_WANT)
self.assertEqual(self.java_run(d, "Pure"), PURE_WANT)
def test_algorithm_with_loops_assignments_and_ternary(self):
d = rs.fresh_dir("java-algo")
rs.write_program(d, "Algo.sleela", "#sleela 3.1\n" + ALGO)
self.assertEqual(rs.program_output(rs.run_sleela(["run", "Algo.sleela"], cwd=d)), ALGO_WANT, "VM vs oracle")
self.assertEqual(self.java_run(d, "Algo"), ALGO_WANT, "JVM vs oracle")
def test_generated_integer_expressions_agree_across_vm_jvm_and_oracle(self):
rng = random.Random(0x7A5A)
exprs = [random_expr(rng, rng.randint(1, 5)) for _ in range(150)]
body = "\n".join(f" print({e.render()});" for e in exprs)
d = rs.fresh_dir("java-expr")
rs.write_program(d, "Ex.sleela", f"#sleela 3.1\nclass Ex {{ void main() {{\n{body}\n }} }}")
want = [str(e.value()) for e in exprs]
self.assertEqual(rs.program_output(rs.run_sleela(["run", "Ex.sleela"], cwd=d)), want, "VM vs oracle")
self.assertEqual(self.java_run(d, "Ex"), want, "JVM vs oracle")
@unittest.skipUnless(HAVE_CC, "C compiler not installed")
class CTarget(ProgramTestCase):
def c_run(self, directory, cls):
cp = emit(directory, f"{cls}.sleela", "c")
self.assertEqual(cp.returncode, 0, rs.diagnostics(cp))
(directory / f"{cls}.c").write_text(emitted_text(cp))
cc = subprocess.run([rs.CC, "-w", "-O1", f"{cls}.c", "-o", cls], cwd=directory, capture_output=True, text=True, timeout=120)
self.assertEqual(cc.returncode, 0, cc.stderr)
run = subprocess.run([f"./{cls}"], cwd=directory, capture_output=True, text=True, timeout=60)
return run
def test_pure_program_agrees_with_vm_and_oracle(self):
d = rs.fresh_dir("c-pure")
rs.write_program(d, "Pure.sleela", "#sleela 3.1\n" + PURE)
run = self.c_run(d, "Pure")
self.assertEqual(run.returncode, 0)
self.assertEqual(run.stdout.splitlines(), PURE_WANT)
def test_algorithm_with_loops_assignments_and_ternary(self):
d = rs.fresh_dir("c-algo")
rs.write_program(d, "Algo.sleela", "#sleela 3.1\n" + ALGO)
run = self.c_run(d, "Algo")
self.assertEqual(run.returncode, 0, run.stderr)
self.assertEqual(run.stdout.splitlines(), ALGO_WANT, "emitted C vs oracle")
def test_bitwise_and_shift_operators_compile_correctly(self):
"""Regression (was NS-C-BITOPS): & | ^ << >> >>> and ~ map to real integer operations."""
d = rs.fresh_dir("c-bits")
rs.write_program(d, "Bits.sleela", "#sleela 3.1\nclass Bits { void main() { print(6 & 3); print(6 ^ 3); print(1 << 4); print(6 | 3);"
" print(0 - 16 >> 2); print(0 - 16 >>> 60); print(~5); print(5 & 0 - 2); print(true && false); print(false || true); } }")
vm = rs.program_output(rs.run_sleela(["run", "Bits.sleela"], cwd=d))
self.assertEqual(vm, ["2", "5", "16", "7", "-4", "15", "-6", "4", "false", "true"])
run = self.c_run(d, "Bits")
self.assertEqual(run.returncode, 0, run.stderr)
self.assertEqual(run.stdout.splitlines(), vm)
def test_generated_integer_expressions_agree_across_vm_c_and_oracle(self):
rng = random.Random(0xC0FFEE)
exprs = [random_expr(rng, rng.randint(1, 5)) for _ in range(150)]
body = "\n".join(f" print({e.render()});" for e in exprs)
d = rs.fresh_dir("c-expr")
rs.write_program(d, "Ex.sleela", f"#sleela 3.1\nclass Ex {{ void main() {{\n{body}\n }} }}")
want = [str(e.value()) for e in exprs]
self.assertEqual(rs.program_output(rs.run_sleela(["run", "Ex.sleela"], cwd=d)), want, "VM vs oracle")
run = self.c_run(d, "Ex")
self.assertEqual(run.returncode, 0, run.stderr)
self.assertEqual(run.stdout.splitlines(), want, "emitted C vs oracle")
def test_arrays_agree_with_vm_and_expected(self):
"""Arrays in the C target (was: rejected): creation, literals, rank 2,
defaults, element compound assignment and ++/--, .length, printing, and
the VM's evaluation order (base, index, value)."""
d = rs.fresh_dir("c-arrays")
rs.write_program(d, "Arr.sleela", "#sleela 3.1\n" + ARRAYS)
vm = rs.program_output(rs.run_sleela(["run", "Arr.sleela"], cwd=d))
self.assertEqual(vm, ARRAYS_WANT, "VM vs expected")
run = self.c_run(d, "Arr")
self.assertEqual(run.returncode, 0, run.stderr)
self.assertEqual(run.stdout.splitlines(), ARRAYS_WANT, "emitted C vs expected")
def test_enhanced_for_over_arrays_agrees_with_the_vm(self):
"""The enhanced for (was: rejected by the C target): sum, nested loops over a rank-2 array, an empty
array, the iterable evaluated once, the loop variable not leaking, and an error from a null iterable."""
body = ("int calls = 0; int[] a = {3, 4, 5}; int t = 0; for (int x : a) { t += x; } print(t); "
"int[][] m = {{1, 2}, {3, 4}}; int u = 0; for (int[] row : m) { for (int y : row) { u = u * 10 + y; } } print(u); "
"int[] e = new int[0]; for (int z : e) { print(\"never\"); } "
"for (int x : a) { a[0] = 99; print(x); } "
"String[] w = {\"p\", \"q\"}; String j = \"\"; for (String s : w) { j += s; } print(j);")
d = rs.fresh_dir("c-foreach")
rs.write_program(d, "Fe.sleela", "#sleela 3.1\nclass Fe { void main() { " + body + " } }")
vm_run = rs.run_sleela(["run", "Fe.sleela"], cwd=d)
self.assertEqual(vm_run.returncode, 0, rs.diagnostics(vm_run))
vm = rs.program_output(vm_run)
self.assertEqual(vm[:3], ["12", "1234", "3"], "VM baseline")
run = self.c_run(d, "Fe")
self.assertEqual(run.returncode, 0, run.stderr)
self.assertEqual(run.stdout.splitlines(), vm, "emitted C vs VM")
def test_array_errors_stop_like_the_vm(self):
cases = (
("int[] a = new int[2]; print(\"before\"); print(a[2]); print(\"after\");", ["before"], "array index out of range"),
("int[] a = new int[1]; a[3] = f(); print(\"after\");", ["rhs"], "array index out of range"),
("int[] a = new int[1]; a[3] += f(); print(\"after\");", [], "array index out of range"),
("int[] a = null; print(a[0]);", [], None),
)
for i, (body, want, message) in enumerate(cases):
d = rs.fresh_dir("c-arrerr")
name = f"E{i}"
rs.write_program(d, f"{name}.sleela", f"#sleela 3.1\nclass {name} {{ static int f() {{ print(\"rhs\"); return 1; }}"
f" void main() {{ {body} }} }}")
vm = rs.run_sleela(["run", f"{name}.sleela"], cwd=d)
self.assertNotEqual(vm.returncode, 0, body)
self.assertEqual(rs.program_output(vm), want, f"VM: {body}")
run = self.c_run(d, name)
self.assertEqual(run.returncode, 1, f"C: {body}")
self.assertEqual(run.stdout.splitlines(), want, f"C: {body}")
if message:
self.assertIn(message, rs.diagnostics(vm))
self.assertIn(message, run.stderr)
def test_value_used_postfix_and_prefix_increments(self):
"""Was rejected: a postfix ++/-- whose value is used."""
src = ("class Inc { void main() { int x = 5; print(x++); print(x); print(x--); print(x); print(++x); print(--x);"
" int y = x++ + x++; print(y); print(x); int i = 0; int[] a = {10, 20, 30};"
" print(a[i++]); print(a[i++]); print(i); print(a[1]++); print(a[1]); print(--a[2]); } }")
want = ["5", "6", "6", "5", "6", "5", "11", "7", "10", "20", "2", "20", "21", "29"]
d = rs.fresh_dir("c-inc")
rs.write_program(d, "Inc.sleela", "#sleela 3.1\n" + src)
self.assertEqual(rs.program_output(rs.run_sleela(["run", "Inc.sleela"], cwd=d)), want, "VM vs expected")
run = self.c_run(d, "Inc")
self.assertEqual(run.returncode, 0, run.stderr)
self.assertEqual(run.stdout.splitlines(), want, "emitted C vs expected")
ARRAYS = """class Arr {
static int calls = 0;
static int tick() { calls++; return calls; }
static int sum(int[] v) { int t = 0; for (int i = 0; i < v.length; i++) { t += v[i]; } return t; }
void main() {
int[] a = new int[5];
for (int i = 0; i < a.length; i++) { a[i] = i * i; }
print(a); print(sum(a));
a[2] += 10; a[3] *= 2; a[4] -= 1; a[1] <<= 3; print(a);
int j = 0;
a[j++] = j; print(a[0]); print(j);
print(a[3]++); print(a[3]); print(++a[3]); print(--a[3]); print(a[3]--); print(a[3]);
int[] b = {3, 1, 2}; print(b.length); print(b[0] + b[1] * b[2]);
int[][] m = new int[2][3]; m[1][2] = 9; m[0][1] += 4; print(m); print(m.length + m[0].length);
int[][] lit = {{1, 2}, {3}}; print(lit); print(lit[1][0]);
int[][] half = new int[2][]; print(half); print(half[0] == null); half[0] = b; print(half);
String[] s = new String[2]; print(s); s[1] = "hi"; print(s); print(s[0] == null); print(s[1] == null);
double[] d = new double[2]; d[1] = 2.5; print(d);
boolean[] z = new boolean[2]; z[0] = true; print(z);
int[] e = new int[0]; print(e); print(e.length);
print(a == a); print(a == b);
int[] c = {tick(), tick(), tick()}; print(c);
a[tick()] = tick(); print(a); print(calls);
String t = null; print(t); print(t == null); String u = "x"; print(u == null);
int k = 0; while (k < 3) { b[k]++; k++; } print(b);
}
}
"""
ARRAYS_WANT = [
"[0, 1, 4, 9, 16]", "30", "[0, 8, 14, 18, 15]", "1", "1",
"18", "19", "20", "19", "19", "18",
"3", "5", "[[0, 4, 0], [0, 0, 9]]", "5", "[[1, 2], [3]]", "3",
"[null, null]", "true", "[[3, 1, 2], null]",
"[null, null]", "[null, hi]", "true", "false",
"[0, 2.5]", "[true, false]", "[]", "0", "true", "false",
"[1, 2, 3]", "[1, 8, 14, 18, 5]", "5",
"null", "true", "false", "[4, 2, 3]",
]
if __name__ == "__main__":
unittest.main()