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

tpyc/prescan.py

@@ -0,0 +1,254 @@
+"""Pre-scan utilities for TurboPython function bodies.
+
+Pure AST walking -- no type registry or analysis context needed.
+Run once in sema; results consumed by both sema and codegen.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields as dc_fields
+
+from .parse import (
+    TpyStmt, TpyExpr, TpyVarDecl, TpyTupleUnpack, TpyAssign, TpyAugAssign,
+    TpyForEach, TpyWith, TpyName, TpySubscript,
+    TpyCall, TpyBinOp, TpyChainedCompare, TpyUnaryOp, TpyMethodCall,
+    TpyIntLiteral, TpyFloatLiteral, TpyStrLiteral,
+    TpyBoolLiteral, TpyNoneLiteral, TpyArrayLiteral, TpyListRepeat,
+    TpyCoerce, TpyFieldAccess, TpyIfExpr, TpyNamedExpr,
+    TpyNestedDef,
+    TpyFStringValue, TpyComprehensionGenerator,
+    TpyDictLiteral, TpySetLiteral, TpyTupleLiteral, TpyFString,
+)
+
+
+@dataclass
+class ScanResult:
+    """Result of pre-scanning a function body for reassigned variables."""
+    reassigned: set[str] = field(default_factory=set)
+    rvalue_reassigned: set[str] = field(default_factory=set)
+    lvalue_reassigned: set[str] = field(default_factory=set)
+    aug_assigned: set[str] = field(default_factory=set)
+    # alias_name -> source_name for lvalue-initialized, non-reassigned variables
+    # with simple TpyName init (T& reference candidates).
+    alias_sources: dict[str, str] = field(default_factory=dict)
+    # Variables initially aliased from another name (before reassignment cleanup).
+    # Used by del codegen to avoid destroying through a pointer that may
+    # still point at the source variable's storage.
+    initial_alias_names: set[str] = field(default_factory=set)
+
+
+def scan_reassigned_vars(stmts: list[TpyStmt],
+                         pre_declared: set[str] | None = None) -> ScanResult:
+    """Pre-scan a function body to find variables that are reassigned after first declaration.
+
+    Args:
+        stmts: The statements to scan.
+        pre_declared: Names already in scope (e.g. function parameters).
+            Assignment to these names counts as reassignment.
+
+    Returns a ScanResult with:
+    - reassigned: variables with a second TpyVarDecl or TpyAssign after first declaration
+    - rvalue_reassigned: subset of reassigned with at least one rvalue reassignment
+    - lvalue_reassigned: subset of reassigned with at least one lvalue reassignment
+    - aug_assigned: variables targeted by augmented assignment (+=, -=, etc.)
+    """
+    declared: set[str] = set(pre_declared) if pre_declared else set()
+    result = ScanResult()
+    _scan_stmts(stmts, declared, result)
+    result.initial_alias_names = set(result.alias_sources.keys())
+    # Reassigned vars become T* pointers, not T& refs -- remove from alias map
+    for name in result.reassigned:
+        result.alias_sources.pop(name, None)
+    return result
+
+
+def _expr_to_narrowing_key(expr: TpyExpr) -> str | None:
+    """Convert an expression to a narrowing key string.
+
+    Returns a simple name for TpyName, or a dotted path for multi-level
+    TpyFieldAccess (e.g. "obj.field", "obj.inner.field").
+    Returns None for unsupported expressions.
+    """
+    if isinstance(expr, TpyName):
+        return expr.name
+    if isinstance(expr, TpyNamedExpr):
+        return expr.target
+    if isinstance(expr, TpyFieldAccess):
+        obj_key = _expr_to_narrowing_key(expr.obj)
+        if obj_key is not None:
+            return f"{obj_key}.{expr.field}"
+    return None
+
+
+# A deref-view narrowing rides `narrowed_types` under a distinct key: it
+# narrows the polymorphic payload reached through an owning wrapper's
+# reference-returning __deref__ (`if isinstance(rc, Dog): rc.bark()` resolves
+# `bark` against Dog through the deref, while `rc.clone()` stays an Rc method).
+# Keying it apart from the wrapper variable's own narrowing key leaves the
+# wrapper type untouched and lets the existing save/restore/merge-at-joins
+# machinery for narrowed_types apply unchanged -- exactly like field-path
+# narrowing keys. The NUL suffix cannot collide with any source-level dotted
+# path produced by _expr_to_narrowing_key.
+#
+# INVARIANT: a deref-view key is NOT a `name.`-dotted field path, so the
+# field-path prefix sweeps (NarrowingTracker._invalidate_field_facts and
+# friends) do NOT cover it. Any code that invalidates narrowed_types on a
+# write/mutation of `name` must also drop deref_view_key(name) explicitly (see
+# update_after_write); a prefix-scan alone silently leaves the deref-view fact
+# stale -- the bug class that null-derefs a reassigned wrapper.
+_DEREF_VIEW_SUFFIX = "\x00deref"
+
+
+def deref_view_key(narrowing_key: str) -> str:
+    """Map a receiver narrowing key to its deref-view narrowing key."""
+    return narrowing_key + _DEREF_VIEW_SUFFIX
+
+
+def parse_deref_view_key(key: str) -> 'str | None':
+    """If `key` is a deref-view narrowing key, return the receiver key it wraps;
+    otherwise None."""
+    if key.endswith(_DEREF_VIEW_SUFFIX):
+        return key[:-len(_DEREF_VIEW_SUFFIX)]
+    return None
+
+
+def match_is_none(expr: TpyExpr) -> tuple[str, bool] | None:
+    """Match `v is None`, `v is not None`, `None is v`, `None is not v`.
+
+    Also matches dotted field access at any depth: `obj.field is None`,
+    `obj.a.b is None`, etc.
+    Returns (key, is_not_none) or None if the pattern doesn't match.
+    The key is a simple name or a dotted path ("obj.field", "obj.a.b").
+    """
+    if not isinstance(expr, TpyBinOp) or expr.op not in ("is", "is not"):
+        return None
+    key: str | None = None
+    if isinstance(expr.right, TpyNoneLiteral):
+        key = _expr_to_narrowing_key(expr.left)
+    elif isinstance(expr.left, TpyNoneLiteral):
+        key = _expr_to_narrowing_key(expr.right)
+    if key is None:
+        return None
+    return key, expr.op == "is not"
+
+
+def is_scan_rvalue(expr: TpyExpr | None) -> bool:
+    """Conservative rvalue check for pre-scan (no type registry needed)."""
+    if expr is None:
+        return False
+    if isinstance(expr, TpyCoerce):
+        return is_scan_rvalue(expr.expr)
+    if isinstance(expr, (TpyName, TpySubscript)):
+        return False
+    if isinstance(expr, TpyFieldAccess):
+        return is_scan_rvalue(expr.obj)
+    if isinstance(expr, TpyNamedExpr):
+        return is_scan_rvalue(expr.value)
+    return isinstance(expr, (TpyCall, TpyBinOp, TpyChainedCompare, TpyUnaryOp, TpyMethodCall,
+                             TpyIntLiteral, TpyFloatLiteral, TpyStrLiteral,
+                             TpyBoolLiteral, TpyNoneLiteral, TpyArrayLiteral, TpyListRepeat,
+                             TpyDictLiteral, TpySetLiteral, TpyTupleLiteral, TpyFString,
+                             TpyIfExpr))
+
+
+def _scan_walrus_in_expr(expr: TpyExpr | None, declared: set[str],
+                         result: ScanResult) -> None:
+    """Walk an expression tree to find walrus operator bindings.
+
+    Uses generic dataclass field introspection so new expression types
+    are handled automatically without manual enumeration.
+    """
+    if expr is None:
+        return
+    if isinstance(expr, TpyNamedExpr):
+        if expr.target in declared:
+            result.reassigned.add(expr.target)
+            result.rvalue_reassigned.add(expr.target)
+        else:
+            declared.add(expr.target)
+    for f in dc_fields(expr):
+        val = getattr(expr, f.name)
+        if isinstance(val, TpyExpr):
+            _scan_walrus_in_expr(val, declared, result)
+        elif isinstance(val, TpyComprehensionGenerator):
+            _scan_walrus_in_expr(val.iterable, declared, result)
+            for cond in val.conditions:
+                _scan_walrus_in_expr(cond, declared, result)
+        elif isinstance(val, list):
+            for item in val:
+                if isinstance(item, TpyExpr):
+                    _scan_walrus_in_expr(item, declared, result)
+                elif isinstance(item, TpyFStringValue):
+                    _scan_walrus_in_expr(item.expr, declared, result)
+        elif isinstance(val, dict):
+            for v in val.values():
+                if isinstance(v, TpyExpr):
+                    _scan_walrus_in_expr(v, declared, result)
+
+
+def _scan_walrus_in_stmt(stmt: TpyStmt, declared: set[str],
+                          result: ScanResult) -> None:
+    """Scan expressions within a statement for walrus bindings."""
+    for expr in stmt.exprs():
+        _scan_walrus_in_expr(expr, declared, result)
+
+
+def _scan_stmts(stmts: list[TpyStmt], declared: set[str],
+                result: ScanResult) -> None:
+    for stmt in stmts:
+        # Scan for walrus bindings inside expressions before normal stmt scanning
+        _scan_walrus_in_stmt(stmt, declared, result)
+        if isinstance(stmt, TpyVarDecl):
+            if stmt.name in declared:
+                result.reassigned.add(stmt.name)
+                if is_scan_rvalue(stmt.init):
+                    result.rvalue_reassigned.add(stmt.name)
+                else:
+                    result.lvalue_reassigned.add(stmt.name)
+            else:
+                declared.add(stmt.name)
+                if (stmt.init is not None
+                        and isinstance(stmt.init, TpyName)
+                        and stmt.init.name != stmt.name):
+                    result.alias_sources[stmt.name] = stmt.init.name
+        elif isinstance(stmt, TpyAssign):
+            if isinstance(stmt.target, TpyName) and stmt.target.name in declared:
+                result.reassigned.add(stmt.target.name)
+                if is_scan_rvalue(stmt.value):
+                    result.rvalue_reassigned.add(stmt.target.name)
+                else:
+                    result.lvalue_reassigned.add(stmt.target.name)
+        elif isinstance(stmt, TpyTupleUnpack):
+            for name in stmt.targets:
+                if name is None:
+                    continue
+                if name in declared:
+                    result.reassigned.add(name)
+                    # std::get<i>(tmp) is always an rvalue
+                    result.rvalue_reassigned.add(name)
+                else:
+                    declared.add(name)
+        elif isinstance(stmt, TpyAugAssign):
+            if isinstance(stmt.target, TpyName) and stmt.target.name in declared:
+                result.aug_assigned.add(stmt.target.name)
+        elif isinstance(stmt, TpyNestedDef):
+            name = stmt.func.name
+            if name in declared:
+                result.reassigned.add(name)
+                result.rvalue_reassigned.add(name)
+            else:
+                declared.add(name)
+            # Do NOT recurse into nested body (separate scope)
+        # Recurse into sub-bodies (if/while/for/with)
+        if isinstance(stmt, TpyForEach):
+            declared.add(stmt.var)
+        if isinstance(stmt, TpyWith):
+            for item in stmt.items:
+                if item.target is not None:
+                    if item.target in declared:
+                        result.reassigned.add(item.target)
+                        result.rvalue_reassigned.add(item.target)
+                    else:
+                        declared.add(item.target)
+        for body in stmt.sub_bodies():
+            _scan_stmts(body, declared, result)

tpyc/qnames.py

@@ -0,0 +1,149 @@
+"""
+Qualified name constants for compiler-known types, decorators, and protocols.
+
+These constants are the canonical identifiers used by the parser and sema to
+dispatch on well-known names. They match the @builtin_type("...") and
+@builtin_decorator("...") annotations in .py stubs under lib/tpy/.
+"""
+
+# -- Builtin types --
+BOOL = "builtins.bool"
+INT = "builtins.int"
+FLOAT = "builtins.float"
+STR = "builtins.str"
+TUPLE = "builtins.tuple"
+BASIC_SLICE = "tpy.basic_slice"
+SLICE = "builtins.slice"
+TYPE = "builtins.type"
+NONE = "builtins.None"
+LIST = "builtins.list"
+DICT = "builtins.dict"
+DICT_KEYS = "builtins.dict_keys"
+DICT_VALUES = "builtins.dict_values"
+DICT_ITEMS = "builtins.dict_items"
+SET = "builtins.set"
+RANGE = "builtins.Range"
+EXCEPTION = "builtins.Exception"
+BASE_EXCEPTION = "builtins.BaseException"
+STOP_ITERATION = "builtins.StopIteration"
+
+# -- tpy types --
+PTR = "tpy.Ptr"
+OWN = "tpy.Own"
+FN = "tpy.Fn"
+SPAN = "tpy.Span"
+ARRAY = "tpy.Array"
+SPAN_ITER = "tpy.SpanIter"
+CHAR = "tpy.Char"
+FLOAT32 = "tpy.Float32"
+STRING = "tpy.String"
+STRVIEW = "tpy.StrView"
+
+# Fixed-width integers
+INT8 = "tpy.Int8"
+INT16 = "tpy.Int16"
+INT32 = "tpy.Int32"
+INT64 = "tpy.Int64"
+UINT8 = "tpy.UInt8"
+UINT16 = "tpy.UInt16"
+UINT32 = "tpy.UInt32"
+UINT64 = "tpy.UInt64"
+
+# Map from qualified name to short name for all fixed ints
+FIXED_INT_NAMES = {
+    INT8: "Int8", INT16: "Int16", INT32: "Int32", INT64: "Int64",
+    UINT8: "UInt8", UINT16: "UInt16", UINT32: "UInt32", UINT64: "UInt64",
+}
+
+# -- tpy decorators / type modifiers --
+READONLY = "tpy.readonly"
+NOALLOC = "tpy.noalloc"
+NOCOPY = "tpy.nocopy"
+PURE = "tpy.pure"
+INLINE = "tpy.inline"
+DYNAMIC = "tpy.dynamic"
+ERROR_RETURN = "tpy.error_return"
+AUTO_READONLY = "tpy.auto_readonly"
+AUTO_OWN = "tpy.auto_own"
+
+# -- typing --
+PROTOCOL = "typing.Protocol"
+SELF = "typing.Self"
+OPTIONAL = "typing.Optional"
+FINAL = "typing.Final"
+CLASSVAR = "typing.ClassVar"
+CALLABLE = "typing.Callable"
+OVERLOAD = "typing.overload"
+OVERRIDE = "typing.override"
+LITERAL = "typing.Literal"
+TYPED_DICT = "typing.TypedDict"
+UNPACK = "typing.Unpack"
+
+# -- typing protocols --
+ITERATOR = "typing.Iterator"
+ITERABLE = "typing.Iterable"
+SIZED = "typing.Sized"
+SEQUENCE = "typing.Sequence"
+
+# -- tpy.coro / asyncio --
+AWAITABLE = "tpy.coro.Awaitable"
+CANCELLABLE = "tpy.coro.Cancellable"
+POLL = "tpy.coro.Poll"
+ASYNCIO_RUN = "asyncio.run"
+ASYNCIO_CREATE_TASK = "asyncio.create_task"
+
+# -- tpy @builtin_function names with bespoke codegen emission --
+COPY = "tpy.copy"
+COPY_ITER = "tpy.copy_iter"
+OWN_ITER = "tpy.own_iter"
+TRY_PARSE = "tpy.try_parse"
+
+# -- tpy protocols --
+NATIVE_ITERABLE = "tpy.NativeIterable"
+NATIVE_RANGE_CONSTRUCTIBLE = "tpy.NativeRangeConstructible"
+SPANNABLE = "tpy.Spannable"
+VALUE_TYPE = "tpy.ValueType"
+COPYABLE = "tpy.Copyable"
+SEND = "tpy.Send"
+SYNC = "tpy.Sync"
+DEFAULT = "tpy.Default"
+COVARIANT = "tpy.Covariant"
+RETURN_EXCEPTION = "tpy.ReturnException"
+THROWABLE = "tpy.Throwable"
+# Phase 20: methods auto-emitted by codegen on every concrete Throwable
+# subclass (clone returns a heap-allocated polymorphic copy at the
+# concrete type, __raise__ throws *this, what reads the message field).
+# Sema rejects user-defined overrides of these names on Throwable
+# subclasses to prevent a C++ redefinition collision.
+THROWABLE_ABI_METHODS = ("clone", "__raise__", "what")
+HASHABLE = "tpy.Hashable"
+COMPARABLE = "tpy.Comparable"
+EQUATABLE = "tpy.Equatable"
+DEREF = "tpy.Deref"
+TRUTHY = "tpy.Truthy"
+STRINGABLE = "tpy.Stringable"
+REPRESENTABLE = "tpy.Representable"
+ANY_FIXED_INT = "tpy.AnyFixedInt"
+ANY_FIXED_SIGNED = "tpy.AnyFixedSigned"
+ANY_FIXED_UNSIGNED = "tpy.AnyFixedUnsigned"
+
+# -- tpy.extern decorators --
+NATIVE = "tpy.extern.native"
+EXPORT = "tpy.extern.export"
+CPP_TEMPLATE = "tpy.extern.cpp_template"
+BUILTIN_TYPE = "tpy.extern.builtin_type"
+BUILTIN_DECORATOR = "tpy.extern.builtin_decorator"
+VALUE_PTR_COERCION = "tpy.extern.value_ptr_coercion"
+NATIVE_PRESERVES_REFS = "tpy.extern.native_preserves_refs"
+TYPE_PARAM_DEFAULT = "tpy.extern.type_param_default"
+BUILTIN_FUNCTION = "tpy.extern.builtin_function"
+DEFAULT_INT = "tpy.extern.DefaultInt"
+
+# -- enum --
+ENUM = "enum.Enum"
+INT_ENUM = "enum.IntEnum"
+ENUM_AUTO = "enum.auto"
+
+# -- builtins special --
+STATICMETHOD = "builtins.staticmethod"
+PROPERTY = "builtins.property"