@pineforge/codegen-pyodide 0.8.0 → 0.9.0

package/pineforge_codegen/analyzer/contracts.py

@@ -37,6 +37,20 @@ class TACallSite:
     returns_tuple: bool        # e.g., MACD, supertrend
     node: Any = None           # the FuncCall AST node
     is_static: bool = False    # true if global scope & arguments are recursively static
+    # Name of the user function that OWNS this site, or None for a top-level
+    # site. For an ORIGINAL site this is the function whose body textually
+    # contains the ``ta.*`` call. For a CLONE minted in
+    # ``_handle_user_func_call`` this is the CALLEE (the function being
+    # called, NOT the caller whose body visit triggered the clone) -- the
+    # clone belongs to the callee's per-call-site namespace.
+    #
+    # The codegen's dead-code pass keys off this rather than off
+    # ``func_ta_ranges`` slices, because a function's slice can include
+    # clones of ANOTHER (live) function's sites (minted while visiting a
+    # caller's body). Marking such a borrowed clone dead would leave the
+    # owning callee's emitted clone body referencing undeclared members
+    # (regression: quantbyboji-nq-hma-midday ``_ta_change_*_cs1``).
+    owner_func: str | None = None
 
 
 @dataclass
@@ -65,6 +79,21 @@ class FuncInfo:
     # ``Sample s = build_sample(...)`` then ``s.score()`` dispatches
     # correctly. Probe: data/validation/udt-method-probe-20-udt-return-from-func.
     udt_return_type: str | None = None
+    # Parallel to ``node.params``; each entry is a ``TypeSpec`` (or ``None``)
+    # carrying UDT / drawing-handle / precise-scalar typing that the coarse
+    # ``param_types`` (PineType) cannot represent. Populated from the
+    # function's declared parameter type hints (authoritative) and, for
+    # untyped params, from the call-site argument type. The codegen prefers
+    # this over ``param_types`` when emitting each parameter's C++ type so a
+    # ``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``.
+    return_type_spec: Any = None
 
 
 @dataclass
@@ -72,6 +101,13 @@ class FixnanCallSite:
     """Per-call-site state for ``fixnan(...)`` (one previous-value member each)."""
     member_name: str           # e.g., "_prev_fixnan_1"
     pine_type: Any             # PineType
+    node: Any = None           # the FuncCall AST node (for variant-aware lookup)
+    # Name of the user function that OWNS this site, or None for a top-level
+    # site. Mirrors ``TACallSite.owner_func``: the codegen's dead-code pass
+    # and per-variant clone logic key off this so a fixnan site minted inside
+    # a dead caller's body but cloned for a live callee survives, and each
+    # emitted function variant references its OWN fixnan member.
+    owner_func: str | None = None
 
 
 @dataclass
@@ -104,9 +140,33 @@ class SecurityCallInfo:
     gaps: Any = None
     lookahead: Any = None
     ta_range: Any = None
+    # request.security(ticker.heikinashi(syminfo.tickerid), ...) — the chart's own
+    # symbol read as Heikin-Ashi candles. The engine applies the HA OHLC transform
+    # to each (aggregated) bar before evaluating the security expression; the
+    # expression's close/open/high/low therefore see HA values. Same-symbol only.
+    heikinashi: bool = False
     depends_on_mutable_globals: bool = False
     mutable_globals: tuple[str, ...] = ()
     is_lower_tf_array: bool = False
+    # Name of the user function whose body contains this call ("" at global
+    # scope). A ``request.security(sym, tf, ...)`` whose ``tf`` is that
+    # function's parameter cannot be resolved at class scope (the security
+    # evaluator is a class method, not the function body) — the codegen resolves
+    # such a param-tf from the function's call sites instead.
+    containing_func: str = ""
+    # Set when this SecurityCallInfo is one of N per-call-site CLONES of a
+    # single source request.security(...) whose ``timeframe`` is a UDF
+    # parameter called from >= 2 sites with >= 2 distinct literal timeframes
+    # (e.g. ``scoreFromRange(tf) => request.security(sym, tf, ...)`` called as
+    # ``scoreFromRange("15")``, ``scoreFromRange("240")``, ...). Each clone's
+    # ``timeframe`` is rewritten to a literal StringLiteral for its call site
+    # and gets its own unique ``sec_id``; ``callsite_idx`` is the SAME index
+    # ``func_call_cs_map`` assigns that call site for the existing per-
+    # call-site UDF-body-cloning mechanism, so the codegen can pick the right
+    # clone's ``sec_id`` while emitting that call site's specialized function
+    # body (``self._active_call_site_idx``). None for an ordinary
+    # (non-cloned) security call.
+    callsite_idx: int | None = None
 
 
 @dataclass
