@pineforge/codegen-pyodide 0.9.0 → 0.10.1

package/pineforge_codegen/analyzer/contracts.py

@@ -24,7 +24,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any
 
-from ..symbols import TypeSpec
+from ..symbols import PineType, TypeSpec
 
 
 @dataclass
@@ -88,11 +88,12 @@ class FuncInfo:
     # ``pivot hi`` parameter emits as ``pivot hi`` (not ``double hi``) and an
     # untyped ``s`` used as a string emits as ``std::string s``.
     param_type_specs: list = field(default_factory=list)
-    # ``TypeSpec`` of the function's return value when it is a collection the
-    # coarse ``return_type`` (PineType) cannot represent — today this covers
-    # array-returning functions (``buildPDLevels() => array.from(...)`` ->
-    # ``std::vector<double>``). UDT / drawing-handle returns use
-    # ``udt_return_type``; tuple returns use ``returns_tuple``.
+    # Exact ``TypeSpec`` of the function's return value when downstream
+    # expression inference needs more than the coarse ``return_type`` slot.
+    # This primarily carries arrays/maps and also direct-terminal primitive
+    # array-element reads, whose cached spec prevents inference from re-visiting
+    # a stateful UDF call. UDT / drawing-handle returns use ``udt_return_type``;
+    # tuple returns use ``returns_tuple``.
     return_type_spec: Any = None
 
 
@@ -137,6 +138,12 @@ class SecurityCallInfo:
     expression: Any
     returns_tuple: bool
     tuple_size: int
+    # Exact helper/direct tuple element types. Empty for scalar calls and for
+    # legacy/TA tuple records whose runtime result struct already defines its
+    # field types. User-defined request.security helpers use this to select
+    # numeric-double versus homogeneous-bool aggregate storage without
+    # guessing in codegen.
+    tuple_element_types: tuple[PineType, ...] = ()
     gaps: Any = None
     lookahead: Any = None
     ta_range: Any = None
@@ -181,6 +188,22 @@ class AnalyzerContext:
     symbols: Any               # SymbolTable
     ta_call_sites: list = field(default_factory=list)
     series_vars: set = field(default_factory=set)
+    # Exact emitted member identities for persistent ``var``/``varip``
+    # bindings that are history-referenced.  Unlike ``series_vars`` this set
+    # preserves sibling-block renames such as ``x__blk1``.
+    series_var_members: set = field(default_factory=set)
+    # Exact VarDecl node ids whose binding is history-referenced.  This lets
+    # codegen distinguish a scalar local shadow from a same-named global
+    # Series without relying on the raw-name union above.
+    series_decl_nodes: set = field(default_factory=set)
+    # Exact declaration binding keys ``(node_id, raw_name)``.  TupleAssign has
+    # one AST node for several independently scoped names, so node identity
+    # alone cannot say which destructured element owns history storage.
+    series_decl_bindings: set = field(default_factory=set)
+    # Raw names of exact declaration-bound, non-persistent Series storage.
+    # This excludes history parameters and global reads observed from inside a
+    # callable, both of which also appear in legacy raw series inventories.
+    nonpersistent_series_decl_names: set = field(default_factory=set)
     series_bar_fields: set = field(default_factory=set)
     var_members: list = field(default_factory=list)   # [(name, PineType, init_expr_str)]
     func_infos: list = field(default_factory=list)
@@ -198,11 +221,43 @@ class AnalyzerContext:
     filename: str = "<stdin>"
     global_var_decls: list = field(default_factory=list)  # [(name, PineType)] non-var global scope vars
     global_expr_map: dict = field(default_factory=dict)   # name -> defining AST expr (global, non-var)
+    # Exact lexical binding scope for each visited Identifier AST node.  Raw
+    # name lookup is not enough once a UDF parameter, block local, or loop
+    # iterator shadows a same-spelled global binding.
+    identifier_binding_scopes: dict = field(default_factory=dict)  # id(Identifier) -> scope name | None
     var_member_init_exprs: dict = field(default_factory=dict)  # var-member name -> init AST expr
+    # id(VarDecl) -> (node, emitted member name, PineType, rendered initializer,
+    #                 is function/method scoped)
+    var_member_metadata_by_node: dict = field(default_factory=dict)
+    # id(VarDecl) -> exact structured declaration type.  Name-keyed type
+    # registries cannot distinguish sibling/callable persistent bindings.
+    var_member_type_specs_by_node: dict = field(default_factory=dict)
+    # id(VarDecl) -> owning callable key (``FuncInfo.name``), or None for
+    # top-level/on-bar persistent bindings.
+    var_member_owners_by_node: dict = field(default_factory=dict)
     # Per-call-site TA member cloning for user functions:
     func_ta_ranges: dict = field(default_factory=dict)    # func_name -> (start_idx, end_idx)
+    # Exact TA indices belonging to each callable path. ``func_ta_ranges`` is
+    # retained as the legacy stateful-callable marker, but a widened min/max
+    # range can contain unrelated sites allocated between two borrowed sites.
+    func_ta_indices: dict = field(default_factory=dict)   # func_name -> [site_idx, ...]
     func_call_cs_map: dict = field(default_factory=dict)  # call_node_id -> (func_name, call_site_index)
