pyscriptc 0.1.0__py3-none-any.whl

pyscriptc/__init__.py

@@ -0,0 +1,3 @@
+"""Spike compiler: CPython ast to a Python typed IR to LLVM."""
+
+__version__ = "0.1.0"

pyscriptc/__main__.py

@@ -0,0 +1,3 @@
+from pyscriptc.cli import main
+
+raise SystemExit(main())

pyscriptc/_posthog_token.py

@@ -0,0 +1 @@
+TOKEN = "phc_yqbYPqN9SbrYLd4A3HKwoRFqzfe9Q5LiMbKg3QBrYKVc"

pyscriptc/builtins.py

@@ -0,0 +1,156 @@
+"""Closed builtin and method tables.
+
+A name is lowered only when it is listed here. `len` of `str` and `len` of a
+list are different operations; both are listed. Anything else stays a fence.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Codes match ps_rt.c. Exception is the wildcard handler and a raise target.
+EXCEPTIONS: dict[str, int] = {
+    "ValueError": 1,
+    "IndexError": 2,
+    "KeyError": 3,
+    "OverflowError": 4,
+    "ZeroDivisionError": 5,
+    "RuntimeError": 6,
+    "Exception": 7,
+}
+
+# User exception classes take codes from here up; matches PS_USER_BASE in
+# ps_rt.h. Exception handlers treat every code at or above it as an
+# Exception descendant, since all user exceptions inherit a lowered builtin.
+USER_EXC_BASE = 8
+
+# params are type kinds. return is a type kind, or "self" for the receiver's type.
+STR_METHODS: dict[str, dict[str, Any]] = {
+    "strip": {"params": [], "return": "self"},
+    "lstrip": {"params": [], "return": "self"},
+    "rstrip": {"params": [], "return": "self"},
+    "upper": {"params": [], "return": "self"},
+    "lower": {"params": [], "return": "self"},
+    "startswith": {"params": ["self"], "return": "bool"},
+    "endswith": {"params": ["self"], "return": "bool"},
+    "find": {"params": ["self"], "return": "int"},
+    "replace": {"params": ["self", "self"], "return": "self"},
+    "count": {"params": ["self"], "return": "int"},
+    "index": {"params": ["self"], "return": "int"},
+    "rfind": {"params": ["self"], "return": "int"},
+    "isdigit": {"params": [], "return": "bool"},
+    "isalpha": {"params": [], "return": "bool"},
+    "isalnum": {"params": [], "return": "bool"},
+    "isspace": {"params": [], "return": "bool"},
+    "isupper": {"params": [], "return": "bool"},
+    "islower": {"params": [], "return": "bool"},
+    "title": {"params": [], "return": "self"},
+    "capitalize": {"params": [], "return": "self"},
+    # casefold is str-only in CPython; the "kinds" gate keeps bytes.casefold fenced.
+    "casefold": {"params": [], "return": "self", "kinds": {"str"}},
+    "swapcase": {"params": [], "return": "self"},
+    "zfill": {"params": ["int"], "return": "self"},
+    "removeprefix": {"params": ["self"], "return": "self"},
+    "removesuffix": {"params": ["self"], "return": "self"},
+    "splitlines": {"params": [], "return": "self_list"},
+}
+
+LEN_KINDS = {"str", "bytes", "list", "dict"}
+
+
+def _len_ok(typ: dict[str, Any]) -> bool:
+    if typ["kind"] in LEN_KINDS:
+        return True
+    return typ["kind"] == "class" and typ.get("name") == "Deque"
+
+
+def builtin_spec(name: str, arg_types: list[dict[str, Any]]) -> dict[str, Any] | None:
+    """Return the result type of a builtin call, or None when it is not lowered."""
+
+    if name == "len" and len(arg_types) == 1 and _len_ok(arg_types[0]):
+        return {"kind": "int"}
+    if name == "int" and len(arg_types) == 1 and arg_types[0]["kind"] in {"float", "bytes", "str"}:
+        return {"kind": "int"}
+    if name == "float" and len(arg_types) == 1 and arg_types[0]["kind"] in {"int", "str"}:
+        return {"kind": "float"}
+    if (
+        name == "str"
+        and len(arg_types) == 1
+        and arg_types[0]["kind"]
+        in {
+            "str",
+            "int",
+            "float",
+            "bool",
+            "bytes",
+            "none",
+        }
+    ):
+        return {"kind": "str"}
+    if name == "str" and len(arg_types) == 1 and arg_types[0]["kind"] == "class" and arg_types[0].get("name") == "Path":
+        return {"kind": "str"}
+    return None
+
+
+def method_spec(receiver: dict[str, Any], name: str, arg_types: list[dict[str, Any]]) -> dict[str, Any] | None:
+    if receiver["kind"] not in {"str", "bytes"}:
+        return None
+    if name == "encode":
+        # One optional str encoding argument; the value is checked in _call_attr.
+        if receiver["kind"] != "str" or len(arg_types) > 1:
+            return None
+        if arg_types and arg_types[0]["kind"] != "str":
+            return None
+        return {"kind": "bytes"}
+    if name == "decode":
+        if receiver["kind"] != "bytes" or len(arg_types) > 1:
+            return None
+        if arg_types and arg_types[0]["kind"] != "str":
+            return None
+        return {"kind": "str"}
+    if name in {"split", "rsplit"}:
+        # split([sep [, maxsplit]]); sep None is not a lowered type, so the
+        # whitespace form stays the 0-arg call.
+        if len(arg_types) > 2:
+            return None
+        if len(arg_types) >= 1 and arg_types[0]["kind"] != receiver["kind"]:
+            return None
+        if len(arg_types) == 2 and arg_types[1]["kind"] != "int":
+            return None
+        return {"kind": "list", "elem": {"kind": receiver["kind"]}}
+    if name in {"ljust", "rjust", "center"}:
+        if not 1 <= len(arg_types) <= 2:
+            return None
+        if arg_types[0]["kind"] != "int":
+            return None
+        if len(arg_types) == 2 and arg_types[1]["kind"] != receiver["kind"]:
+            return None
+        return {"kind": receiver["kind"]}
+    if name == "expandtabs":
+        if len(arg_types) > 1 or (arg_types and arg_types[0]["kind"] != "int"):
+            return None
+        return {"kind": receiver["kind"]}
+    if name == "join":
+        if len(arg_types) != 1 or arg_types[0]["kind"] != "list":
+            return None
+        if arg_types[0]["elem"]["kind"] != receiver["kind"]:
+            return None
+        return {"kind": receiver["kind"]}
+    if name not in STR_METHODS:
+        return None
+    spec = STR_METHODS[name]
+    if receiver["kind"] not in spec.get("kinds", {"str", "bytes"}):
+        return None
+    if len(arg_types) != len(spec["params"]):
+        return None
+    for got, want in zip(arg_types, spec["params"], strict=True):
+        if want == "self":
+            if got["kind"] != receiver["kind"]:
+                return None
+        elif got["kind"] != want:
+            return None
+    if spec["return"] == "self":
+        return {"kind": receiver["kind"]}
+    if spec["return"] == "self_list":
+        return {"kind": "list", "elem": {"kind": receiver["kind"]}}
+    return {"kind": spec["return"]}

pyscriptc/canonical.py

@@ -0,0 +1,167 @@
+"""Canonical form of the JSON IR and its stable hash.
+
+Probes compare compiler runs across invocations, so the IR they digest must
+not carry anything incidental: spans name the invocation directory, the
+cpython stamp tracks the interpreter rather than the compiler, and package
+merge notes are stderr material. The rules and the full key vocabulary live
+in docs/ir-canonicity.md; this module is that document in code.
+
+The hash is schema-versioned (the sccache FORMAT_VERSION pattern): a change
+to the canonicalization rules rekeys every digest instead of masquerading as
+a compiler change.
+"""
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+import os
+import sys
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+CANONICAL_SCHEMA_VERSION = "canonical-schema/2"
+
+# Schema/2: environment-derived absolute paths reaching IR string constants
+# (stdmore.py reads sys.prefix / sys.executable at compile time) are replaced
+# with this placeholder so the digest cannot depend on the checkout or venv
+# location. Decision 2026-10-16.
+_PATH_PLACEHOLDER = "<PATH>"
+
+# Keys removed at every nesting depth. `span` rides on functions, classes,
+# statements, expressions and fence records; the rest are module level only.
+_STRIP_KEYS = frozenset({"span", "sourceFile", "cpython", "_notes"})
+
+
+def canonicalize(module: dict[str, Any]) -> dict[str, Any]:
+    """Return a canonical deep copy: incidental keys stripped, orders normalized.
+
+    - every `span`, plus top-level `sourceFile`, `cpython`, `_notes`, gone;
+    - every substring of an environment absolute path (sys.executable,
+      sys._base_executable, sys.exec_prefix, sys.prefix, cwd, the pyscriptc
+      checkout root) in any string value is replaced by `<PATH>`; longest
+      first so an executable path is consumed before its prefix runs;
+    - `classes` sorted by `name` (synthetic class order leaks a set iteration
+      order at lower.py:607);
+    - every try-handler's `codes` list sorted (same leak via self.classes);
+    - `fences` sorted by (code, message, function or "", span.line, span.col),
+      computed before spans are stripped because `function` may be None.
+
+    Idempotent: canonicalize(canonicalize(x)) == canonicalize(x). The input
+    dict is never mutated.
+    """
+    out = _strip(module)
+    classes = out.get("classes")
+    if isinstance(classes, list):
+        out["classes"] = sorted(classes, key=lambda cls: cls.get("name") or "")
+    for stmt in _walk_stmts(out):
+        for handler in stmt.get("handlers", ()):
+            if isinstance(handler, dict) and isinstance(handler.get("codes"), list):
+                handler["codes"] = sorted(handler["codes"])
+    fences = out.get("fences")
+    if isinstance(fences, list):
+        out["fences"] = sorted(
+            fences,
+            key=lambda fence: (
+                fence.get("code") or "",
+                fence.get("message") or "",
+                fence.get("function") or "",
+                fence.get("span", {}).get("line", 0),
+                fence.get("span", {}).get("col", 0),
+            ),
+        )
+    return _scrub_paths(out)
+
+
+def hash_module(module: dict[str, Any]) -> str:
+    """SHA-256 hex of the schema-versioned canonical form of a module IR dict."""
+    canonical = {
+        "schema": CANONICAL_SCHEMA_VERSION,
+        "ir": canonicalize(module),
+    }
+    # allow_nan=False on purpose: a NaN reaching IR means a compiler bug and
+    # should surface here instead of silently hashing into a digest.
+    payload = json.dumps(canonical, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False)
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+@lru_cache(maxsize=1)
+def _env_paths() -> tuple[str, ...]:
+    """Every absolute path this environment could leak into IR strings.
+
+    Realpath and as-given variants both (macOS /tmp is a symlink), longest
+    first so a path nested under another is replaced before its container.
+    Cached: sys.prefix etc. cannot change inside one process.
+    """
+
+    roots: list[str] = []
+    for raw in (
+        getattr(sys, "executable", ""),
+        getattr(sys, "_base_executable", ""),
+        getattr(sys, "exec_prefix", ""),
+        getattr(sys, "prefix", ""),
+        os.getcwd(),
+        _checkout_root(),
+    ):
+        if not raw:
+            continue
+        roots.append(os.path.normpath(raw))
+        real = os.path.realpath(raw)
+        if real != roots[-1]:
+            roots.append(real)
+    # Drop paths contained in a longer candidate: replacing the container
+    # first would strand the remainder of the shorter one as plain text.
+    return tuple(sorted(set(roots), key=len, reverse=True))
+
+
+def _checkout_root() -> str:
+    """Repository root found by walking up from this file to a pyproject.toml."""
+
+    for parent in Path(__file__).resolve().parents:
+        if (parent / "pyproject.toml").is_file():
+            return str(parent)
+    return ""
+
+
+def _scrub_paths(value: Any) -> Any:
+    """Replace environment path substrings in every string value (keys are
+    structural: the IR key vocabulary is fixed and never carries paths)."""
+
+    if isinstance(value, dict):
+        return {k: _scrub_paths(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_scrub_paths(item) for item in value]
+    if isinstance(value, str):
+        for path in _env_paths():
+            if path in value:
+                value = value.replace(path, _PATH_PLACEHOLDER)
+        return value
+    return value
+
+
+def _strip(value: Any) -> Any:
+    """Deep copy `value` dropping every _STRIP_KEYS member at any depth."""
+    if isinstance(value, dict):
+        return {k: _strip(v) for k, v in value.items() if k not in _STRIP_KEYS}
+    if isinstance(value, list):
+        return [_strip(item) for item in value]
+    if isinstance(value, tuple):
+        return [_strip(item) for item in value]
+    return copy.copy(value)
+
+
+def _walk_stmts(value: Any):
+    """Yield every dict that looks like a statement node, recursively."""
+    if isinstance(value, dict):
+        if isinstance(value.get("kind"), str) and "handlers" in value:
+            yield value
+            for handler in value["handlers"]:
+                yield from _walk_stmts(handler.get("body"))
+        else:
+            for child in value.values():
+                yield from _walk_stmts(child)
+    elif isinstance(value, (list, tuple)):
+        for item in value:
+            yield from _walk_stmts(item)

pyscriptc/check.py

@@ -0,0 +1,49 @@
+"""Checker preflight.
+
+mypy is a subprocess. Its AST is not an input to lowering. A bad annotation
+fails the build before LLVM emission.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+class CheckFailed(Exception):
+    def __init__(self, output: str) -> None:
+        super().__init__(output)
+        self.output = output
+
+
+def run_checker(path: Path, checker: str = "mypy") -> None:
+    if checker != "mypy":
+        raise CheckFailed(f"checker {checker!r} is not wired; the spike preflight uses mypy")
+    with tempfile.TemporaryDirectory(prefix="pyscriptc-mypy-") as cache:
+        proc = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "mypy",
+                "--show-error-codes",
+                "--hide-error-context",
+                "--no-error-summary",
+                "--follow-imports=silent",
+                "--cache-dir",
+                cache,
+                "--no-incremental",
+                str(path),
+            ],
+            capture_output=True,
+            text=True,
+        )
+    if proc.returncode == 0:
+        return
+    output = (proc.stdout or proc.stderr).strip()
+    if not output:
+        output = proc.stderr.strip() or f"mypy exited {proc.returncode}"
+    if "No module named mypy" in output:
+        output = "mypy is not installed for this interpreter"
+    raise CheckFailed(output)

