pyscriptc 0.3.0__tar.gz → 0.4.0__tar.gz

{pyscriptc-0.3.0 → pyscriptc-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyscriptc
-Version: 0.3.0
+Version: 0.4.0
 Summary: Lower a typed subset of Python to LLVM, with CPython as the island.
 Author: Joaquin Terrasa
 License-Expression: Apache-2.0

{pyscriptc-0.3.0 → pyscriptc-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyscriptc"
-version = "0.3.0"
+version = "0.4.0"
 description = "Lower a typed subset of Python to LLVM, with CPython as the island."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -39,7 +39,7 @@ Reference = "https://github.com/vercel-labs/scriptc"
 pyscriptc = "pyscriptc.cli:main"
 
 [dependency-groups]
-dev = ["pytest>=8", "ruff>=0.14", "mypy>=2.4"]
+dev = ["pytest>=8", "pytest-xdist>=3.8", "ruff>=0.14", "mypy>=2.4"]
 # Release binary build only (packaging/). Not installed by a plain `uv sync`.
 packaging = ["nuitka>=4.0", "zstandard>=0.23", "ordered-set>=4.1"]
 

pyscriptc-0.4.0/src/pyscriptc/restlower/__init__.py

@@ -0,0 +1,259 @@
+"""Call lowering for the modules in `stdmore`.
+
+The lowerer evaluates arguments and reports fences. This module decides which
+calls are in the closed surface and which symbol implements them: per-module
+handlers live in the sibling `_*.py` modules, and this file keeps only the
+`(module, attr)` registry, the `builtin_call` table and the shared table
+consults (`CALL_FENCES`, `FOR_ONLY`, `WITH_ONLY`, `fixed_spec`).
+"""
+
+from __future__ import annotations
+
+import ast
+from collections.abc import Callable
+from typing import Any
+
+from pyscriptc.restlower._builtins import (
+    _abs,
+    _base_repr,
+    _chr,
+    _divmod,
+    _getattr,
+    _hasattr,
+    _isinstance,
+    _ord,
+    _pow_call,
+    _repr,
+    _round,
+)
+from pyscriptc.restlower._collections import _counter, _defaultdict, _deque, _ordered
+from pyscriptc.restlower._copy import _copy_call
+from pyscriptc.restlower._csv import _csv_call
+from pyscriptc.restlower._ctypes import _sizeof
+from pyscriptc.restlower._datetime import _ints
+from pyscriptc.restlower._functools import _reduce
+from pyscriptc.restlower._hmac import _hmac, _hmac_compare
+from pyscriptc.restlower._io import _input, _named_temp, _open, _print
+from pyscriptc.restlower._iterators import (
+    _enumerate_value,
+    _filter,
+    _iter,
+    _map,
+    _mk_iter,
+    _next,
+    _range_value,
+    _reversed,
+    _zip_value,
+)
+from pyscriptc.restlower._itertools import _itertools
+from pyscriptc.restlower._minmax import _minmax, _sorted, _sum
+from pyscriptc.restlower._operator import _bisect, _join, _operator
+from pyscriptc.restlower._pathlib import _buffer, _one
+from pyscriptc.restlower._random import _random_call
+from pyscriptc.restlower._system import _as_file_value, _atexit_register, _exit, _getenv, _resource_files, _unicode_name
+from pyscriptc.restlower._textwrap import _textwrap_call
+from pyscriptc.restlower._time import _clock, _sleep
+from pyscriptc.stdmore import (
+    CALL_FENCES,
+    CLASS_METHODS,
+    CTYPES,
+    FOR_ONLY,
+    OPERATORS,
+    PATH_ATTRS,
+    WITH_ONLY,
+    fixed_spec,
+    type_alias,
+)
+
+__all__ = ["_mk_iter", "alias_name", "builtin_call", "method_spec", "path_attr", "rest_call"]
+
+# A registered handler takes the lowerer, the call, its span, the expected type
+# and the attribute name, whatever subset of those it actually needs.
+Handler = Callable[[Any, ast.Call, dict[str, Any], "dict[str, Any] | None", str], dict[str, Any]]
+
+_DATETIME_ROWS: dict[str, tuple[str, str, int, list[str]]] = {
+    "date": ("ps_date_ymd", "Date", 3, ["year", "month", "day"]),
+    "datetime": (
+        "ps_dt_new",
+        "DateTime",
+        3,
+        ["year", "month", "day", "hour", "minute", "second", "microsecond"],
+    ),
+    "time": ("ps_tod_new", "Time", 0, ["hour", "minute", "second", "microsecond"]),
+    "timedelta": ("ps_delta_new", "TimeDelta", 0, ["days", "seconds", "microseconds"]),
+}
+
+
+def _datetime_row(attr: str) -> Handler:
+    symbol, cls, minimum, names = _DATETIME_ROWS[attr]
+    return lambda lo, node, span, expect, _attr: _ints(lo, node, span, "datetime", attr, symbol, cls, minimum, names)
+
+
+def _namedtuple_only(lo: Any, node: ast.Call, span: dict[str, Any], expect: Any, attr: str) -> dict[str, Any]:
+    lo.fail(node, "PS2002", "collections.namedtuple is only lowered in a Name = namedtuple(...) assignment")
+    raise AssertionError("unreachable")
+
+
+# Consulted before the fence tables and before `fixed_spec`.
+_EARLY: dict[tuple[str, str], Handler] = {
+    ("sys", "exit"): lambda lo, node, span, expect, attr: _exit(lo, node, span),
+    ("importlib.resources", "as_file"): lambda lo, node, span, expect, attr: _as_file_value(lo, node, span),
+    # The 1-arg form returns the tagged `str | None`; the 2-arg form returns the default instead.
+    ("os", "getenv"): lambda lo, node, span, expect, attr: _getenv(lo, node, span),
+    ("tempfile", "NamedTemporaryFile"): lambda lo, node, span, expect, attr: _named_temp(lo, node, span),
+    ("functools", "partial"): lambda lo, node, span, expect, attr: lo._partial_callable(node, span),
+}
+
+# Whole-module handlers, consulted before `fixed_spec`.
+_MODULES_BEFORE_SPEC: dict[str, Handler] = {
+    "itertools": lambda lo, node, span, expect, attr: _itertools(lo, node, span, attr),
+}
+
+# Whole-module handlers, consulted after `fixed_spec`.
+_MODULES_AFTER_SPEC: dict[str, Handler] = {
+    "random": lambda lo, node, span, expect, attr: _random_call(lo, node, span, attr),
+    "csv": lambda lo, node, span, expect, attr: _csv_call(lo, node, span, attr),
+    "textwrap": lambda lo, node, span, expect, attr: _textwrap_call(lo, node, span, attr),
+    "copy": lambda lo, node, span, expect, attr: _copy_call(lo, node, span, attr),
+}
+
+# Per-attribute handlers that run before keyword arguments are rejected.
+_BEFORE_KEYWORDS: dict[tuple[str, str], Handler] = {
+    **{("datetime", attr): _datetime_row(attr) for attr in _DATETIME_ROWS},
+    ("collections", "OrderedDict"): lambda lo, node, span, expect, attr: _ordered(lo, node, span, expect),
+    ("collections", "Counter"): lambda lo, node, span, expect, attr: _counter(lo, node, span, expect),
+    ("collections", "defaultdict"): lambda lo, node, span, expect, attr: _defaultdict(lo, node, span, expect),
+    ("collections", "namedtuple"): _namedtuple_only,
+}
+
+# Per-attribute handlers that run after keyword arguments are rejected.
+_AFTER_KEYWORDS: dict[tuple[str, str], Handler] = {
+    **{
+        ("operator", attr): (lambda lo, node, span, expect, name: _operator(lo, node, span, name)) for attr in OPERATORS
+    },
+    ("bisect", "bisect_left"): lambda lo, node, span, expect, attr: _bisect(lo, node, span, attr),
+    ("bisect", "bisect_right"): lambda lo, node, span, expect, attr: _bisect(lo, node, span, attr),
+    ("time", "sleep"): lambda lo, node, span, expect, attr: _sleep(lo, node, span),
+    ("time", "gmtime"): lambda lo, node, span, expect, attr: _clock(lo, node, span, attr),
+    ("time", "localtime"): lambda lo, node, span, expect, attr: _clock(lo, node, span, attr),
+    ("collections", "deque"): lambda lo, node, span, expect, attr: _deque(lo, node, span, expect),
+    ("functools", "reduce"): lambda lo, node, span, expect, attr: _reduce(lo, node, span),
+    ("posixpath", "join"): lambda lo, node, span, expect, attr: _join(lo, node, span),
+    ("pathlib", "Path"): lambda lo, node, span, expect, attr: _one(
+        lo, node, span, "pathlib", "Path", "ps_path_new", {"kind": "str"}, {"kind": "class", "name": "Path"}
+    ),
+    ("io", "StringIO"): lambda lo, node, span, expect, attr: _buffer(
+        lo, node, span, "io", "StringIO", "ps_io_string", "str", "TextIO"
+    ),
+    ("io", "BytesIO"): lambda lo, node, span, expect, attr: _buffer(
+        lo, node, span, "io", "BytesIO", "ps_io_bytes", "bytes", "BytesIO"
+    ),
+    ("ctypes", "sizeof"): lambda lo, node, span, expect, attr: _sizeof(lo, node, span),
+    ("hmac", "digest"): lambda lo, node, span, expect, attr: _hmac(lo, node, span, attr),
+    ("hmac", "new"): lambda lo, node, span, expect, attr: _hmac(lo, node, span, attr),
+    ("hmac", "compare_digest"): lambda lo, node, span, expect, attr: _hmac_compare(lo, node, span),
+    ("unicodedata", "name"): lambda lo, node, span, expect, attr: _unicode_name(lo, node, span),
+    ("importlib.resources", "files"): lambda lo, node, span, expect, attr: _resource_files(lo, node, span),
+    ("atexit", "register"): lambda lo, node, span, expect, attr: _atexit_register(lo, node, span),
+}
+
+
+def rest_call(
+    lo: Any,
+    node: ast.Call,
+    span: dict[str, Any],
+    module: str,
+    attr: str,
+    expect: dict[str, Any] | None,
+) -> dict[str, Any]:
+    key = (module, attr)
+    handler = _EARLY.get(key)
+    if handler is not None:
+        return handler(lo, node, span, expect, attr)
+    message = CALL_FENCES.get(key)
+    if message:
+        lo.fail(node, "PS2001", message)
+    if key in FOR_ONLY:
+        lo.fail(node, "PS2002", f"{module}.{attr} is only lowered as the iterator of a for")
+    if key in WITH_ONLY:
+        lo.fail(node, "PS2002", f"{module}.{attr} is only lowered as a with context")
+    if module == "ctypes" and attr in CTYPES:
+        lo.fail(node, "PS2001", f"ctypes.{attr} is not callable in this subset")
+    handler = _MODULES_BEFORE_SPEC.get(module)
+    if handler is not None:
+        return handler(lo, node, span, expect, attr)
+    spec = fixed_spec(module, attr)
+    if spec is not None:
+        return lo._fixed_call(node, span, module, attr, spec)
+    handler = _MODULES_AFTER_SPEC.get(module)
+    if handler is not None:
+        return handler(lo, node, span, expect, attr)
+    handler = _BEFORE_KEYWORDS.get(key)
+    if handler is not None:
+        return handler(lo, node, span, expect, attr)
+    lo._reject_keywords(node)
+    handler = _AFTER_KEYWORDS.get(key)
+    if handler is not None:
+        return handler(lo, node, span, expect, attr)
+    lo.fail(node, "PS2001", f"{module}.{attr} is not in the lowered subset of {module}")
+    raise AssertionError("unreachable")
+
+
+BuiltinHandler = Callable[[Any, ast.Call, dict[str, Any], str], "dict[str, Any] | None"]
+
+# Builtins whose keyword arguments are rejected before the handler runs.
+_NO_KEYWORDS = frozenset({"isinstance", "getattr", "hasattr", "abs", "ord", "chr", "round"})
+
+_BUILTINS: dict[str, BuiltinHandler] = {
+    "open": lambda lo, node, span, name: _open(lo, node, span),
+    "print": lambda lo, node, span, name: _print(lo, node, span),
+    "input": lambda lo, node, span, name: _input(lo, node, span),
+    "isinstance": lambda lo, node, span, name: _isinstance(lo, node, span),
+    "getattr": lambda lo, node, span, name: _getattr(lo, node, span),
+    "hasattr": lambda lo, node, span, name: _hasattr(lo, node, span),
+    "abs": lambda lo, node, span, name: _abs(lo, node, span),
+    "min": _minmax,
+    "max": _minmax,
+    "sum": lambda lo, node, span, name: _sum(lo, node, span),
+    "sorted": lambda lo, node, span, name: _sorted(lo, node, span),
+    "divmod": lambda lo, node, span, name: _divmod(lo, node, span),
+    "hex": _base_repr,
+    "oct": _base_repr,
+    "bin": _base_repr,
+    "pow": lambda lo, node, span, name: _pow_call(lo, node, span),
+    "repr": lambda lo, node, span, name: _repr(lo, node, span),
+    "ord": lambda lo, node, span, name: _ord(lo, node, span),
+    "chr": lambda lo, node, span, name: _chr(lo, node, span),
+    "round": lambda lo, node, span, name: _round(lo, node, span),
+    "iter": lambda lo, node, span, name: _iter(lo, node, span),
+    "next": lambda lo, node, span, name: _next(lo, node, span),
+    "map": lambda lo, node, span, name: _map(lo, node, span),
+    "filter": lambda lo, node, span, name: _filter(lo, node, span),
+    "reversed": lambda lo, node, span, name: _reversed(lo, node, span),
+    "range": lambda lo, node, span, name: _range_value(lo, node, span),
+    "enumerate": lambda lo, node, span, name: _enumerate_value(lo, node, span),
+    "zip": lambda lo, node, span, name: _zip_value(lo, node, span),
+}
+
+
+def builtin_call(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any] | None:
+    assert isinstance(node.func, ast.Name)
+    name = node.func.id
+    handler = _BUILTINS.get(name)
+    if handler is None:
+        return None
+    if node.keywords and name in _NO_KEYWORDS:
+        lo._reject_keywords(node)
+    return handler(lo, node, span, name)
+
+
+def method_spec(class_name: str, name: str) -> dict[str, Any] | None:
+    return CLASS_METHODS.get(class_name, {}).get(name)
+
+
+def path_attr(name: str) -> tuple[dict[str, Any], str] | None:
+    return PATH_ATTRS.get(name)
+
+
+def alias_name(module: str, member: str) -> str | None:
+    return type_alias(module, member)

pyscriptc-0.4.0/src/pyscriptc/restlower/_builtins.py

@@ -0,0 +1,177 @@
+"""Scalar and introspection builtins."""
+
+from __future__ import annotations
+
+import ast
+from typing import Any
+
+from pyscriptc.restlower._shared import _pin, _span_to
+
+
+def _isinstance(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any]:
+    if len(node.args) != 2:
+        lo.fail(node, "PS2003", "isinstance expects 2 argument(s)")
+    obj = lo._expr(node.args[0])
+    want = lo._isinstance_type(node.args[1])
+    if obj["type"].get("optional"):
+        # `isinstance(x, T)` on `T | None` is the tag: the value is exactly
+        # its element type or it is None.
+        if lo._isinstance_holds(obj["type"]["elem"], want):
+            return {"kind": "attr", "value": obj, "name": "_tag", "type": {"kind": "bool"}, "span": span}
+        return {"kind": "const", "value": False, "type": {"kind": "bool"}, "span": span}
+    flag = lo._isinstance_holds(obj["type"], want)
+    return {"kind": "const", "value": flag, "type": {"kind": "bool"}, "span": span}
+
+
+def _getattr(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any]:
+    if len(node.args) != 2:
+        lo.fail(node, "PS2003", "getattr expects 2 argument(s)")
+    obj = lo._expr(node.args[0])
+    name = _literal_name(lo, node)
+    return lo._lookup_attr(obj, name, span, node)
+
+
+def _hasattr(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any]:
+    if len(node.args) != 2:
+        lo.fail(node, "PS2003", "hasattr expects 2 argument(s)")
+    obj = lo._expr(node.args[0])
+    name = _literal_name(lo, node)
+    return {"kind": "const", "value": lo._has_attr(obj, name), "type": {"kind": "bool"}, "span": span}
+
+
+def _literal_name(lo: Any, node: ast.Call) -> str:
+    arg = node.args[1]
+    if isinstance(arg, ast.Constant) and isinstance(arg.value, str) and arg.value.isidentifier():
+        if any(ord(ch) > 127 for ch in arg.value):
+            lo.fail(node, "PS2005", "non-ASCII string literals are not lowered")
+        return arg.value
+    lo.fail(node, "PS2001", "the attribute name is a string literal")
+    raise AssertionError("unreachable")
+
+
+def _abs(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any]:
+    if len(node.args) != 1:
+        lo.fail(node, "PS2003", "abs expects 1 argument(s)")
+    arg = lo._expr(node.args[0])
+    kind = arg["type"]["kind"]
+    if kind == "int":
+        return lo._abi_call("builtins", "abs", [arg], {"kind": "int"}, "ps_abs_i64", span)
+    if kind == "float":
+        return lo._abi_call("builtins", "abs", [arg], {"kind": "float"}, "ps_abs_f64", span)
+    lo.fail(node, "PS2003", "abs is lowered for int and float")
+    raise AssertionError("unreachable")
+
+
+def _divmod(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any]:
+    """divmod(a, b) is the `(a // b, a % b)` pair as a synthetic tuple_2.
+
+    Each operand pins once because it appears in both halves; the halves ride
+    the existing `//` and `%` lowering, so int, float, and mixed pairs all
+    work, and bool or text operands keep their binop fences.
+    """
+
+    lo._reject_keywords(node)
+    if len(node.args) != 2:
+        lo.fail(node, "PS2003", "divmod expects 2 argument(s)")
+    pinned = [_pin(lo, lo._expr(arg), span, "dv") for arg in node.args]
+    left = ast.Name(id=pinned[0]["id"], ctx=ast.Load())
+    right = ast.Name(id=pinned[1]["id"], ctx=ast.Load())
+    elems = []
+    for op in (ast.FloorDiv(), ast.Mod()):
+        elems.append(lo._expr(_span_to(node, ast.BinOp(left=left, op=op, right=right))))
+    return lo._materialize_tuple(elems, span)
+
+
+_BASE_SYMS = {"hex": "ps_hex_i64", "oct": "ps_oct_i64", "bin": "ps_bin_i64"}
+
+
+def _base_repr(lo: Any, node: ast.Call, span: dict[str, Any], name: str) -> dict[str, Any]:
+    """hex/oct/bin of an int: CPython's `0x`/`0o`/`0b` spellings, sign first."""
+
+    lo._reject_keywords(node)
+    if len(node.args) != 1:
+        lo.fail(node, "PS2003", f"{name} expects 1 argument(s)")
+    arg = lo._expr(node.args[0])
+    if arg["type"]["kind"] != "int":
+        lo.fail(node, "PS1003", f"{name} argument is int")
+    return lo._abi_call("builtins", name, [arg], {"kind": "str"}, _BASE_SYMS[name], span)
+
+
+def _pow_call(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any]:
+    """pow(x, y) is `x ** y`; pow(x, y, m) is `x ** y % m` for ints.
+
+    A negative exponent with a modulus keeps the `**` ValueError instead of
+    computing CPython's modular inverse.
+    """
+
+    lo._reject_keywords(node)
+    if len(node.args) not in {2, 3}:
+        lo.fail(node, "PS2003", "pow expects 2 or 3 argument(s)")
+    base = lo._pow(node, lo._expr(node.args[0]), lo._expr(node.args[1]), span)
+    if len(node.args) == 2:
+        return base
+    mod = lo._expr(node.args[2])
+    if base["type"]["kind"] != "int" or mod["type"]["kind"] != "int":
+        lo.fail(node, "PS2003", "pow with a modulus takes int arguments")
+    return {"kind": "binary", "op": "%", "left": base, "right": mod, "type": {"kind": "int"}, "span": span}
+
+
+def _repr(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any]:
+    """repr(x) is `'%r' % x` — the format engine already owns the spellings."""
+
+    lo._reject_keywords(node)
+    if len(node.args) != 1:
+        lo.fail(node, "PS2003", "repr expects 1 argument(s)")
+    arg = lo._expr(node.args[0])
+    kind = arg["type"]["kind"]
+    style = "percent"
+    if kind == "dict":
+        value_kinds = {"int", "float", "str", "bytes"}
+        if arg["type"]["key"]["kind"] not in {"int", "str"} or arg["type"]["value"]["kind"] not in value_kinds:
+            lo.fail(node, "PS2002", "repr needs scalar dict keys and values")
+        style = "map"
+    elif kind == "class":
+        called = lo._dunder_call(node, arg, "__repr__", [], span)
+        if called is not None:
+            return called
+        lo.fail(node, "PS2004", f"repr of {kind} is not lowered")
+    elif kind not in {"int", "float", "str", "bool", "bytes"}:
+        lo.fail(node, "PS2004", f"repr of {kind} is not lowered")
+    fmt = {"kind": "const", "value": "%r", "type": {"kind": "str"}, "span": span}
+    expr = lo._abi_call("builtins", "format", [fmt, arg], {"kind": "str"}, "ps_str_format", span)
+    expr["format_style"] = style
+    return expr
+
+
+def _ord(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any]:
+    if len(node.args) != 1:
+        lo.fail(node, "PS2003", "ord expects 1 argument(s)")
+    arg = lo._expr(node.args[0])
+    if arg["type"]["kind"] != "str":
+        lo.fail(node, "PS1003", "ord argument is str")
+    return lo._abi_call("builtins", "ord", [arg], {"kind": "int"}, "ps_ord", span)
+
+
+def _chr(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any]:
+    if len(node.args) != 1:
+        lo.fail(node, "PS2003", "chr expects 1 argument(s)")
+    arg = lo._expr(node.args[0])
+    if arg["type"]["kind"] != "int":
+        lo.fail(node, "PS1003", "chr argument is int")
+    return lo._abi_call("builtins", "chr", [arg], {"kind": "str"}, "ps_chr", span)
+
+
+def _round(lo: Any, node: ast.Call, span: dict[str, Any]) -> dict[str, Any]:
+    if len(node.args) not in {1, 2}:
+        lo.fail(node, "PS2003", "round expects 1 or 2 argument(s)")
+    arg = lo._expr(node.args[0])
+    if len(node.args) == 1 and arg["type"]["kind"] == "int":
+        return arg
+    if arg["type"]["kind"] != "float":
+        lo.fail(node, "PS1003", "round argument is float")
+    if len(node.args) == 1:
+        return lo._abi_call("builtins", "round", [arg], {"kind": "int"}, "ps_round_i64", span)
+    digits = lo._expr(node.args[1])
+    if digits["type"]["kind"] != "int":
+        lo.fail(node, "PS1003", "round ndigits is int")
+    return lo._abi_call("builtins", "round", [arg, digits], {"kind": "float"}, "ps_round_nd", span)

pyscriptc-0.4.0/src/pyscriptc/restlower/_collections.py

@@ -0,0 +1,115 @@
+"""collections constructors."""
+
+from __future__ import annotations
+
+import ast
+from typing import Any
+
+from pyscriptc.restlower._shared import _const_int
+from pyscriptc.stdmore import slot_size
+
+
+def _deque(lo: Any, node: ast.Call, span: dict[str, Any], expect: dict[str, Any] | None) -> dict[str, Any]:
+    if len(node.args) > 1:
+        lo.fail(node, "PS2003", "deque expects 0 or 1 argument(s)")
+    if not node.args:
+        if expect is None or expect.get("name") != "Deque" or "elem" not in expect:
+            lo.fail(node, "PS1001", "deque() needs a deque annotation")
+        elem = expect["elem"]
+        if elem["kind"] == "bool":
+            lo.fail(node, "PS2002", "list[bool] is not lowered")
+        size = _const_int(slot_size(elem), span)
+        return lo._abi_call("collections", "deque", [size], expect, "ps_deque_empty", span)
+    arg = lo._expr(node.args[0])
+    if arg["type"]["kind"] != "list":
+        lo.fail(node, "PS1003", "deque() takes a list")
+    elem = arg["type"]["elem"]
+    if elem["kind"] == "bool":
+        lo.fail(node, "PS2002", "list[bool] is not lowered")
+    typ = {"kind": "class", "name": "Deque", "elem": elem}
+    if expect is not None and expect.get("name") == "Deque":
+        lo._expect(node, typ, expect, "deque")
+    size = _const_int(slot_size(elem), span)
+    return lo._abi_call("collections", "deque", [size, arg], typ, "ps_deque_from", span)
+
+
+def _counter(lo: Any, node: ast.Call, span: dict[str, Any], expect: dict[str, Any] | None) -> dict[str, Any]:
+    """`Counter()`, `Counter(str)`, `Counter(list)`, `Counter(dict[K, int])`.
+
+    The result is the map type marked `counter`, so `c[k]` reads 0 on a
+    miss instead of raising. Counting happens in ps_coll.c. Subset keeps
+    one positional iterable/mapping; `Counter(a=2)` keyword counts,
+    `elements`, `most_common`, `subtract`, `total`, and the arithmetic
+    operators stay fenced, and `update` keeps its fence because CPython
+    adds counts where dict.update replaces.
+    """
+    if node.keywords:
+        lo.fail(node, "PS2001", "Counter keyword arguments are not lowered")
+    if len(node.args) > 1:
+        lo.fail(node, "PS2003", "Counter expects 0 or 1 argument(s)")
+    if not node.args:
+        if expect is None or expect["kind"] != "dict":
+            lo.fail(node, "PS1001", "Counter() needs a Counter annotation")
+        return {"kind": "dict", "pairs": [], "type": {**expect, "counter": True}, "span": span}
+    arg = lo._expr(node.args[0])
+    at = arg["type"]
+    if at["kind"] == "str":
+        typ = {"kind": "dict", "key": {"kind": "str"}, "value": {"kind": "int"}, "counter": True}
+        return lo._abi_call("collections", "Counter", [arg], typ, "ps_counter_from_buf", span)
+    if at["kind"] == "list" and not at.get("set") and at["elem"]["kind"] in {"int", "str"}:
+        typ = {"kind": "dict", "key": at["elem"], "value": {"kind": "int"}, "counter": True}
+        return lo._abi_call("collections", "Counter", [arg], typ, "ps_counter_from_seq", span)
+    if at["kind"] == "dict" and at["value"]["kind"] == "int":
+        typ = {"kind": "dict", "key": at["key"], "value": {"kind": "int"}, "counter": True}
+        return lo._abi_call("collections", "Counter", [arg], typ, "ps_counter_from_map", span)
+    lo.fail(node, "PS1003", "Counter takes a str, a list of int or str, or a dict of int values")
+    raise AssertionError("unreachable")
+
+
+def _defaultdict(lo: Any, node: ast.Call, span: dict[str, Any], expect: dict[str, Any] | None) -> dict[str, Any]:
+    """`defaultdict(factory)` where the annotation supplies the value type.
+
+    The factory is validated against the annotation's value type and the
+    default itself comes from the type's zero: `defaultdict(list)` makes
+    `d[k]` insert a fresh `list`, `defaultdict(int)` inserts 0, and so on.
+    Subset factories: list, dict, set, int, float, str. Lambdas and other
+    callables, the no-argument form, and `default_factory` access stay
+    fenced.
+    """
+    if node.keywords:
+        lo.fail(node, "PS2001", "defaultdict keyword arguments are not lowered")
+    if len(node.args) != 1:
+        lo.fail(node, "PS2003", "defaultdict expects 1 argument(s)")
+    factory = node.args[0]
+    factories = {"list", "dict", "set", "int", "float", "str"}
+    if not isinstance(factory, ast.Name) or factory.id not in factories:
+        lo.fail(node, "PS2001", "defaultdict factory is list, dict, set, int, float, or str")
+    name = factory.id
+    if expect is None or expect["kind"] != "dict":
+        lo.fail(node, "PS1001", "defaultdict needs a defaultdict annotation")
+    val_t = expect["value"]
+    ok = (
+        (name == "list" and val_t["kind"] == "list" and not val_t.get("set"))
+        or (name == "set" and val_t["kind"] == "list" and val_t.get("set"))
+        or (name == "dict" and val_t["kind"] == "dict")
+        or (name in {"int", "float", "str"} and val_t["kind"] == name)
+    )
+    if not ok:
+        lo.fail(node, "PS1003", f"defaultdict({name}) needs a defaultdict annotation whose value is {name}-like")
+    return {"kind": "dict", "pairs": [], "type": {**expect, "defaultdict": True}, "span": span}
+
+
+def _ordered(lo: Any, node: ast.Call, span: dict[str, Any], expect: dict[str, Any] | None) -> dict[str, Any]:
+    """`OrderedDict()` with no arguments is the empty dict the compiler already builds.
+
+    A positional iterable and keyword arguments stay fenced. The `ordered` mark
+    is not part of the type key, so an annotated `dict` assignment still matches.
+    """
+    if node.args:
+        lo.fail(node, "PS2001", "an OrderedDict iterable is not lowered")
+    if node.keywords:
+        lo.fail(node, "PS2001", "OrderedDict keyword arguments are not lowered")
+    if expect is not None and expect["kind"] != "dict":
+        lo.fail(node, "PS1001", "OrderedDict needs a dict annotation")
+    base = expect if expect is not None else {"kind": "dict", "key": {"kind": "str"}, "value": {"kind": "int"}}
+    return {"kind": "dict", "pairs": [], "type": {**base, "ordered": True}, "span": span}

pyscriptc-0.4.0/src/pyscriptc/restlower/_copy.py

@@ -0,0 +1,43 @@
+"""copy call lowering."""
+
+from __future__ import annotations
+
+import ast
+from typing import Any
+
+_COPY_SCALARS = {"int", "float", "bool", "str", "bytes"}
+
+
+def _copyable(typ: dict[str, Any]) -> bool:
+    kind = typ["kind"]
+    if kind in {"int", "float", "str", "bytes"}:
+        return True
+    if kind == "list":
+        return _copyable(typ["elem"])
+    if kind == "dict":
+        return _copyable(typ["value"])
+    return False
+
+
+def _copy_call(lo: Any, node: ast.Call, span: dict[str, Any], attr: str) -> dict[str, Any]:
+    """copy.copy/deepcopy: scalars are returned as-is; shallow copies of
+    list/dict memcpy the container; deepcopy walks a static type table the
+    emitter writes next to the call (ps_copy_deep)."""
+    lo._reject_keywords(node)
+    if len(node.args) != 1:
+        lo.fail(node, "PS2003", f"copy.{attr} expects 1 argument(s)")
+    arg = lo._expr(node.args[0])
+    typ = arg["type"]
+    kind = typ["kind"]
+    if kind in _COPY_SCALARS:
+        return arg
+    if attr == "copy":
+        if kind == "list":
+            return lo._abi_call("copy", attr, [arg], typ, "ps_copy_seq", span)
+        if kind == "dict":
+            return lo._abi_call("copy", attr, [arg], typ, "ps_copy_map", span)
+    else:
+        if kind in {"list", "dict"} and _copyable(typ):
+            return lo._abi_call("copy", attr, [arg], typ, "ps_copy_deep", span)
+    lo.fail(node, "PS2001", f"copy.{attr} is not lowered for {kind}")
+    raise AssertionError("unreachable")

pyscriptc-0.4.0/src/pyscriptc/restlower/_csv.py

@@ -0,0 +1,36 @@
+"""csv call lowering."""
+
+from __future__ import annotations
+
+import ast
+from typing import Any
+
+from pyscriptc.restlower._shared import _class
+
+
+def _csv_call(lo: Any, node: ast.Call, span: dict[str, Any], attr: str) -> dict[str, Any]:
+    """csv.reader is eager: it returns list[list[str]] from a file or a
+    list[str] of physical lines. csv.writer wraps the TextIO handle itself as
+    the CsvWriter value and writes excel-dialect rows."""
+    lo._reject_keywords(node)
+    if attr == "reader":
+        if len(node.args) != 1:
+            lo.fail(node, "PS2003", "csv.reader expects 1 argument(s)")
+        arg = lo._expr(node.args[0])
+        typ = arg["type"]
+        rows: dict[str, Any] = {"kind": "list", "elem": {"kind": "list", "elem": {"kind": "str"}}}
+        if typ["kind"] == "list" and typ["elem"]["kind"] == "str":
+            return lo._abi_call("csv", "reader", [arg], rows, "ps_csv_read_lines", span)
+        if typ["kind"] == "class" and typ.get("name") == "TextIO":
+            return lo._abi_call("csv", "reader", [arg], rows, "ps_csv_read_io", span)
+        lo.fail(node, "PS1003", "csv.reader takes a list[str] or a text file")
+    if attr == "writer":
+        if len(node.args) != 1:
+            lo.fail(node, "PS2003", "csv.writer expects 1 argument(s)")
+        arg = lo._expr(node.args[0])
+        typ = arg["type"]
+        if typ["kind"] == "class" and typ.get("name") == "TextIO":
+            return lo._abi_call("csv", "writer", [arg], _class("CsvWriter"), "ps_csv_writer", span)
+        lo.fail(node, "PS1003", "csv.writer takes a text file")
+    lo.fail(node, "PS2001", f"csv.{attr} is not in the lowered subset of csv")
+    raise AssertionError("unreachable")