tpy-lang 0.3.0.dev0__py3-none-any.whl

tpyc/codegen_cpp/string_dispatch.py

@@ -0,0 +1,76 @@
+"""String dispatch optimization for match/case and enum lookup.
+
+Analyzes a set of string literals to find the best single discriminator
+(string length or character at a fixed position) that partitions the
+strings into the smallest possible buckets for switch-based dispatch.
+"""
+
+from __future__ import annotations
+
+# Minimum number of unguarded string literal cases to trigger switch dispatch
+STRING_SWITCH_THRESHOLD = 5
+
+
+def find_best_discriminator(
+    strings: list[str],
+) -> tuple[str, int | None, dict[int, list[str]]]:
+    """Find the best discriminator for switch-based string dispatch.
+
+    Args:
+        strings: List of distinct string literals to dispatch on.
+
+    Returns:
+        (kind, param, buckets) where:
+        - kind: "length" or "char_at"
+        - param: None for length, character position index for char_at
+        - buckets: maps discriminator value -> list of strings
+          For "length": value is string length.
+          For "char_at": value is ord(char) at the given position.
+    """
+    if not strings:
+        return ("length", None, {})
+
+    # Candidate 1: string length
+    best_kind = "length"
+    best_param: int | None = None
+    best_buckets = _group_by_length(strings)
+    best_max = _max_bucket(best_buckets)
+
+    if best_max <= 1:
+        return (best_kind, best_param, best_buckets)
+
+    # Candidate 2: character at position i (only positions reachable by all strings)
+    min_len = min(len(s) for s in strings)
+    for i in range(min_len):
+        buckets = _group_by_char_at(strings, i)
+        max_b = _max_bucket(buckets)
+        if max_b < best_max:
+            best_kind = "char_at"
+            best_param = i
+            best_buckets = buckets
+            best_max = max_b
+            if best_max <= 1:
+                break
+
+    return (best_kind, best_param, best_buckets)
+
+
+def _group_by_length(strings: list[str]) -> dict[int, list[str]]:
+    buckets: dict[int, list[str]] = {}
+    for s in strings:
+        buckets.setdefault(len(s), []).append(s)
+    return buckets
+
+
+def _group_by_char_at(strings: list[str], pos: int) -> dict[int, list[str]]:
+    buckets: dict[int, list[str]] = {}
+    for s in strings:
+        key = ord(s[pos])
+        buckets.setdefault(key, []).append(s)
+    return buckets
+
+
+def _max_bucket(buckets: dict[int, list[str]]) -> int:
+    if not buckets:
+        return 0
+    return max(len(v) for v in buckets.values())

tpyc/codegen_cpp/test_context.py

@@ -0,0 +1,46 @@
+"""Tests for codegen C++ context utilities."""
+
+import pytest
+
+from .context import expand_cpp_template, CodeGenError
+
+
+class TestExpandCppTemplate:
+    def test_self_only(self):
+        assert expand_cpp_template("{self}.size()", "v") == "v.size()"
+
+    def test_self_and_positional(self):
+        result = expand_cpp_template("{self}.push_back({0})", "vec", "42")
+        assert result == "vec.push_back(42)"
+
+    def test_multiple_positional(self):
+        result = expand_cpp_template("{self}[{0}] = {1}", "arr", "i", "val")
+        assert result == "arr[i] = val"
+
+    def test_no_placeholders(self):
+        assert expand_cpp_template("std::sort()", "x") == "std::sort()"
+
+    def test_repeated_placeholder(self):
+        result = expand_cpp_template("{self} + {self}", "a")
+        assert result == "a + a"
+
+    def test_unreplaced_self_raises(self):
+        with pytest.raises(CodeGenError, match=r"\{self\}"):
+            expand_cpp_template("{self}.set({0})", "obj")
+
+    def test_unreplaced_positional_raises(self):
+        with pytest.raises(CodeGenError, match=r"\{1\}"):
+            expand_cpp_template("{self}.f({0}, {1})", "obj", "a")
+
+    def test_extra_args_ok(self):
+        result = expand_cpp_template("{self}.f({0})", "obj", "a", "unused")
+        assert result == "obj.f(a)"
+
+    def test_cpp_braces_in_substituted_value(self):
+        """C++ initializer braces in substituted values must not trigger false positives."""
+        result = expand_cpp_template(
+            "::tpy::list_concat({self}, {0})",
+            "v",
+            "std::vector<int>{30}",
+        )
+        assert result == "::tpy::list_concat(v, std::vector<int>{30})"

tpyc/codegen_cpp/test_param_const.py

