@pineforge/codegen-pyodide 0.8.1 → 0.10.0

package/pineforge_codegen/analyzer/call_handlers.py

@@ -67,7 +67,7 @@ from typing import Any
 
 from ..ast_nodes import (
     ASTNode, BinOp, BoolLiteral, ExprStmt, FuncCall, Identifier, MemberAccess,
-    NumberLiteral, StringLiteral, TupleLiteral, UnaryOp, VarDecl,
+    NumberLiteral, StringLiteral, Ternary, TupleLiteral, UnaryOp, VarDecl,
 )
 from ..symbols import PineType
 from .. import signatures as sigs
@@ -75,7 +75,7 @@ from .. import tv_input_choices as tv_in
 from .contracts import FixnanCallSite, FuncInfo, SecurityCallInfo, TACallSite
 from .tables import (
     BAR_FIELDS, TA_CLASS_MAP, TA_MULTI_CTOR, TA_NO_CTOR, TA_PERIOD_ARG,
-    TA_TUPLE_RETURNS,
+    TA_TUPLE_RETURNS, TA_TUPLE_ELEMENT_COUNTS, TA_COMPUTE_ARGS,
 )
 
 
@@ -205,6 +205,7 @@ class CallHandlers:
                 returns_tuple=returns_tuple,
                 node=node,
                 is_static=is_static,
+                owner_func=(self._enclosing_func_names[-1] if self._enclosing_func_names else None),
             )
             self._ta_call_sites.append(site)
             self._ta_member_names.add(site.member_name)
@@ -235,9 +236,14 @@ class CallHandlers:
         elif func_name in TA_PERIOD_ARG:
             ctor_indices = {TA_PERIOD_ARG[func_name]}
 
-        for i, arg in enumerate(all_args):
-            if i not in ctor_indices and arg is not None:
-                compute_args.append(arg)
+        if func_name in TA_COMPUTE_ARGS:
+            for i in TA_COMPUTE_ARGS[func_name]:
+                if i < len(all_args) and all_args[i] is not None:
+                    compute_args.append(all_args[i])
+        else:
+            for i, arg in enumerate(all_args):
+                if i not in ctor_indices and arg is not None:
+                    compute_args.append(arg)
 
         is_static = self._global_scope and all(self._is_static_expression(arg) for arg in compute_args)
         site = TACallSite(
@@ -248,6 +254,7 @@ class CallHandlers:
             returns_tuple=returns_tuple,
             node=node,
             is_static=is_static,
+            owner_func=(self._enclosing_func_names[-1] if self._enclosing_func_names else None),
         )
         self._ta_call_sites.append(site)
         self._ta_member_names.add(site.member_name)
@@ -309,6 +316,27 @@ class CallHandlers:
 
             returns_tuple = isinstance(expr_node, TupleLiteral)
             tuple_size = len(expr_node.elements) if returns_tuple else 0
+            if not returns_tuple and isinstance(expr_node, FuncCall):
+                expr_func = None
+                expr_ns = None
+                if (isinstance(expr_node.callee, MemberAccess)
+                        and isinstance(expr_node.callee.object, Identifier)):
+                    expr_ns = expr_node.callee.object.name
+                    expr_func = expr_node.callee.member
+                if expr_ns == "ta":
+                    if expr_func == "vwap":
+                        merged_v = list(expr_node.args)
+                        for i, pname in enumerate(["source", "anchor", "stdev_mult"]):
+                            if pname in expr_node.kwargs:
+                                while len(merged_v) <= i:
+                                    merged_v.append(None)
+                                if merged_v[i] is None:
+                                    merged_v[i] = expr_node.kwargs[pname]
+                        if len(merged_v) >= 3:
+                            expr_func = "vwap_bands"
+                    if expr_func in TA_TUPLE_RETURNS:
+                        returns_tuple = True
+                        tuple_size = TA_TUPLE_ELEMENT_COUNTS.get(expr_func, 0)
 
             gaps_node = all_args[3] if len(all_args) > 3 else None
             lookahead_node = all_args[4] if len(all_args) > 4 else None
@@ -785,11 +813,18 @@ class CallHandlers:
             arg_type = self._visit(arg)
 
         self._fixnan_counter += 1
