qleisli 0.2.2

Experimental quantum language with linear ownership, exact contracts and independent finite IR verification
Documentation
#!/usr/bin/env python3
"""Independent JSON decoding and machine CLI conformance; pass a built binary path."""

import json
import math
import os
from pathlib import Path
import subprocess
import sys
import tempfile
import unittest

BINARY = str(Path(sys.argv.pop(1)).resolve()) if len(sys.argv) > 1 else "target/debug/qleisli"


class JsonCliTests(unittest.TestCase):
    def setUp(self):
        self.directory = tempfile.TemporaryDirectory(prefix="qleisli-json-日本語-")
        self.addCleanup(self.directory.cleanup)
        self.root = Path(self.directory.name)

    def source(self, source):
        (self.root / "main.qli").write_bytes(source.encode("utf-8"))

    def invoke(self, *args, status=0):
        output = subprocess.run([BINARY, *args], capture_output=True, check=False)
        self.assertEqual(output.returncode, status, output)
        self.assertEqual(output.stderr, b"", output)
        self.assertTrue(output.stdout.endswith(b"\n"), output)
        self.assertEqual(output.stdout.count(b"\n"), 1, output)

        def reject_constant(value):
            self.fail(f"Non-JSON number: {value}")

        def unique_object(pairs):
            self.assertEqual(len(pairs), len(dict(pairs)), pairs)
            return dict(pairs)

        result = json.loads(output.stdout, parse_constant=reject_constant, object_pairs_hook=unique_object)
        self.assertEqual(set(result), {"format", "version", "command", "outcome", "diagnostics", "result"})
        self.assertEqual(result["format"], "qleisli.result")
        self.assertEqual(result["version"], 1)
        self.assertEqual(result["outcome"], "error" if status else "ok")
        if status:
            self.assertIsNone(result["result"])
            self.assertTrue(result["diagnostics"])
        else:
            self.assertEqual(result["diagnostics"], [])
        for diagnostic in result["diagnostics"]:
            self.assertEqual(set(diagnostic), {"code", "severity", "message", "primary", "related"})
            self.assertEqual(diagnostic["severity"], "error")
            for related in diagnostic["related"]:
                self.assertEqual(set(related), {"message", "location"})
                self.assertTrue(related["message"].startswith("json_pointer:"))
                self.assertIsNone(related["location"])
            if diagnostic["primary"] is not None:
                self.assertEqual(set(diagnostic["primary"]), {"path", "start", "end", "line", "column"})
        return result

    def test_check_run_and_distribution_order(self):
        self.source("use std::quantum::init0; use std::quantum::h; use std::observe::measure_z;\n"
                    "observe fn main() -> (CBit,CBit) { let a = measure_z(h(init0())); (a,not a) }")
        self.assertEqual(self.invoke("check", self.root, "--format=json")["result"], {"verified": True})
        rows = self.invoke("run", "--format=json", self.root)["result"]["distribution"]
        self.assertEqual([row["bits"] for row in rows], [[False, True], [True, False]])
        for row in rows:
            self.assertEqual(set(row), {"bits", "probability"})
            self.assertTrue(math.isfinite(row["probability"]))
            self.assertAlmostEqual(row["probability"], 0.5)
        self.source("observe fn main() -> Unit { () }")
        self.assertEqual(self.invoke("--format=json", "run", self.root)["result"],
                         {"distribution": [{"bits": [], "probability": 1}]})

    def test_original_byte_spans_and_unicode_scalar_columns(self):
        for source in ["/* 🦀日本語 */ @", "// 日本語\r\nobserve fn main() -> Unit {", "@"]:
            with self.subTest(source=source):
                self.source(source)
                diagnostic = self.invoke("check", self.root, "--format=json", status=1)["diagnostics"][0]
                self.assertEqual(diagnostic["code"], "parse")
                start = source.index("@") if "@" in source else len(source)
                end = start + 1 if "@" in source else start
                self.assertEqual(diagnostic["primary"], {
                    "path": "main.qli", "start": len(source[:start].encode()), "end": len(source[:end].encode()),
                    "line": source[:start].count("\n") + 1, "column": len(source[:start].split("\n")[-1]) + 1,
                })

    def test_truncated_static_arguments_are_located_parse_failures(self):
        for source in ["unitary fn f(q: Q<Bit>) -> Q<Bit> { g[",
                       "unitary fn f(q: Q<Bit>) -> Q<Bit> { g[repeat_op(0,"]:
            self.source(source)
            for command in ["check", "run"]:
                with self.subTest(source=source, command=command):
                    result = self.invoke(command, self.root, "--format=json", status=1)
                    self.assertEqual(len(result["diagnostics"]), 1)
                    diagnostic = result["diagnostics"][0]
                    self.assertEqual(diagnostic["code"], "parse")
                    self.assertEqual(diagnostic["primary"], {
                        "path": "main.qli", "start": len(source), "end": len(source),
                        "line": 1, "column": len(source) + 1,
                    })

    def test_error_categories_and_nested_project_relative_paths(self):
        sources = {
            "type_mismatch": "observe fn main() -> CBit { () }",
            "unknown_name": "observe fn main() -> Unit { missing() }",
            "recursive_call": "unitary fn f() -> Unit { f() }",
            "ownership": "unitary fn f(q:Q<Bit>) -> (Q<Bit>,Q<Bit>) { (q,q) }",
            "effect": "use std::quantum::init0; unitary fn f() -> Q<Bit> { init0() }",
            "arity": "unitary fn f() -> Unit { () } observe fn main() -> Unit { f(true) }",
            "project": "use absent::name;",
        }
        for code, source in sources.items():
            with self.subTest(code=code):
                self.source(source)
                diagnostic = self.invoke("check", self.root, "--format=json", status=1)["diagnostics"][0]
                self.assertEqual(diagnostic["code"], code)
                self.assertEqual(diagnostic["primary"]["path"], "main.qli")
        self.source("")
        (self.root / "nested").mkdir()
        (self.root / "nested" / "module.qli").write_text("unitary fn f() -> Unit { missing() }")
        diagnostic = self.invoke("check", self.root, "--format=json", status=1)["diagnostics"][0]
        self.assertEqual(diagnostic["primary"]["path"], "nested/module.qli")

    def test_project_and_entry_errors_have_no_invented_source_span(self):
        self.source("")
        for command, root, code in [("run", self.root, "invalid_entry"),
                                    ("check", self.root / "missing", "project")]:
            diagnostic = self.invoke(command, root, "--format=json", status=1)["diagnostics"][0]
            self.assertEqual(diagnostic["code"], code)
            self.assertIsNone(diagnostic["primary"])
        (self.root / "main.qli").write_bytes(b"\xff")
        diagnostic = self.invoke("check", self.root, "--format=json", status=1)["diagnostics"][0]
        self.assertEqual(diagnostic["code"], "project")
        self.assertIsNone(diagnostic["primary"])

    def test_usage_and_escaped_command_names(self):
        for command in ["doc", "sample", "emit-ir", 'unknown"\\\n\t日本語']:
            result = self.invoke(command, self.root, "--format=json", status=2)
            self.assertEqual(result["command"], command)
            self.assertEqual(result["diagnostics"][0]["code"], "usage")
        result = self.invoke("--format=json", status=2)
        self.assertEqual(result["command"], "")

    def test_seeded_samples_use_fresh_preparation_and_preserve_correlation(self):
        self.source("use std::quantum::init0; use std::quantum::h; use std::observe::measure_z;\n"
                    "observe fn main() -> (CBit,CBit) { let a = measure_z(h(init0())); (a,not a) }")
        args = ("sample", self.root, "--shots=64", "--seed=18446744073709551615", "--format=json")
        result = self.invoke(*args)["result"]
        self.assertEqual(result, self.invoke(*args)["result"])
        self.assertEqual(set(result), {"rng", "seed", "shots", "execution_steps"})
        self.assertEqual(result["rng"], "splitmix64-v1")
        self.assertEqual(result["seed"], "18446744073709551615")
        self.assertEqual(len(result["shots"]), 64)
        self.assertEqual(result["execution_steps"], sum(s["execution_steps"] for s in result["shots"]))
        for shot in result["shots"]:
            self.assertEqual(set(shot), {"bits", "execution_steps"})
            self.assertNotEqual(*shot["bits"])

    def test_portable_ir_is_independently_decoded_and_reverified(self):
        self.source("observe fn main() -> CBit { true }")
        artifact = self.root / "artifact.json"
        self.assertEqual(self.invoke("emit-ir", self.root, f"--output={artifact}", "--format=json")["result"], {"path": str(artifact)})
        data = json.loads(artifact.read_bytes())
        self.assertEqual(set(data), {"format", "version", "profile", "sources", "programs", "evidence", "root", "root_interface"})
        self.assertEqual(data["format"], "qleisli.finite-ir")
        self.assertEqual(data["version"], 2)
        (self.root / "main.qli").unlink()
        self.assertEqual(self.invoke("verify-ir", artifact, "--format=json")["result"], {"verified": True, "request_checked": False})
        data["programs"][data["root"]]["classical_outputs"] = [4294967295]
        artifact.write_text(json.dumps(data), encoding="utf-8")
        error = self.invoke("verify-ir", artifact, "--format=json", status=1)["diagnostics"][0]
        self.assertEqual(error["code"], "invalid_ir")
        self.assertTrue(error["related"])

    @unittest.skipUnless(os.name == "posix", "raw POSIX argument bytes")
    def test_non_utf8_paths_and_commands(self):
        root = os.fsencode(self.root) + b"/invalid-\xff"
        diagnostic = self.invoke("check", root, "--format=json", status=1)["diagnostics"][0]
        self.assertEqual(diagnostic["code"], "project")
        self.assertIsNone(diagnostic["primary"])
        result = self.invoke(b"check\xff", self.root, "--format=json", status=2)
        self.assertEqual(result["command"], "")

    @unittest.skipUnless(sys.platform.startswith("linux"), "non-UTF-8 filesystem names")
    def test_existing_non_utf8_path_and_stdout_write_failure(self):
        root = os.fsencode(self.root) + b"/invalid-\xff"
        os.mkdir(root)
        with open(root + b"/main.qli", "wb") as source:
            source.write(b"observe fn main() -> Unit { () }")
        self.assertEqual(self.invoke("check", root, "--format=json", status=1)["diagnostics"][0]["code"], "project")
        self.source("observe fn main() -> Unit { () }")
        with open("/dev/full", "wb") as output:
            result = subprocess.run([BINARY, "check", str(self.root), "--format=json"], stdout=output, stderr=subprocess.PIPE)
        self.assertEqual(result.returncode, 1)
        self.assertIn(b"could not write JSON result", result.stderr)


if __name__ == "__main__":
    unittest.main()