@@ -0,0 +1,113 @@
+"""Unit tests for the centralized const decision helper."""
+
+from ..typesys import (
+    INT32, BOOL, STR, BIGINT,
+    NominalType, OptionalType, TupleType, OwnType, ReadonlyType, RefType,
+    TypeParamRef, TypeParamKind,
+)
+from .param_const import decide_param_const, ParamConstDecision
+
+
+T = NominalType("T")
+TUPLE_T_T = TupleType((T, T))
+TUPLE_OPT_T = TupleType((OptionalType(T), OptionalType(T)))
+OPT_T = OptionalType(T)
+
+
+def _decide(ptype, **kwargs):
+    """decide_param_const helper that defaults common args."""
+    kwargs.setdefault("index", 0)
+    kwargs.setdefault("pname", "p")
+    kwargs.setdefault("mutated_params", frozenset())
+    return decide_param_const(ptype, **kwargs)
+
+
+class TestSingleRecord:
+    def test_unmutated_borrow_is_const(self):
+        d = _decide(T)
+        assert d == ParamConstDecision(True, True)
+
+    def test_mutated_borrow_is_not_const(self):
+        d = _decide(T, mutated_params=frozenset({0}))
+        assert d == ParamConstDecision(False, False)
+
+    def test_unanalyzed_is_not_const(self):
+        d = _decide(T, mutated_params=None)
+        assert d == ParamConstDecision(False, False)
+
+    def test_addr_escape_is_not_const(self):
+        d = _decide(T, addr_escapes_params=frozenset({0}))
+        assert d == ParamConstDecision(False, False)
+
+    def test_explicit_readonly_is_const(self):
+        d = _decide(ReadonlyType(T), mutated_params=None)
+        assert d == ParamConstDecision(True, True)
+
+    def test_const_params_forces_const(self):
+        d = _decide(T, mutated_params=None, const_params=True)
+        assert d == ParamConstDecision(True, True)
+
+
+class TestSingleOptional:
+    def test_unmutated_pointer_optional_is_const(self):
+        d = _decide(OPT_T)
+        assert d == ParamConstDecision(True, True)
+
+    def test_mutated_pointer_optional_is_not_const(self):
+        d = _decide(OPT_T, mutated_params=frozenset({0}))
+        assert d == ParamConstDecision(False, False)
+
+    def test_value_optional_is_not_const(self):
+        # Optional[int] uses std::optional<int>, not pointer repr.
+        opt_int = OptionalType(INT32)
+        d = _decide(opt_int)
+        assert d == _NOT_CONST
+
+
+class TestTupleParam:
+    def test_unmutated_tuple_of_records_is_deep_const(self):
+        d = _decide(TUPLE_T_T)
+        assert d == ParamConstDecision(True, True)
+
+    def test_unmutated_tuple_of_optional_records_is_deep_const(self):
+        d = _decide(TUPLE_OPT_T)
+        assert d == ParamConstDecision(True, True)
+
+    def test_mutated_tuple_is_not_const(self):
+        d = _decide(TUPLE_T_T, mutated_params=frozenset({0}))
+        assert d == ParamConstDecision(False, False)
+
+    def test_value_only_tuple_is_not_const(self):
+        # tuple[int, int] -- no borrowed surface.
+        d = _decide(TupleType((INT32, BOOL)))
+        assert d == _NOT_CONST
+
+    def test_generic_slot_tuple_is_not_inferred(self):
+        # tuple[T, T] where T is unbounded -- mutation surface is unknowable
+        # at the template level. Inference must default to not-const.
+        T_param = TypeParamRef(name="T", kind=TypeParamKind.TYPE)
+        d = _decide(TupleType((T_param, T_param)))
+        assert d == _NOT_CONST
+
+
+class TestTypeParamTopLevel:
+    def test_top_level_typeparam_is_not_inferred(self):
+        # def f[T](x: T): ... -- spelling decided at instantiation, not now.
+        T_param = TypeParamRef(name="T", kind=TypeParamKind.TYPE)
+        d = _decide(T_param)
+        assert d == _NOT_CONST
+
+
+class TestReassignedParams:
+    def test_reassigned_str_is_not_const(self):
+        # str needs copy-for-reassign.
+        d = _decide(STR, reassigned_params={"p"})
+        assert d == _NOT_CONST
+
+    def test_reassigned_record_can_still_be_const(self):
+        # Records don't need copy-for-reassign; can rebind a const ref.
+        d = _decide(T, reassigned_params={"p"})
+        assert d.signature_const
+
+
+_NOT_CONST = ParamConstDecision(False, False)

tpyc/codegen_cpp/test_resumable_cfg.py

