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

tpyc/sema/flow_facts.py

@@ -0,0 +1,199 @@
+"""
+FlowFacts -- immutable snapshot of flow-sensitive analysis state.
+
+Captures the flow-sensitive properties that must be saved, restored,
+and merged at branch/loop boundaries: definite assignment, termination,
+rvalue tracking, parameter provenance, safe-to-return locals, pointer
+non-null status, type narrowing, and consumed-variable tracking.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import TYPE_CHECKING
+
+from .context import BorrowKind, BORROW_KIND_RANK
+from .value_range import ValueRange
+
+if TYPE_CHECKING:
+    from ..typesys import TpyType
+
+
+class _MergePolicy(Enum):
+    INTERSECT = auto()
+    UNION = auto()
+
+
+def _merge_sets(
+    then_set: frozenset[str],
+    else_set: frozenset[str],
+    then_term: bool,
+    else_term: bool,
+    policy: _MergePolicy,
+) -> frozenset[str]:
+    """Merge two frozensets across branch endpoints.
+
+    When a branch terminates (return/break/raise), it cannot reach the
+    merge point, so only the other branch's set matters.  When both are
+    live, ``policy`` decides: INTERSECT (conservative -- must hold on
+    both paths) or UNION (conservative -- may hold on either path).
+    """
+    if then_term and else_term:
+        return then_set | else_set
+    if then_term:
+        return else_set
+    if else_term:
+        return then_set
+    if policy is _MergePolicy.INTERSECT:
+        return then_set & else_set
+    return then_set | else_set
+
+
+def _merge_narrowed(
+    then_narrowed: frozenset[tuple[str, TpyType]],
+    else_narrowed: frozenset[tuple[str, TpyType]],
+    then_term: bool,
+    else_term: bool,
+) -> frozenset[tuple[str, TpyType]]:
+    """Merge narrowed-type mappings, represented as frozensets of (name, type) pairs.
+
+    When both branches are live, only narrowings that agree on both sides
+    survive (key present in both with equal type).
+    """
+    if then_term and else_term:
+        then_dict = dict(then_narrowed)
+        then_dict.update(else_narrowed)
+        return frozenset(then_dict.items())
+    if then_term:
+        return else_narrowed
+    if else_term:
+        return then_narrowed
+    then_dict = dict(then_narrowed)
+    else_dict = dict(else_narrowed)
+    merged = {k: v for k, v in then_dict.items()
+              if k in else_dict and else_dict[k] == v}
+    return frozenset(merged.items())
+
+
+def _merge_value_ranges(
+    then_ranges: frozenset[tuple[str, ValueRange]],
+    else_ranges: frozenset[tuple[str, ValueRange]],
+    then_term: bool,
+    else_term: bool,
+) -> frozenset[tuple[str, ValueRange]]:
+    """Merge value range mappings across branch endpoints.
+
+    When both branches are live, per-variable ranges are merged (widened)
+    using ValueRange.merge. Variables tracked on only one branch are dropped
+    (conservative -- we can only use a fact if it holds on all paths).
+    """
+    if then_term and else_term:
+        then_dict = dict(then_ranges)
+        then_dict.update(else_ranges)
+        return frozenset(then_dict.items())
+    if then_term:
+        return else_ranges
+    if else_term:
+        return then_ranges
+    then_dict = dict(then_ranges)
+    else_dict = dict(else_ranges)
+    merged = {}
+    for k, v in then_dict.items():
+        if k in else_dict:
+            merged[k] = ValueRange.merge(v, else_dict[k])
+    return frozenset(merged.items())
+
+
+def _merge_borrow_triples(
+    then_borrows: frozenset[tuple[str, str, BorrowKind]],
+    else_borrows: frozenset[tuple[str, str, BorrowKind]],
+    then_term: bool,
+    else_term: bool,
+) -> frozenset[tuple[str, str, BorrowKind]]:
+    """Merge borrow (storage, borrower, kind) triples across branch endpoints.
+
+    Uses UNION policy: a borrow exists after the merge if it exists in
+    either live branch (conservative -- may hold on either path).
+    When the same (storage, borrower) has different kinds on the two branches,
+    the more dangerous kind wins (element > alias, ptr > alias, iter > alias).
+    """
+    if then_term and else_term:
+        combined = then_borrows | else_borrows
+    elif then_term:
+        combined = else_borrows
+    elif else_term:
+        combined = then_borrows
+    else:
+        combined = then_borrows | else_borrows
+    # Deduplicate (storage, borrower) pairs, keeping the more dangerous kind
+    best: dict[tuple[str, str], BorrowKind] = {}
+    for storage, borrower, kind in combined:
+        key = (storage, borrower)
+        prev = best.get(key)
+        if prev is None or BORROW_KIND_RANK[kind] > BORROW_KIND_RANK[prev]:
+            best[key] = kind
+    return frozenset((s, b, k) for (s, b), k in best.items())
+
+
+@dataclass(frozen=True, slots=True)
+class FlowFacts:
+    """Immutable snapshot of flow-sensitive analysis state."""
+
+    definitely_assigned: frozenset[str] = frozenset()
+    init_terminated: bool = False
+    rvalue_vars: frozenset[str] = frozenset()
+    param_provenance_vars: frozenset[str] = frozenset()
+    safe_to_return_vars: frozenset[str] = frozenset()
+    non_null_ptr_vars: frozenset[str] = frozenset()
+    narrowed_types: frozenset[tuple[str, TpyType]] = frozenset()
+    consumed_vars: frozenset[str] = frozenset()
+    # Borrow map: (storage_name, borrower_name, BorrowKind) triples.
+    # "__for_iter" is used as the borrower for implicit for-loop iterator borrows.
+    borrows: frozenset[tuple[str, str, BorrowKind]] = frozenset()
+    value_ranges: frozenset[tuple[str, ValueRange]] = frozenset()
+
+    @staticmethod
+    def merge(then: FlowFacts, else_: FlowFacts) -> FlowFacts:
+        """Merge flow facts from then/else branches."""
+        then_term = then.init_terminated
+        else_term = else_.init_terminated
+        return FlowFacts(
+            definitely_assigned=_merge_sets(
+                then.definitely_assigned, else_.definitely_assigned,
+                then_term, else_term, _MergePolicy.INTERSECT,
+            ),
+            init_terminated=then_term and else_term,
+            rvalue_vars=_merge_sets(
+                then.rvalue_vars, else_.rvalue_vars,
+                then_term, else_term, _MergePolicy.INTERSECT,
+            ),
+            param_provenance_vars=_merge_sets(
+                then.param_provenance_vars, else_.param_provenance_vars,
+                then_term, else_term, _MergePolicy.INTERSECT,
+            ),
+            safe_to_return_vars=_merge_sets(
+                then.safe_to_return_vars, else_.safe_to_return_vars,
+                then_term, else_term, _MergePolicy.INTERSECT,
+            ),
+            non_null_ptr_vars=_merge_sets(
+                then.non_null_ptr_vars, else_.non_null_ptr_vars,
+                then_term, else_term, _MergePolicy.INTERSECT,
+            ),
+            narrowed_types=_merge_narrowed(
+                then.narrowed_types, else_.narrowed_types,
+                then_term, else_term,
+            ),
+            consumed_vars=_merge_sets(
+                then.consumed_vars, else_.consumed_vars,
+                then_term, else_term, _MergePolicy.UNION,
+            ),
+            borrows=_merge_borrow_triples(
+                then.borrows, else_.borrows,
+                then_term, else_term,
+            ),
+            value_ranges=_merge_value_ranges(
+                then.value_ranges, else_.value_ranges,
+                then_term, else_term,
+            ),
+        )

tpyc/sema/init_tracker.py

@@ -0,0 +1,150 @@
+"""
+TurboPython Definite-Assignment Tracker
+
+Tracks which variables are guaranteed to be initialized on all paths
+reaching the current point. Prevents use-before-assignment errors that
+would be undefined behavior in generated C++.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from .flow_facts import FlowFacts
+
+if TYPE_CHECKING:
+    from ..typesys import TpyType
+    from .context import SemanticContext
+
+
+
+
+class InitTracker:
+    """Definite-assignment and rvalue-vars flow analysis."""
+
+    def __init__(self, ctx: SemanticContext):
+        self.ctx = ctx
+
+    def save(self) -> FlowFacts:
+        return FlowFacts(
+            definitely_assigned=frozenset(self.ctx.func.definitely_assigned),
+            init_terminated=self.ctx.func.init_terminated,
+            rvalue_vars=frozenset(self.ctx.func.rvalue_vars),
+            param_provenance_vars=frozenset(self.ctx.func.param_provenance_vars),
+            safe_to_return_vars=frozenset(self.ctx.func.safe_to_return_vars),
+            non_null_ptr_vars=frozenset(self.ctx.func.non_null_ptr_vars),
+            narrowed_types=frozenset(self.ctx.func.narrowed_types.items()),
+            consumed_vars=frozenset(self.ctx.func.consumed_vars),
+            borrows=self.ctx.func.borrow_tracker.freeze(),
+            value_ranges=frozenset(self.ctx.func.value_ranges.items()),
+        )
+
+    def restore(self, state: FlowFacts) -> None:
+        self.ctx.func.definitely_assigned = set(state.definitely_assigned)
+        self.ctx.func.init_terminated = state.init_terminated
+        self.ctx.func.rvalue_vars = set(state.rvalue_vars)
+        self.ctx.func.param_provenance_vars = set(state.param_provenance_vars)
+        self.ctx.func.safe_to_return_vars = set(state.safe_to_return_vars)
+        self.ctx.func.non_null_ptr_vars = set(state.non_null_ptr_vars)
+        # Invariant: pending post-access ptr-narrowing flushes at statement
+        # boundary (see `analyze_stmt` try/finally). Any entries surviving a
+        # restore would leak into a branch they don't belong to.
+        self.ctx.func.pending_non_null_ptr_vars.clear()
+        self.ctx.func.narrowed_types = dict(state.narrowed_types)
+        self.ctx.func.consumed_vars = set(state.consumed_vars)
+        self.ctx.func.borrow_tracker.restore_from_frozen(state.borrows)
+        self.ctx.func.value_ranges = dict(state.value_ranges)
+
+    def mark_assigned(self, name: str) -> None:
+        self.ctx.func.definitely_assigned.add(name)
+
+    def mark_terminated(self) -> None:
+        self.ctx.func.init_terminated = True
+
+    def mark_provenance(self, name: str, is_param_derived: bool) -> None:
+        """Track whether a variable's storage derives from parameters/globals."""
+        if is_param_derived:
+            self.ctx.func.param_provenance_vars.add(name)
+        else:
+            self.ctx.func.param_provenance_vars.discard(name)
+
+    def mark_safe_to_return(self, name: str, is_safe: bool) -> None:
+        """Record that returning ``name`` after this binding is non-dangling.
+
+        Membership is what is_dangling_return consults for locals, so callers
+        must also keep this set a superset of param_provenance_vars (the
+        merge invariant relied on by FlowFacts.merge / apply_loop_exit_facts).
+        See is_safe_to_return_expr in compatibility.py for the source rule.
+        """
+        if is_safe:
+            self.ctx.func.safe_to_return_vars.add(name)
+        else:
+            self.ctx.func.safe_to_return_vars.discard(name)
+
+    def mark_non_null_ptr(self, name: str, is_non_null: bool) -> None:
+        """Track whether a pointer variable is provably non-null."""
+        if is_non_null:
+            self.ctx.func.non_null_ptr_vars.add(name)
+        else:
+            self.ctx.func.non_null_ptr_vars.discard(name)
+
+    def add_loop_var_provenance(self, name: str) -> None:
+        # Both sets must move together: leaving safe_to_return_vars empty
+        # while populating param_provenance_vars would let an intersecting
+        # merge drop the var from safe_to_return_vars while keeping it in
+        # param_provenance_vars, breaking the documented subset invariant.
+        self.ctx.func.param_provenance_vars.add(name)
+        self.ctx.func.safe_to_return_vars.add(name)
+
+    def remove_loop_var_provenance(self, name: str) -> None:
+        self.ctx.func.param_provenance_vars.discard(name)
+        self.ctx.func.safe_to_return_vars.discard(name)
+
+    def apply_loop_entry_facts(
+        self,
+        before: FlowFacts,
+        condition_type_facts: dict[str, TpyType] | None = None,
+    ) -> None:
+        """Apply flow facts at loop body entry.
+
+        Restores the state from just before the loop, so that outer
+        narrowing proven by enclosing if-blocks is preserved inside the
+        loop body. Any additional narrowing the loop condition itself
+        proves (e.g. ``while x is not None``) is layered on top.
+        """
+        self.ctx.func.definitely_assigned = set(before.definitely_assigned)
+        self.ctx.func.init_terminated = False
+        self.ctx.func.rvalue_vars = set(before.rvalue_vars)
+        self.ctx.func.param_provenance_vars = set(before.param_provenance_vars)
+        self.ctx.func.safe_to_return_vars = set(before.safe_to_return_vars)
+        self.ctx.func.non_null_ptr_vars = set(before.non_null_ptr_vars)
+        self.ctx.func.narrowed_types = dict(before.narrowed_types)
+        self.ctx.func.consumed_vars = set(before.consumed_vars)
+        self.ctx.func.borrow_tracker.restore_from_frozen(before.borrows)
+        self.ctx.func.value_ranges = dict(before.value_ranges)
+        if condition_type_facts is not None:
+            self.ctx.func.narrowed_types.update(condition_type_facts)
+
+    def merge_branches(self, then_state: FlowFacts, else_state: FlowFacts) -> None:
+        self.restore(FlowFacts.merge(then_state, else_state))
+
+    def apply_loop_exit_facts(self, before: FlowFacts) -> None:
+        """Apply post-loop state for a may-execute-zero-times loop.
+
+        Call with live post-body state still in ``ctx.func.*``. Monotone
+        kill-facts (pointer non-null, parameter provenance, safe-to-return,
+        type narrowing) survive iff they held both before the loop AND at
+        body exit, so a reassignment that cleared a fact is not undone by
+        ``restore(before)``.
+
+        Single-pass conservative approximation -- proper fixpoint belongs
+        with the THIR/MIR migration (see ``docs/IR_DESIGN.md``).
+        """
+        body_end_nn_ptr = frozenset(self.ctx.func.non_null_ptr_vars)
+        body_end_param_prov = frozenset(self.ctx.func.param_provenance_vars)
+        body_end_safe_return = frozenset(self.ctx.func.safe_to_return_vars)
+        body_end_narrowed = frozenset(self.ctx.func.narrowed_types.items())
+        self.restore(before)
+        self.ctx.func.non_null_ptr_vars &= body_end_nn_ptr
+        self.ctx.func.param_provenance_vars &= body_end_param_prov
+        self.ctx.func.safe_to_return_vars &= body_end_safe_return
+        self.ctx.func.narrowed_types = dict(body_end_narrowed & before.narrowed_types)