+        owner = self._enclosing_func_names[-1] if self._enclosing_func_names else None
         site = FixnanCallSite(
             member_name=f"_prev_fixnan_{self._fixnan_counter}",
             pine_type=arg_type,
+            node=node,
+            owner_func=owner,
         )
+        idx = len(self._fixnan_sites)
         self._fixnan_sites.append(site)
+        self._fixnan_member_names.add(site.member_name)
+        if owner is not None:
+            self._func_fixnan_indices.setdefault(owner, []).append(idx)
 
         return arg_type
 
@@ -817,13 +852,30 @@ class CallHandlers:
                 return _is_arith(n.left) and _is_arith(n.right)
             if isinstance(n, UnaryOp):
                 return _is_arith(n.operand)
+            if isinstance(n, Ternary):
+                # ``cond ? a : b`` — expand when both branches are arith.
+                # The condition may be a comparison/logical over arith leaves;
+                # rely on the codegen stability gate to reject series deps.
+                return (_is_arith(n.true_val) and _is_arith(n.false_val)
+                        and _is_arith(n.condition))
+            if isinstance(n, MemberAccess):
+                # ``timeframe.*`` / ``syminfo.*`` / ``math.pi`` etc. — stable
+                # per-run scalars that may appear inside a function-local
+                # derived length. Let the codegen stability classifier decide.
+                return True
             if isinstance(n, FuncCall):
-                # Allow math.* helpers (math.round/sqrt/...) over arith args.
                 callee = n.callee
+                # Allow math.* helpers (math.round/sqrt/cos/...) over arith args.
                 if (isinstance(callee, MemberAccess)
                         and isinstance(callee.object, Identifier)
                         and callee.object.name == "math"):
                     return all(_is_arith(a) for a in n.args)
+                # Pine type-cast builtins ``int(x)`` / ``float(x)`` / ``bool(x)``
+                # / ``string(x)`` — transparent over arith args. Common in
+                # derived TA lengths (``int(math.round(2 / a))``).
+                if (isinstance(callee, Identifier)
+                        and callee.name in ("int", "float", "bool", "string")):
+                    return all(_is_arith(a) for a in n.args)
             return False
 
         reassigned: set[str] = set()
@@ -848,6 +900,170 @@ class CallHandlers:
                 defs[stmt.name] = self._expr_to_str(stmt.value)
         return defs
 