@@ -0,0 +1,182 @@
+"""Unit tests for the resumable-frame CFG builder.
+
+Phase A of the generator -> resumable-frame migration makes the CFG
+builder suspension-generic: a `yield` statement is now a suspension
+point alongside `await`, the lazy-decomposition predicate
+(`_stmt_has_any_suspension`) treats both uniformly, and a top-level
+`yield` lowers to a `Yield` terminator carrying a `YieldPayload`. These
+tests exercise that wiring at the CFG level, before any generator emit
+exists (the builder runs on raw parsed `TpyStmt` bodies, no sema/codegen
+needed).
+"""
+import pytest
+
+from ..parse import Parser
+from .resumable_cfg import (
+    CFGBuilder, YieldPayload, AwaitPayload, MatchDispatch,
+    _stmt_has_any_suspension,
+)
+
+
+def _gen_body(src: str):
+    """Parse `src` and return the body (list of TpyStmt) of its first
+    function."""
+    module = Parser().parse(src, module_name="t")
+    assert module.functions, "expected at least one function"
+    return module.functions[0].body
+
+
+def _build(src: str):
+    return CFGBuilder().build(_gen_body(src))
+
+
+class TestYieldDispatch:
+    def test_top_level_yields_produce_yield_payloads(self):
+        cfg = _build(
+            "from typing import Iterator\n"
+            "from tpy import Int32\n"
+            "def g() -> Iterator[Int32]:\n"
+            "    yield 1\n"
+            "    yield 2\n"
+        )
+        assert len(cfg.yield_sites) == 2
+        for y in cfg.yield_sites:
+            assert isinstance(y.payload, YieldPayload)
+            assert not isinstance(y.payload, AwaitPayload)
+            # A non-bare yield always carries its value expression.
+            assert y.payload.value_expr is not None
+        # Suspension indices are assigned in source order.
+        assert [y.suspension_index for y in cfg.yield_sites] == [0, 1]
+
+    def test_yield_in_while_decomposes_loop(self):
+        # A yield inside a while body must force the loop into a CFG
+        # region (multiple BBs), driven by the generic suspension
+        # predicate -- not left as a single leaf statement.
+        cfg = _build(
+            "from typing import Iterator\n"
+            "from tpy import Int32\n"
+            "def g(n: Int32) -> Iterator[Int32]:\n"
+            "    i = 0\n"
+            "    while i < n:\n"
+            "        yield i\n"
+            "        i += 1\n"
+        )
+        assert len(cfg.yield_sites) == 1
+        assert isinstance(cfg.yield_sites[0].payload, YieldPayload)
+        # Loop decomposition produces several BBs (check/body/exit + ...),
+        # not the single block a non-decomposed leaf body would yield.
+        assert len(cfg.blocks) > 1
+
+
+class TestSuspensionPredicate:
+    def test_detects_nested_yield(self):
+        body = _gen_body(
+            "from typing import Iterator\n"
+            "from tpy import Int32\n"
+            "def g(n: Int32) -> Iterator[Int32]:\n"
+            "    while n > 0:\n"
+            "        yield n\n"
+        )
+        # body[-1] is the while-loop; it nests a yield.
+        assert _stmt_has_any_suspension(body[-1]) is True
+
+    def test_plain_loop_without_yield_is_not_a_suspension(self):
+        body = _gen_body(
+            "from tpy import Int32\n"
+            "def f(n: Int32) -> Int32:\n"
+            "    total = 0\n"
+            "    while n > 0:\n"
+            "        total += n\n"
+            "        n -= 1\n"
+            "    return total\n"
+        )
+        # The while loop has no suspension; predicate must say so.
+        whiles = [s for s in body if type(s).__name__ == "TpyWhile"]
+        assert whiles and _stmt_has_any_suspension(whiles[0]) is False
+
+
+class TestLoopElseSupported:
+    # Phase D3: the CFG now models break-vs-normal-exit via distinct edges
+    # (else runs on the normal-exit edge; `break` targets a separate
+    # after-BB that skips it), so a suspension inside a loop `else` is
+    # supported instead of rejected. These build the CFG and assert both
+    # the body and else yields are recorded.
+    def test_yield_in_while_else_builds(self):
+        cfg = _build(
+            "from typing import Iterator\n"
+            "from tpy import Int32\n"
+            "def g(n: Int32) -> Iterator[Int32]:\n"
+            "    while n > 0:\n"
+            "        yield n\n"
+            "        n -= 1\n"
+            "    else:\n"
+            "        yield -1\n"
+        )
+        # one yield in the body, one in the else clause.
+        assert len(cfg.yield_sites) == 2
+
+    def test_yield_in_for_else_builds(self):
+        # for-loops need a registered uid (normally from the gen_async
+        # pre-scan); supply one so the builder reaches the else handling.
+        body = _gen_body(
+            "from typing import Iterator\n"
+            "from tpy import Int32\n"
+            "def g(xs: list[Int32]) -> Iterator[Int32]:\n"
+            "    for x in xs:\n"
+            "        yield x\n"
+            "    else:\n"
+            "        yield -1\n"
+        )
+        for_stmt = body[0]
+        cfg = CFGBuilder(for_uid_map={id(for_stmt): 0}).build(body)
+        assert len(cfg.yield_sites) == 2
+
+
+class TestMatchDecomposition:
+    # H1: a `match` carrying a suspension is decomposed by the builder into
+    # a single `MatchDispatch` terminator (the suspension-free, type-aware
+    # dispatch is reused at emit) plus one BB per arm body, so the nested
+    # yields are real CFG yield sites rather than silently-dropped leaves.
+    def test_yield_in_match_decomposes(self):
+        cfg = _build(
+            "from typing import Iterator\n"
+            "from tpy import Int32\n"
+            "def g() -> Iterator[Int32]:\n"
+            "    yield 1\n"
+            "    sel = 2\n"
+            "    match sel:\n"
+            "        case 2:\n"
+            "            yield 99\n"
+            "        case _:\n"
+            "            yield 0\n"
+            "    yield 3\n"
+        )
+        # yield 1 / yield 99 / yield 0 / yield 3 are all real suspensions.
+        assert len(cfg.yield_sites) == 4
+        dispatches = [bb.terminator for bb in cfg.blocks.values()
+                      if isinstance(bb.terminator, MatchDispatch)]
+        assert len(dispatches) == 1
+        # One arm BB per case; a reachable join (the trailing `yield 3`).
+        assert len(dispatches[0].arm_bbs) == 2
+        assert dispatches[0].join_bb is not None
+
+    def test_match_without_suspension_is_plain_leaf(self):
+        # A `match` with no `yield` inside is ordinary straight-line code
+        # between suspensions -- the builder appends it as a leaf and the
+        # CFG builds cleanly.
+        cfg = _build(
+            "from typing import Iterator\n"
+            "from tpy import Int32\n"
+            "def g(sel: Int32) -> Iterator[Int32]:\n"
+            "    yield 1\n"
+            "    match sel:\n"
+            "        case 2:\n"
+            "            print(99)\n"
+            "        case _:\n"
+            "            print(0)\n"
+            "    yield 3\n"
+        )
+        assert len(cfg.yield_sites) == 2
+
+
+

