Home /Modules/test-suites/test_cli_transpilers.py

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()