+    def _materialize_user_func_call_site_state(
+            self, func_name: str, cs_idx: int, node: FuncCall,
+            *, reuse_existing_owner: str | None = None) -> None:
+        """Materialize TA/fixnan state for one UDF call-site variant.
+
+        Ordinary call sites are handled while walking the AST.  A second class
+        is discovered only after that walk: a stateful helper reached through a
+        multi-call-site parent needs the parent's additional call-path indices
+        even though the helper has only one textual call.  The late propagation
+        pass in ``Analyzer._propagate_call_site_counts`` calls this same helper
+        for those inherited variants so the exported count never references a
+        TA/fixnan clone that was not actually declared.
+
+        ``reuse_existing_owner`` is used only by late propagation.  A
+        range-widened parent may already have materialized the default
+        ``{member}_cs{idx}`` clone for the borrowed callee site; when that clone
+        belongs to the parent currently being propagated, it is the desired
+        call-path state and must be reused rather than duplicated under a
+        disambiguated-but-unused name.
+        """
+        func_def = self._func_defs[func_name]
+
+        param_arg_map: dict[str, str] = {}
+        for p_idx, param_name in enumerate(func_def.params):
+            if p_idx < len(node.args):
+                param_arg_map[param_name] = self._expr_to_str(node.args[p_idx])
+
+        if func_name in self._func_ta_ranges:
+            start, end = self._func_ta_ranges[func_name]
+
+            # Map local derived length variables back to expressions over the
+            # function's parameters before substituting call-site arguments.
+            local_defs = self._func_local_length_defs(func_def)
+
+            def _subst_params(arg: str, pmap: dict[str, str]) -> str:
+                import re
+                result = arg
+                for param, value in sorted(
+                        pmap.items(), key=lambda item: len(item[0]), reverse=True):
+                    result = re.sub(rf'\b{re.escape(param)}\b', value, result)
+                return result
+
+            def _expand_locals(arg: str) -> str:
+                import re
+                if not local_defs:
+                    return arg
+                for _ in range(32):
+                    def _rep(match: re.Match) -> str:
+                        name = match.group(0)
+                        if name in local_defs:
+                            return "(" + local_defs[name] + ")"
+                        return name
+                    expanded = re.sub(r"[A-Za-z_][A-Za-z_0-9]*", _rep, arg)
+                    if expanded == arg:
+                        break
+                    arg = expanded
+                return arg
+
+            import re as _re
+            enclosing_params: set[str] = set()
+            for names in self._enclosing_func_params:
+                enclosing_params |= names
+
+            if cs_idx == 0:
+                # cs0 owns the source-level sites. Preserve their parameterized
+                # ctor args for every later direct or inherited clone.
+                for i in range(start, end):
+                    site = self._ta_call_sites[i]
+                    if not hasattr(site, '_orig_ctor_args'):
+                        site._orig_ctor_args = [
+                            _expand_locals(arg) for arg in site.ctor_args
+                        ]
+                    site.ctor_args = [
+                        _subst_params(arg, param_arg_map)
+                        for arg in site._orig_ctor_args
+                    ]
+                    # If a ctor is now expressed in an enclosing UDF's params,
+                    # retain that expression so the enclosing call can resolve
+                    # it and widen the enclosing TA range as before.
+                    if enclosing_params and self._nested_ta_touched is not None:
+                        for arg in site.ctor_args:
+                            tokens = set(_re.findall(
+                                r"[A-Za-z_][A-Za-z_0-9]*", arg))
+                            if tokens & enclosing_params:
+                                site._orig_ctor_args = list(site.ctor_args)
+                                self._nested_ta_touched.add(i)
+                                break
+            else:
+                clone_name_map: dict[str, str] = {}
+                for i in range(start, end):
+                    orig = self._ta_call_sites[i]
+                    orig_args = getattr(orig, '_orig_ctor_args', orig.ctor_args)
+                    resolved_ctor = [
+                        _subst_params(arg, param_arg_map) for arg in orig_args
+                    ]
+                    clone_name = f"{orig.member_name}_cs{cs_idx}"
+                    existing = next(
+                        (site for site in self._ta_call_sites
+                         if site.member_name == clone_name),
+                        None,
+                    )
+                    if (reuse_existing_owner is not None
+                            and existing is not None
+                            and existing.owner_func == reuse_existing_owner):
+                        # The active parent's widened range already made the
+                        # exact member this inherited callee variant needs.
+                        continue
+                    if clone_name in self._ta_member_names:
+                        base = clone_name
+                        suffix = 2
+                        while clone_name in self._ta_member_names:
+                            clone_name = f"{base}_u{suffix}"
+                            suffix += 1
+                        clone_name_map[orig.member_name] = clone_name
+                    cloned = TACallSite(
+                        member_name=clone_name,
+                        class_name=orig.class_name,
+                        ctor_args=resolved_ctor,
+                        compute_args=orig.compute_args[:],
+                        returns_tuple=orig.returns_tuple,
+                        node=orig.node,
+                        is_static=orig.is_static,
+                        owner_func=func_name,
+                    )
+                    self._ta_call_sites.append(cloned)
+                    self._ta_member_names.add(clone_name)
+                if clone_name_map:
+                    self._func_cs_ta_clone_names[(func_name, cs_idx)] = clone_name_map
+
+        # fixnan is stateful for the same reason as a rolling TA reducer: each
+        # emitted function variant needs its own previous-value member.
+        fn_indices = self._func_fixnan_indices.get(func_name, [])
+        if cs_idx > 0 and fn_indices:
+            clone_map: dict[str, str] = {}
+            for fi in fn_indices:
+                orig = self._fixnan_sites[fi]
+                clone_name = f"{orig.member_name}_cs{cs_idx}"
+                existing = next(
+                    (site for site in self._fixnan_sites
+                     if site.member_name == clone_name),
+                    None,
+                )
+                if (reuse_existing_owner is not None
+                        and existing is not None
+                        and existing.owner_func == reuse_existing_owner):
+                    continue
+                if clone_name in self._fixnan_member_names:
+                    base = clone_name
+                    suffix = 2
+                    while clone_name in self._fixnan_member_names:
+                        clone_name = f"{base}_u{suffix}"
+                        suffix += 1
+                    clone_map[orig.member_name] = clone_name
+                cloned = FixnanCallSite(
+                    member_name=clone_name,
+                    pine_type=orig.pine_type,
+                    node=orig.node,
+                    owner_func=func_name,
+                )
+                self._fixnan_sites.append(cloned)
+                self._fixnan_member_names.add(clone_name)
+            if clone_map:
+                self._func_cs_fixnan_clone_names[(func_name, cs_idx)] = clone_map
+
     def _handle_user_func_call(self, func_name: str, node: FuncCall) -> PineType:
         """Handle calls to user-defined functions."""
         func_def = self._func_defs[func_name]