+    # Removed lexical nested-call mappings inherit their natural parent's
+    # active cs index. Fresh context-sensitive parents have no such index, so
+    # codegen uses this exact node -> callee identity to compose dispatch.
+    func_inherited_call_names: dict = field(default_factory=dict)
     func_call_site_counts: dict = field(default_factory=dict)  # func_name -> int
+    # Exact primitive parameter/return types for each emitted written-callsite
+    # variant.  Untyped Pine parameters are independently specialized at every
+    # written call; collapsing these onto FuncInfo's first observed type makes
+    # generated semantics depend on source order (for example one ``src[1]``
+    # helper called with both ``bar_index`` and ``close``).
+    func_callsite_param_types: dict = field(default_factory=dict)
+    func_callsite_return_types: dict = field(default_factory=dict)
+    # Declaration-time parameter specs, before any call-site inference fills
+    # untyped slots on the legacy FuncInfo record.  Codegen uses this to apply
+    # variant overrides only to genuinely untyped parameters.
+    func_declared_param_type_specs: dict = field(default_factory=dict)
     # Functions that need per-call-site body cloning PURELY because they
     # contain a request.security(...) whose timeframe is a UDF parameter
     # called with >= 2 distinct literal timeframes (the security-tf-
@@ -225,15 +280,57 @@ class AnalyzerContext:
     # request.security calls (see SecurityCallInfo):
     security_calls: list = field(default_factory=list)
     global_mutable_infos: dict = field(default_factory=dict)  # name -> MutableGlobalInfo
+    # AST-authoritative top-level non-var binding names.  Unlike
+    # ``global_var_decls``, this is not filtered through legacy raw Series
+    # tracking and therefore survives same-named callable history state.
+    ordinary_global_binding_names: set = field(default_factory=set)
+    # Exact subset whose own top-level declaration is history-bearing.  A raw
+    # callable Series name does not promote a same-named scalar/map global.
+    ordinary_global_series_names: set = field(default_factory=set)
     # Per-function var_members + series_vars (used when emitting per-function call-site variants):
     func_var_members: dict = field(default_factory=dict)
+    # Ordinary FuncDef persistent locals keep their Pine spelling in
+    # ``func_var_members`` for lexical/type analysis.  When its storage would
+    # collide with another persistent lexical declaration, this owner-scoped
+    # overlay carries the collision-safe class-member identity instead:
+    # ``func_name -> {raw_name: emitted_member_name}``.
+    #
+    # Keeping lexical and storage identity separate is important.  Clone maps
+    # operate on emitted members, while a function body must not see the new
+    # member until its declaration has executed (so an earlier same-named
+    # global read remains lexical Pine, not the future local).
+    func_var_storage_names: dict = field(default_factory=dict)
     func_series_vars: dict = field(default_factory=dict)
-    # Per-function array-return TypeSpec (see FuncInfo.return_type_spec).
+    # FuncDef owner -> declaration-bound non-persistent history-local names.
+    # Parameters are deliberately excluded so a same-named qualified
+    # persistent member does not manufacture a bogus raw/clone Series.
+    func_nonpersistent_series_vars: dict = field(default_factory=dict)
+    # Per-function exact return TypeSpec (see FuncInfo.return_type_spec).
     func_return_type_specs: dict = field(default_factory=dict)
     # var_name -> UDT type name for variables instantiated via TypeName.new(...)
     udt_var_types: dict[str, str] = field(default_factory=dict)
     # var_name -> structured collection/UDT type metadata
     collection_types: dict[str, TypeSpec] = field(default_factory=dict)
+    # Stable callable key -> raw local name -> collection TypeSpec.  Function
+    # and method locals are lexical: two callables may both declare ``values``
+    # with unrelated collection kinds/element types, so they cannot share the
+    # top-level raw-name registry above.
+    func_collection_types: dict[str, dict[str, TypeSpec]] = field(default_factory=dict)
+    # id(immediate branch/loop owner) -> raw local name -> collection TypeSpec.
+    # Sibling lexical blocks may reuse one raw name with unrelated kinds, so
+    # their bindings cannot be collapsed into ``func_collection_types``.
+    block_collection_types: dict[int, dict[str, TypeSpec | None]] = field(default_factory=dict)
+    # Block id -> owning FuncInfo key. Used for dead-callable header filtering
+    # and exact persistent-member TypeSpec lookup outside callable emission.
+    block_collection_owners: dict[int, str] = field(default_factory=dict)
+    # id(callable-local VarDecl) -> exact collection TypeSpec, or None for a
+    # non-collection declaration that lexically tombstones an outer binding.
+    callable_collection_bindings: dict[int, TypeSpec | None] = field(default_factory=dict)
+    # Declaration node id -> owning callable key.  Persistent-member emission
+    # happens outside the analyzer's lexical scope, so raw names alone cannot
+    # distinguish a real persistent collection from a same-named ordinary
+    # local in another callable.
+    callable_collection_binding_owners: dict[int, str] = field(default_factory=dict)
     # UDT name -> field_name -> structured type metadata
     udt_field_type_specs: dict[str, dict[str, TypeSpec]] = field(default_factory=dict)
     # id(block_node) -> {raw_var_name: scope_unique_member_name} for block-scoped