@@ -125,6 +185,14 @@ class AnalyzerContext:
     var_members: list = field(default_factory=list)   # [(name, PineType, init_expr_str)]
     func_infos: list = field(default_factory=list)
     fixnan_sites: list = field(default_factory=list)
+    # Per-function fixnan site ownership (func_name -> list of indices into
+    # ``fixnan_sites``). Used by the codegen to clone fixnan members per
+    # call-site variant and to skip fixnan state owned by dead functions.
+    func_fixnan_indices: dict = field(default_factory=dict)
+    # (func_name, cs_idx) -> {orig_member_name: cloned_member_name}. Like
+    # ``func_cs_ta_clone_names`` but for fixnan: populated only when the
+    # default ``{base}_cs{cs_idx}`` clone name collides.
+    func_cs_fixnan_clone_names: dict = field(default_factory=dict)
     strategy_params: dict = field(default_factory=dict)
     diagnostics: list = field(default_factory=list)    # warnings
     filename: str = "<stdin>"
@@ -135,6 +203,21 @@ class AnalyzerContext:
     func_ta_ranges: dict = field(default_factory=dict)    # func_name -> (start_idx, end_idx)
     func_call_cs_map: dict = field(default_factory=dict)  # call_node_id -> (func_name, call_site_index)
     func_call_site_counts: dict = field(default_factory=dict)  # func_name -> int
+    # 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-
+    # monomorphization case), even though they have no TA call sites or
+    # series/var members of their own (the usual trigger for cloning). The
+    # codegen's function-emission gate ORs this in alongside has_ta/
+    # has_series so self._active_call_site_idx is actually set while it
+    # emits each call site's body — required for the per-clone
+    # SecurityCallInfo.callsite_idx disambiguation in visit_call.py to work.
+    func_security_clone_only: set = field(default_factory=set)
+    # (func_name, cs_idx) -> {orig_member_name: cloned_member_name}. Populated by
+    # the analyzer ONLY for clones whose default ``{base}_cs{cs_idx}`` name would
+    # collide with a clone minted through another enclosing function; lets codegen
+    # use the disambiguated name instead of re-deriving a colliding one.
+    func_cs_ta_clone_names: dict = field(default_factory=dict)
     # UDT / enum definitions:
     udt_defs: dict = field(default_factory=dict)          # type_name -> {field_name: PineType}
     enum_defs: dict = field(default_factory=dict)         # enum_name -> [member names]
@@ -145,12 +228,20 @@ class AnalyzerContext:
     # Per-function var_members + series_vars (used when emitting per-function call-site variants):
     func_var_members: dict = field(default_factory=dict)
     func_series_vars: dict = field(default_factory=dict)
+    # Per-function array-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)
     # 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
+    # ``var``/``varip`` declarations whose raw name collides with a same-named
+    # block var in a sibling scope. Codegen activates the rename via
+    # ``_active_var_remap`` while emitting that block's statements so reads/writes
+    # of the var resolve to the disambiguated member.
+    block_var_renames: dict[int, dict[str, str]] = field(default_factory=dict)
     # ``// @pf-trace name=expr`` pragmas in source order. Populated by
     # :func:`pineforge_codegen.pragmas.extract_pf_trace_pragmas` from
     # the original source text and attached after :class:`Analyzer`

package/pineforge_codegen/analyzer/diagnostics.py

@@ -89,8 +89,22 @@ class DiagnosticsHelper:
             loc,
         )
 
+    # Non-atomic node kinds whose serialized infix form must be parenthesized
+    # when used as an operand, so the string re-parses to the SAME tree. A TA
+    # ctor-arg string produced here is later re-parsed and lowered by the
+    # codegen (``_runtime_ctor_arg_for_reset``); a flattened ``(a - b) / c``
+    # would otherwise silently reassociate under C++ precedence.
+    _NONATOMIC_EXPR_NODES = (BinOp, UnaryOp, Ternary)
+
+    def _operand_to_str(self, node: ASTNode) -> str:
+        s = self._expr_to_str(node)
+        if isinstance(node, self._NONATOMIC_EXPR_NODES):
+            return f"({s})"
+        return s
+
     def _expr_to_str(self, node: ASTNode) -> str:
-        """Convert an expression node to a rough string representation."""
+        """Convert an expression node to a string that re-parses to the same
+        tree (grouping preserved for non-atomic operands)."""
         if isinstance(node, NumberLiteral):
             return str(node.value)
         if isinstance(node, StringLiteral):