@@ -899,137 +1115,29 @@ class CallHandlers:
                     arg = node.args[p_idx]
                     if isinstance(arg, Identifier) and arg.name in BAR_FIELDS:
                         self._series_bar_fields.add(arg.name)
-
-        # Per-call-site cloning: if this function has TA calls or series vars,
-        # track call sites so codegen can create per-call-site variants.
-        # This prevents shared state corruption when the function is called
-        # multiple times per bar.
+                    elif isinstance(arg, Identifier):
+                        sym = self._symbols.resolve(arg.name)
+                        spec = getattr(sym, "type_spec", None) if sym is not None else None
+                        if spec is not None and spec.kind in ("array", "map", "matrix"):
+                            continue
+                        if sym is not None:
+                            sym.is_series = True
+                            if sym.scope and sym.scope.startswith("func_"):
+                                caller_name = sym.scope[5:]
+                                self._func_series_vars.setdefault(caller_name, set()).add(arg.name)
+                            else:
+                                self._series_vars.add(arg.name)
+
+        # Per-call-site cloning: TA, series/var, and fixnan state all advance
+        # across bars/calls and therefore require isolated UDF variants.
         has_ta = func_name in self._func_ta_ranges
         has_series = func_name in self._func_series_vars or func_name in self._func_var_members
-        if has_ta or has_series:
+        has_fixnan = func_name in self._func_fixnan_indices
+        if has_ta or has_series or has_fixnan:
             cs_idx = self._func_call_site_count.get(func_name, 0)
             self._func_call_site_count[func_name] = cs_idx + 1
             self._func_call_cs_map[id(node)] = (func_name, cs_idx)