tpyc/sema/list_literals.py

@@ -0,0 +1,69 @@
+"""
+TurboPython Iterable Type Helpers
+
+General-purpose iterable-type queries (is_type_iterable, get_iterable_element_type).
+List literal deduction logic has moved to local_deduction.LocalTypeDeduction.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from ..typesys import (
+    TpyType, GenExprType,
+    is_protocol_type,
+)
+from ..diagnostics import SemanticError
+
+if TYPE_CHECKING:
+    from ..parse import SourceLocation
+    from .context import SemanticContext
+
+from tpyc import modules as builtin_modules
+from ..type_def_registry import is_iterator_adapter
+
+
+class IterableHelper:
+    """General-purpose iterable type queries."""
+
+    def __init__(self, ctx: SemanticContext):
+        self.ctx = ctx
+
+    def is_type_iterable(self, typ: TpyType) -> bool:
+        """Check if a type is iterable.
+
+        A type is iterable if it:
+        - Is a NativeIterable[T], Iterator[T], Iterable[T], or
+          Spannable[T] protocol type (used as parameter type)
+        - Is a compiler-internal iterator adapter (CopyIter[T], OwnIter[T],
+          generator-expression type) or SpanIter[T] (stub-declared but its
+          __iter__(self) -> Self currently bypasses the unified lookup --
+          the parser doesn't resolve Self to SpanIter, so the adapter
+          allowlist covers it; low-priority follow-up)
+        - Has __next__() (Iterator conformance)
+        - Has __iter__() returning an iterator type
+        """
+        if is_protocol_type(typ) and typ.qualified_name() in builtin_modules.ITERABLE_PROTOCOL_QNAMES:
+            return True
+        if is_iterator_adapter(typ) or isinstance(typ, GenExprType):
+            return True
+        if builtin_modules.get_iter_element_type(typ, registry=self.ctx.registry) is not None:
+            return True
+        if builtin_modules.get_error_return_next_element_type(typ, registry=self.ctx.registry) is not None:
+            return True
+        return False
+
+    def get_iterable_element_type_or_none(self, iterable_type: TpyType) -> TpyType | None:
+        """Get the element type of an iterable, or None if not iterable."""
+        return builtin_modules.get_iterable_element_type(iterable_type, registry=self.ctx.registry)
+
+    def get_iterable_element_type(
+        self, iterable_type: TpyType, loc: SourceLocation | None = None,
+    ) -> TpyType:
+        """Get the element type of an iterable for for-each loops.
+
+        Raises SemanticError if type is not iterable.
+        """
+        elem_type = self.get_iterable_element_type_or_none(iterable_type)
+        if elem_type is not None:
+            return elem_type
+        raise SemanticError(f"Cannot iterate over type {iterable_type}", loc)

tpyc/sema/literal_utils.py

@@ -0,0 +1,27 @@
+"""Shared helpers for extracting literal values from AST expression nodes.
+
+Handles bare `str` / `int` / `bool` literals plus the unary-minus form
+`-<int_literal>` (CPython encodes `-1` as `TpyUnaryOp("-", TpyIntLiteral(1))`),
+and peels a single `TpyCoerce` wrapper so callers don't have to.
+"""
+from ..parse import (
+    TpyExpr, TpyStrLiteral, TpyIntLiteral, TpyBoolLiteral, TpyUnaryOp, TpyCoerce,
+)
+from ..typesys import LiteralValue, LiteralTag
+
+
+def literal_value_from_expr(expr: TpyExpr | None) -> LiteralValue | None:
+    """Return a tagged `LiteralValue` for a literal AST node, else None."""
+    if expr is None:
+        return None
+    inner = expr.expr if isinstance(expr, TpyCoerce) else expr
+    if isinstance(inner, TpyStrLiteral):
+        return LiteralValue(LiteralTag.STR, inner.value)
+    if isinstance(inner, TpyBoolLiteral):
+        return LiteralValue(LiteralTag.BOOL, inner.value)
+    if isinstance(inner, TpyIntLiteral):
+        return LiteralValue(LiteralTag.INT, inner.value)
+    if (isinstance(inner, TpyUnaryOp) and inner.op == "-"
+            and isinstance(inner.operand, TpyIntLiteral)):
+        return LiteralValue(LiteralTag.INT, -inner.operand.value)
+    return None