@@ -104,9 +118,9 @@ class DiagnosticsHelper:
         if isinstance(node, MemberAccess):
             return f"{self._expr_to_str(node.object)}.{node.member}"
         if isinstance(node, BinOp):
-            return f"{self._expr_to_str(node.left)} {node.op} {self._expr_to_str(node.right)}"
+            return f"{self._operand_to_str(node.left)} {node.op} {self._operand_to_str(node.right)}"
         if isinstance(node, UnaryOp):
-            return f"{node.op}{self._expr_to_str(node.operand)}"
+            return f"{node.op}{self._operand_to_str(node.operand)}"
         if isinstance(node, FuncCall):
             args = ", ".join(self._expr_to_str(a) for a in node.args)
             callee_str = self._expr_to_str(node.callee)
@@ -114,5 +128,5 @@ class DiagnosticsHelper:
         if isinstance(node, Subscript):
             return f"{self._expr_to_str(node.object)}[{self._expr_to_str(node.index)}]"
         if isinstance(node, Ternary):
-            return f"{self._expr_to_str(node.condition)} ? {self._expr_to_str(node.true_val)} : {self._expr_to_str(node.false_val)}"
+            return f"{self._operand_to_str(node.condition)} ? {self._operand_to_str(node.true_val)} : {self._operand_to_str(node.false_val)}"
         return "<?>"

package/pineforge_codegen/analyzer/tables.py