-
-            # Build parameter -> call-site argument string mapping
-            param_arg_map: dict[str, str] = {}
-            for p_idx, param_name in enumerate(func_def.params):
-                if p_idx < len(node.args):
-                    param_arg_map[param_name] = self._expr_to_str(node.args[p_idx])
-
-            # Clone TA call sites (only if function has TA ranges)
-            if has_ta:
-                start, end = self._func_ta_ranges[func_name]
-
-                # Map of this function's local (non-param, non-series) derived
-                # length vars to their raw RHS expression strings, e.g.
-                # ``qqeCalc`` => ``wp = sf * 2 - 1`` -> {"wp": "sf * 2 - 1"}.
-                # A TA ctor arg captured as the bare local name ("wp") must be
-                # expanded to its definition so the subsequent param-substitution
-                # turns it into a class-scope expression ("rsiSmooth * 2 - 1")
-                # rather than leaving a dangling local that degenerates to
-                # period 1 in codegen.
-                local_defs = self._func_local_length_defs(func_def)
-
-                def _subst_params(arg: str, pmap: dict[str, str]) -> str:
-                    """Substitute parameter names in an expression string.
-
-                    Handles both exact matches ('len' -> 'len3') and parameter
-                    names within expressions ('len / 2' -> 'len3 / 2').
-                    """
-                    import re
-                    result = arg
-                    # Sort by length descending to avoid partial replacements
-                    for param, value in sorted(pmap.items(), key=lambda x: len(x[0]), reverse=True):
-                        result = re.sub(rf'\b{re.escape(param)}\b', value, result)
-                    return result
-
-                def _expand_locals(arg: str) -> str:
-                    """Recursively expand function-local length vars to their RHS
-                    (parenthesized) so only params / class-scope names remain."""
-                    import re
-                    if not local_defs:
-                        return arg
-                    for _ in range(32):
-                        def _rep(m: re.Match) -> str:
-                            nm = m.group(0)
-                            if nm in local_defs:
-                                return "(" + local_defs[nm] + ")"
-                            return nm
-                        new = re.sub(r"[A-Za-z_][A-Za-z_0-9]*", _rep, arg)
-                        if new == arg:
-                            break
-                        arg = new
-                    return arg
-
-                # Params of the function we are *currently inside* (if this is a
-                # nested user-func call). Used to detect when a substituted ctor
-                # arg becomes parameterized by the OUTER function, so the outer
-                # call site can resolve it (f_bbwp's _bbwLen -> i_bbwLen reaches
-                # f_basisMa's sites).
-                import re as _re
-                enclosing_params: set[str] = set()
-                for s in self._enclosing_func_params:
-                    enclosing_params |= s
-
-                if cs_idx == 0:
-                    # First call site: save original param-based ctor_args for future cloning,
-                    # then resolve to actual call-site values
-                    for i in range(start, end):
-                        site = self._ta_call_sites[i]
-                        if not hasattr(site, '_orig_ctor_args'):
-                            site._orig_ctor_args = [
-                                _expand_locals(a) for a in site.ctor_args
-                            ]
-                        site.ctor_args = [_subst_params(a, param_arg_map) for a in site._orig_ctor_args]
-                        # If a substituted arg is now expressed in terms of an
-                        # enclosing function's params, promote it to the original
-                        # so the enclosing call re-substitutes, and mark the site
-                        # so the enclosing function's TA range widens to cover it.
-                        if enclosing_params and self._nested_ta_touched is not None:
-                            for a in site.ctor_args:
-                                toks = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", a))
-                                if toks & enclosing_params:
-                                    site._orig_ctor_args = list(site.ctor_args)
-                                    self._nested_ta_touched.add(i)
-                                    break
-                else:
-                    # Subsequent call sites: clone using saved original param names,
-                    # substituted with this call site's arguments
-                    clone_name_map: dict[str, str] = {}
-                    for i in range(start, end):
-                        orig = self._ta_call_sites[i]
-                        orig_args = getattr(orig, '_orig_ctor_args', orig.ctor_args)
-                        resolved_ctor = [_subst_params(a, param_arg_map) for a in orig_args]
-                        # Default name follows the ``{base}_cs{cs_idx}`` formula the
-                        # codegen re-derives. But the SAME base TA site can be reached
-                        # through more than one enclosing function (e.g. a helper cloned
-                        # both via its own call sites AND via a range-widened outer
-                        # function), so two distinct (func, cs_idx) namespaces can mint
-                        # the same name. Detect that collision and fall back to a
-                        # globally-unique name; record the chosen name so the codegen
-                        # consumes it verbatim (see _func_cs_ta_clone_names).
-                        clone_name = f"{orig.member_name}_cs{cs_idx}"
-                        if clone_name in self._ta_member_names:
-                            base = clone_name
-                            n = 2
-                            while clone_name in self._ta_member_names:
-                                clone_name = f"{base}_u{n}"
-                                n += 1
-                            clone_name_map[orig.member_name] = clone_name
-                        cloned = TACallSite(
-                            member_name=clone_name,
-                            class_name=orig.class_name,
-                            ctor_args=resolved_ctor,
-                            compute_args=orig.compute_args[:],
-                            returns_tuple=orig.returns_tuple,
-                            node=orig.node,
-                            is_static=orig.is_static,
-                        )
-                        self._ta_call_sites.append(cloned)
-                        self._ta_member_names.add(clone_name)
-                    if clone_name_map:
-                        self._func_cs_ta_clone_names[(func_name, cs_idx)] = clone_name_map
+            self._materialize_user_func_call_site_state(func_name, cs_idx, node)
 
         # Create or update FuncInfo
         is_tuple = self._func_returns_tuple.get(func_name, False)
@@ -1041,7 +1149,10 @@ class CallHandlers:
         # Per-param TypeSpec: declared hints are authoritative; for untyped
         # params, infer from the call-site argument's type_spec (so an untyped
         # ``s`` used as a string, or a UDT passed by value, emits correctly).
-        param_specs = self._param_type_specs_from_def(func_def)
+        param_specs = list(
+            getattr(self, "_func_param_type_specs", {}).get(func_name)
+            or self._param_type_specs_from_def(func_def)
+        )
         arg_specs = [self._type_spec_from_expr(arg) for arg in node.args]
         for i in range(len(param_specs)):
             if param_specs[i] is None and i < len(arg_specs):

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
@@ -87,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
@@ -164,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>"

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)