pyscriptc/cli.py

@@ -0,0 +1,271 @@
+"""Command line for the spike compiler."""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from pyscriptc import telemetry
+from pyscriptc.check import CheckFailed, run_checker
+from pyscriptc.coverage import build_report, render_text
+from pyscriptc.debug import Debug, resolve
+from pyscriptc.diagnostics import explain
+from pyscriptc.errors import FitError, IRError, SpikeError, VersionError
+from pyscriptc.ir import validate_module
+from pyscriptc.llvm import emit_llvm, link_binary
+from pyscriptc.log import enable_debug, get_logger, tail
+from pyscriptc.lower import lower_file, render_fences
+from pyscriptc.package import lower_directory
+
+log = get_logger()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="pyscriptc",
+        description="Lower a typed Python subset to IR and LLVM.",
+    )
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("-v", "--verbose", action="store_true", help="enable DEBUG audit records")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    compile_parser = sub.add_parser("compile", help="lower a source file", parents=[common])
+    compile_parser.add_argument("source")
+    compile_parser.add_argument("--emit", choices=("ir", "llvm", "bin"), default="llvm")
+    compile_parser.add_argument("-o", dest="output")
+    compile_parser.add_argument("--call", help="function the generated main calls")
+    compile_parser.add_argument(
+        "--args",
+        default="[]",
+        help="Python literal list of arguments for --call, parsed with ast.literal_eval",
+    )
+    compile_parser.add_argument("--run", action="store_true", help="compile a binary and run it")
+    compile_parser.add_argument(
+        "--driver",
+        choices=("clang", "zig"),
+        default="clang",
+        help="C toolchain driver; zig means `zig cc` (required for --target)",
+    )
+    compile_parser.add_argument(
+        "--target",
+        help="cross-compilation triple for `zig cc`, e.g. aarch64-linux-gnu.2.39",
+    )
+    compile_parser.add_argument("--skip-check", action="store_true")
+    compile_parser.add_argument("--checker", default="mypy")
+    compile_parser.add_argument(
+        "--debug",
+        nargs="?",
+        const="",
+        default=None,
+        metavar="WHAT",
+        help="print a compact stage table to stderr; WHAT is a comma list of "
+        "stages,fences,cc,paths,all (also via PYSC_DEBUG)",
+    )
+    compile_parser.add_argument(
+        "--debug-dir",
+        metavar="DIR",
+        help="write debug artifacts (ir.json, out.ll, cc.sh, summary.json) to DIR",
+    )
+    coverage_parser = sub.add_parser("coverage", help="report every fence in a file or package tree", parents=[common])
+    coverage_parser.add_argument("source")
+    coverage_parser.add_argument("--json", action="store_true", help="print the report as JSON")
+    explain_parser = sub.add_parser("explain", help="describe a diagnostic code", parents=[common])
+    explain_parser.add_argument("code")
+    sub.add_parser("logs", help="print the audit-log path and its last lines", parents=[common])
+    telemetry_parser = sub.add_parser("telemetry", help="anonymous usage metrics opt-out")
+    telemetry_parser.add_argument("action", choices=("disable", "enable", "status"))
+    try:
+        args = parser.parse_args(argv)
+        if getattr(args, "verbose", False):
+            enable_debug()
+        log.info("cli.invoke", cmd=args.cmd)
+        telemetry.maybe_print_notice()
+        telemetry.track("cli.invoked", {"subcommand": args.cmd, **telemetry.base_properties()})
+        if args.cmd == "compile":
+            return compile_cmd(args)
+        if args.cmd == "coverage":
+            return coverage_cmd(args)
+        if args.cmd == "explain":
+            return explain_cmd(args)
+        if args.cmd == "logs":
+            return logs_cmd(args)
+        if args.cmd == "telemetry":
+            return telemetry.telemetry_cmd(args.action)
+    except CheckFailed as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+    except (VersionError, FitError) as exc:
+        print(str(exc), file=sys.stderr)
+        return 4
+    except SpikeError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+    return 2
+
+
+def coverage_cmd(args: argparse.Namespace) -> int:
+    report = build_report(Path(args.source))
+    log.info("coverage.report", source=args.source)
+    print(json.dumps(report, indent=2) if args.json else render_text(report))
+    return 0
+
+
+def explain_cmd(args: argparse.Namespace) -> int:
+    text = explain(args.code)
+    log.info("explain.lookup", code=args.code, known=text is not None)
+    if text is None:
+        print(f"unknown diagnostic code: {args.code}", file=sys.stderr)
+        return 2
+    print(text)
+    return 0
+
+
+def logs_cmd(args: argparse.Namespace) -> int:
+    tail()
+    return 0
+
+
+def compile_cmd(args: argparse.Namespace) -> int:
+    started = time.monotonic()
+    state: dict[str, Any] = {"ok": False, "fence_code": None, "ran_bytes": None}
+    try:
+        rc = _compile_cmd(args, state)
+        state["ok"] = rc == 0
+        return rc
+    finally:
+        properties: dict[str, Any] = {
+            "duration_ms": int((time.monotonic() - started) * 1000),
+            "ok": state["ok"],
+        }
+        if state["fence_code"]:
+            properties["fence_code"] = state["fence_code"]
+        telemetry.track("compile.finished", properties)
+        if state["ran_bytes"] is not None:
+            telemetry.track("compile.ran", {"binary_bytes": state["ran_bytes"]})
+
+
+def _compile_cmd(args: argparse.Namespace, state: dict[str, Any]) -> int:
+    try:
+        dbg = resolve(args.debug, args.debug_dir)
+    except ValueError as exc:
+        raise IRError(str(exc)) from exc
+    if dbg is None:
+        dbg = Debug(set(), None)
+    source_path = Path(args.source)
+    log.info(
+        "compile.start",
+        source=str(source_path),
+        emit=args.emit,
+        run=args.run,
+        driver=args.driver,
+        target=args.target,
+        checker=None if args.skip_check else args.checker,
+    )
+    module: dict[str, Any] | None = None
+    llvm_text: str | None = None
+    outputs: dict[str, str] = {}
+    status = "ok"
+    try:
+        dbg.begin("lower")
+        if source_path.is_dir():
+            module, source = lower_directory(source_path)
+        elif source_path.is_file():
+            module, source = lower_file(str(source_path))
+        else:
+            raise IRError(f"source not found: {source_path}")
+        dbg.end("lower")
+        if args.run:
+            args.emit = "bin"
+        for note in module.pop("_notes", []):
+            print(note, file=sys.stderr)
+        if not args.skip_check:
+            dbg.begin("check")
+            run_checker(source_path, args.checker)
+            dbg.end("check")
+        dbg.begin("validate")
+        validate_module(module)
+        dbg.end("validate")
+        ir_path = _output_path(args, source_path, ".ir.json")
+        ir_path.parent.mkdir(parents=True, exist_ok=True)
+        ir_path.write_text(json.dumps(module, indent=2) + "\n", encoding="utf-8")
+        outputs["ir"] = str(ir_path)
+        if module["fences"]:
+            state["fence_code"] = module["fences"][0].get("code")
+            log.info(
+                "check.fences",
+                count=len(module["fences"]),
+                codes=[fence["code"] for fence in module["fences"]],
+            )
+            print(render_fences(module, source), file=sys.stderr)
+            status = "fences"
+            return 3
+        log.info("emit.ir", output=str(ir_path))
+        if args.emit == "ir":
+            print(ir_path)
+            return 0
+        call_args = _parse_args(args.args) if args.call else None
+        dbg.begin("emit_llvm")
+        llvm_text = emit_llvm(module, args.call, call_args, standalone=args.emit == "bin")
+        dbg.end("emit_llvm")
+        ll_path = _output_path(args, source_path, ".ll")
+        ll_path.write_text(llvm_text, encoding="utf-8")
+        outputs["ll"] = str(ll_path)
+        log.info("emit.llvm", output=str(ll_path))
+        if args.emit == "llvm":
+            print(ll_path)
+            return 0
+        binary = Path(args.output) if args.output else source_path.with_suffix("")
+        dbg.begin("link")
+        link_binary(ll_path, binary, driver=args.driver, target=args.target, record=dbg.commands)
+        dbg.end("link")
+        outputs["bin"] = str(binary)
+        log.info("link.binary", output=str(binary), driver=args.driver, target=args.target)
+        try:
+            state["ran_bytes"] = binary.stat().st_size
+        except OSError:
+            pass
+        if not args.run:
+            print(binary)
+            return 0
+        log.info("run.start", binary=str(binary))
+        dbg.begin("run")
+        completed = subprocess.run([str(binary.absolute())])
+        dbg.end("run")
+        code = 128 + (-completed.returncode) if completed.returncode < 0 else completed.returncode
+        log.info("run.exit", binary=str(binary), code=code)
+        return code
+    except Exception:
+        status = "error"
+        raise
+    finally:
+        report = dbg.render(module, outputs)
+        if report:
+            print(report, file=sys.stderr)
+        dbg.write_dir(module, llvm_text, outputs, status)
+
+
+def _parse_args(text: str) -> list[Any]:
+    try:
+        value = ast.literal_eval(text)
+    except (SyntaxError, ValueError) as exc:
+        raise IRError(f"--args is not a Python literal: {exc}") from exc
+    if not isinstance(value, list):
+        raise IRError("--args must be a list literal")
+    return list(value)
+
+
+def _output_path(args: argparse.Namespace, source: Path, suffix: str) -> Path:
+    if args.output and args.emit == "ir" and suffix == ".ir.json":
+        return Path(args.output)
+    if args.output and args.emit == "llvm" and suffix == ".ll":
+        return Path(args.output)
+    if args.output and suffix == ".ll":
+        return Path(str(args.output) + ".ll")
+    if args.output and suffix == ".ir.json":
+        return Path(str(args.output) + ".ir.json")
+    return source.with_suffix(suffix)