@@ -110,7 +110,7 @@ TA_CLASS_MAP = {
 TA_PERIOD_ARG = {
     "sma": 1, "ema": 1, "rma": 1, "rsi": 1, "atr": 0,
     "highest": 1, "lowest": 1, "change": 1,
-    "wma": 1, "hma": 1, "stdev": 1,
+    "wma": 1, "hma": 1,
     # Task 6
     "sum": 1,
     # Task 7 Batch 1
@@ -119,7 +119,7 @@ TA_PERIOD_ARG = {
     "mom": 1, "roc": 1, "rising": 1, "falling": 1, "cci": 1,
     # cum has no period arg — handled in TA_NO_CTOR
     # Task 7 Batch 3
-    "variance": 1, "median": 1, "highestbars": 1, "lowestbars": 1,
+    "median": 1, "highestbars": 1, "lowestbars": 1,
     # Batch 4
     "cmo": 1, "cog": 1, "correlation": 2,
     "percentile_nearest_rank": 1, "percentile_linear_interpolation": 1,
@@ -130,6 +130,14 @@ TA_PERIOD_ARG = {
 
 # Functions that return tuples
 TA_TUPLE_RETURNS = {"macd", "supertrend", "dmi", "bb", "kc", "vwap_bands"}
+TA_TUPLE_ELEMENT_COUNTS = {
+    "macd": 3,
+    "supertrend": 2,
+    "dmi": 3,
+    "bb": 3,
+    "kc": 3,
+    "vwap_bands": 3,
+}
 
 # Functions with multiple constructor args
 TA_MULTI_CTOR = {
@@ -156,6 +164,16 @@ TA_MULTI_CTOR = {
     "bbw": [1, 2],           # length, mult
     "kcw": [1, 2],           # length, mult
     "tr":  [0],              # handle_na (compile-time bool)
+    "stdev": [1, 2],         # length, biased
+    "variance": [1, 2],      # length, biased
+}
+
+# Compute-arg indices: which positional args are forwarded to ``.compute()``.
+# Entries here override the default analyzer behavior of forwarding every
+# non-constructor argument.
+TA_COMPUTE_ARGS = {
+    "stdev": [0],
+    "variance": [0],
 }
 
 # No-state functions (no constructor args, stateless or self-contained)

package/pineforge_codegen/analyzer/types.py

@@ -45,6 +45,12 @@ from ..ast_nodes import (
 )
 from ..symbols import PineType, TypeSpec
 
+# Drawing-objects-as-data type names (spec §4.1). Defined locally — the
+# analyzer must not import from ``codegen`` (codegen imports analyzer, so the
+# reverse would be a cycle). Mirrors codegen.tables.DRAWING_TYPE_TO_CPP keys.
+_DRAWING_TYPE_NAMES = frozenset({"line", "box", "label", "linefill", "chart.point"})
+_DRAWING_NS = frozenset({"line", "box", "label", "linefill"})
+
 
 class TypeHelper:
     """Pine type-hint / expression inference.
@@ -100,8 +106,28 @@ class TypeHelper:
                 return TypeSpec.map(key, val)
         if hint in self._udt_fields:
             return TypeSpec.udt(hint)
+        # Drawing-objects-as-data (P3): scalar ``line``/``box``/``label``/
+        # ``linefill``/``chart.point`` carry the handle identity via a udt
+        # TypeSpec. Without this the analyzer field-spec filter (base.py ~847)
+        # erases a scalar drawing field, collapsing it to double. Drawing names
+        # are NOT in _udt_fields.
+        if hint in _DRAWING_TYPE_NAMES:
+            return TypeSpec.udt(hint)
         return None
 
+    def _param_type_specs_from_def(self, func_def) -> list:
+        """Per-parameter ``TypeSpec`` (or ``None``) from a function's DECLARED
+        parameter type hints — the authoritative source for typed params
+        (``pivot hi``, ``string tf``, ``line[] arr``). Untyped params are
+        ``None`` here so regular-function call-site inference can fill them.
+        """
+        hints = (getattr(func_def, "annotations", None) or {}).get("param_type_hints", [])
+        specs: list = []
+        for i in range(len(func_def.params)):
+            hint = hints[i] if i < len(hints) else None
+            specs.append(self._type_spec_from_hint(hint) if hint else None)
+        return specs
+
     def _template_args_from_call(self, node: FuncCall) -> list[str]:
         callee = node.callee
         ann = getattr(callee, "annotations", None) or {}
@@ -116,6 +142,17 @@ class TypeHelper:
             func = cal.member if isinstance(cal, MemberAccess) else None
             ns = cal.object.name if isinstance(cal, MemberAccess) and isinstance(cal.object, Identifier) else None
             targs = self._template_args_from_call(value)
+            # Drawing-objects-as-data return typing: *.new / *.copy -> handle of
+            # the self-type; linefill.get_line* -> line; chart.point.* -> point.
+            if ns in _DRAWING_NS:
+                if func in ("new", "copy"):
+                    return TypeSpec.udt(ns)
+                if ns == "linefill" and func in ("get_line1", "get_line2"):
+                    return TypeSpec.udt("line")
+            if (isinstance(cal, MemberAccess) and isinstance(cal.object, MemberAccess)
+                    and isinstance(cal.object.object, Identifier)
+                    and cal.object.object.name == "chart" and cal.object.member == "point"):
+                return TypeSpec.udt("chart.point")
             if ns == "array" and func in ("new", "new_float", "new_int", "new_bool", "new_string", "from"):
                 if func == "new_float":
                     return TypeSpec.array(TypeSpec.primitive("float"))
@@ -194,10 +231,26 @@ class TypeHelper:
                         return recv_spec.element
                     if func == "eigenvalues":
                         return TypeSpec.array(TypeSpec.primitive("float"))
+                # Drawing method-form: a.copy() -> same handle; lf.get_line*() -> line.
+                if (recv_spec is not None and recv_spec.kind == "udt"
+                        and recv_spec.name in _DRAWING_TYPE_NAMES):
+                    if func == "copy":
+                        return recv_spec
+                    if recv_spec.name == "linefill" and func in ("get_line1", "get_line2"):
+                        return TypeSpec.udt("line")
         if isinstance(value, Identifier):
             sym = self._symbols.resolve(value.name)
             if sym is not None and sym.type_spec is not None:
                 return sym.type_spec
+        if isinstance(value, FuncCall):
+            # User-function return spec (e.g. an array-returning
+            # ``buildPDLevels() => array.from(...)``), so a caller's
+            # ``allLevels = buildPDLevels()`` infers an array TypeSpec.
+            cal = value.callee
+            fname = cal.member if isinstance(cal, MemberAccess) else (
+                cal.name if isinstance(cal, Identifier) else None)
+            if fname and fname in getattr(self, "_func_return_type_specs", {}):
+                return self._func_return_type_specs[fname]
         if isinstance(value, MemberAccess):
             owner = self._type_spec_from_expr(value.object)
             if owner is not None and owner.kind == "udt" and owner.name:

package/pineforge_codegen/codegen/__init__.py

@@ -41,6 +41,8 @@ from .tables import (
     SYMINFO_MEMBER_MAP,
     COLOR_CONST_MAP,
     ARRAY_METHODS,
+    ARRAY_DRAWING_NEW_CTORS,
+    ARRAY_NEW_CTORS,
     MAP_METHODS,
     MATRIX_METHODS,
     MATRIX_METHOD_KWARGS,
@@ -69,6 +71,8 @@ __all__ = [
     "SYMINFO_MEMBER_MAP",
     "COLOR_CONST_MAP",
     "ARRAY_METHODS",
+    "ARRAY_DRAWING_NEW_CTORS",
+    "ARRAY_NEW_CTORS",
     "MAP_METHODS",
     "MATRIX_METHODS",
     "MATRIX_METHOD_KWARGS",