tpyc/codegen_cpp/type_resolution.py

@@ -0,0 +1,53 @@
+"""Shared type-resolution helpers for codegen."""
+
+from __future__ import annotations
+
+from ..typesys import PendingViewType, TpyType
+from ..sema.context import PENDING_CONTAINER_TYPES
+from ..sema import SemanticAnalyzer
+from ..parse import TpyVarDecl
+from .types import TypeResolver
+
+# Types that indicate an unresolved intermediate sema state.
+_PENDING_TYPES = (*PENDING_CONTAINER_TYPES, PendingViewType)
+
+
+def resolve_stmt_binding_type(
+    stmt: TpyVarDecl,
+    analyzer: SemanticAnalyzer,
+    include_global_binding: bool = True,
+) -> TpyType | None:
+    """Resolve variable type via var_types -> global binding.
+
+    Keeps lookup logic consistent across codegen paths and skips unresolved
+    pending types from intermediate sema state.
+    """
+    var_type = stmt.type
+    if var_type is not None or stmt.init is None:
+        return var_type
+
+    var_type = analyzer.var_types.get(id(stmt))
+    if var_type is None or isinstance(var_type, _PENDING_TYPES):
+        if include_global_binding:
+            binding = analyzer.global_ns.lookup_local(stmt.name)
+            if binding and binding.type is not None:
+                var_type = binding.type
+    return var_type
+
+
+def resolve_stmt_type_cascade(
+    stmt: TpyVarDecl,
+    analyzer: SemanticAnalyzer,
+    types: TypeResolver,
+    include_global_binding: bool = True,
+) -> TpyType | None:
+    """Resolve variable type via var_types -> global binding -> expr type."""
+    var_type = resolve_stmt_binding_type(
+        stmt,
+        analyzer,
+        include_global_binding=include_global_binding,
+    )
+    if var_type is None or isinstance(var_type, _PENDING_TYPES):
+        assert stmt.init is not None
+        var_type = types.get_resolved_type(stmt.init)
+    return var_type