@pineforge/codegen-pyodide 0.8.0 → 0.9.0

package/pineforge_codegen/support_checker.py

@@ -50,11 +50,15 @@ from .tv_input_choices import INPUT_SOURCE_SERIES_IDS
 from .analyzer import TA_CLASS_MAP
 from .codegen import (
     MATH_FUNC_MAP, STR_FUNC_MAP,
-    ARRAY_METHODS, MAP_METHODS, MATRIX_METHODS,
+    ARRAY_METHODS, ARRAY_DRAWING_NEW_CTORS, MAP_METHODS, MATRIX_METHODS,
     SYMINFO_MEMBER_MAP, COLOR_CONST_MAP,
     SKIP_FUNC_NAMES, SKIP_NAMESPACES,
     BAR_BUILTINS, BAR_FIELDS,
 )
+from .codegen.drawing import (
+    LINE_METHODS, LINE_NOOP, BOX_METHODS, BOX_NOOP,
+    LABEL_METHODS, LABEL_NOOP, LINEFILL_METHODS, LINEFILL_NOOP,
+)
 
 
 # ---------------------------------------------------------------------------
@@ -74,10 +78,38 @@ SUPPORTED_MATH: frozenset[str] = frozenset(
 )
 SUPPORTED_STR: frozenset[str] = frozenset(set(STR_FUNC_MAP) | {"format_time"})
 SUPPORTED_INPUT: frozenset[str] = frozenset(sigs.INPUT_FUNCTIONS)
-SUPPORTED_ARRAY: frozenset[str] = frozenset(set(ARRAY_METHODS) | {"new", "new_float", "new_int", "new_bool", "new_string", "from"})
+SUPPORTED_ARRAY: frozenset[str] = frozenset(set(ARRAY_METHODS) | {"new", "new_float", "new_int", "new_bool", "new_string", "from"} | set(ARRAY_DRAWING_NEW_CTORS))
 SUPPORTED_MAP: frozenset[str] = frozenset(set(MAP_METHODS) | {"new"})
 SUPPORTED_MATRIX: frozenset[str] = frozenset(set(MATRIX_METHODS) | {"new"})
 SUPPORTED_SYMINFO: frozenset[str] = frozenset(SYMINFO_MEMBER_MAP)
+# Drawing-objects-as-data (spec §4.5). Geometry methods are REAL (route to the
+# per-type arena); *_NOOP visual setters are accepted no-ops (Level.WARNING).
+# Any line/box/label/linefill method NOT in these sets rejects loudly so an
+# unknown drawing method is not silently emitted. ``table``/``polyline`` are
+# intentionally absent — they stay in SKIP_NAMESPACES (no-op, never reclassified).
+SUPPORTED_LINE: frozenset[str] = frozenset(LINE_METHODS | LINE_NOOP | {"new"})
+SUPPORTED_BOX: frozenset[str] = frozenset(BOX_METHODS | BOX_NOOP | {"new"})
+SUPPORTED_LABEL: frozenset[str] = frozenset(LABEL_METHODS | LABEL_NOOP | {"new"})
+SUPPORTED_LINEFILL: frozenset[str] = frozenset(LINEFILL_METHODS | LINEFILL_NOOP | {"new"})
+SUPPORTED_CHART_POINT: frozenset[str] = frozenset(
+    {"new", "now", "from_index", "from_time", "copy"}
+)
+# Visual no-op drawing setters (warn, don't reject) keyed by namespace.
+_DRAWING_NOOP_BY_NS: dict[str, frozenset[str]] = {
+    "line": LINE_NOOP, "box": BOX_NOOP, "label": LABEL_NOOP, "linefill": LINEFILL_NOOP,
+}
+_DRAWING_SUPPORTED_BY_NS: dict[str, frozenset[str]] = {
+    "line": SUPPORTED_LINE, "box": SUPPORTED_BOX,
+    "label": SUPPORTED_LABEL, "linefill": SUPPORTED_LINEFILL,
+}
+_DRAWING_TYPE_NAMES: frozenset[str] = frozenset({"line", "box", "label", "linefill"})
+# Scalar visual-container types whose *method* calls (``panel.cell(...)``,
+# ``ln.set_xy1(...)``) legitimately carry visual-constant args (``text.align_*``,
+# ``size.*``). A method on a receiver of one of these types — including a
+# table/box/line/label/linefill PARAMETER — is a visual sink, so its argument
+# subtree is visited with constant-namespace reads allowed (mirrors the
+# namespace-form ``table.cell``/``label.new`` handling).
+_VISUAL_CONTAINER_TYPES: frozenset[str] = _DRAWING_TYPE_NAMES | frozenset({"table"})
 SUPPORTED_COLOR_CONST: frozenset[str] = frozenset(COLOR_CONST_MAP)
 SUPPORTED_COLOR_FUNC: frozenset[str] = frozenset({"new", "rgb", "r", "g", "b", "t"})
 # Cosmetic color builders with no backtest-logic effect. Warned (not rejected);
@@ -100,11 +132,10 @@ HARD_REJECT_FUNC: dict[str, str] = {
     "request.seed":              "External seed data feeds not available in PineForge.",
     "request.quandl":            "External Quandl data not available in PineForge.",
     "request.currency_rate":     "Currency conversion data not available in PineForge.",
-    # ticker.* chart-type modifiers and cross-symbol constructors — hard reject
-    "ticker.heikinashi":         (
-        "ticker.heikinashi() chart-type modifier / cross-symbol construction not supported — "
-        "PineForge runs same-symbol MTF only via request.security with the chart's own tickerid."
-    ),
+    # ticker.* chart-type modifiers and cross-symbol constructors — hard reject.
+    # NOTE: ticker.heikinashi is handled contextually in _visit_FuncCall (allowed
+    # for the chart's own symbol — the engine applies the HA candle transform
+    # inside the same-symbol security eval — rejected for cross-symbol).
     "ticker.renko":              (
         "ticker.renko() chart-type modifier / cross-symbol construction not supported — "
         "PineForge runs same-symbol MTF only via request.security with the chart's own tickerid."
@@ -146,17 +177,23 @@ HARD_REJECT_NAMESPACE: dict[str, str] = {
 # DIVERGENT_VARS_ERROR is a SUBSET that is escalated to ERROR (rejected): these
 # are silent MIS-ALIASES, not merely data-window divergences. They return a
 # plausible value that is the WRONG quantity (last_bar_index -> current bar
-# index; time_close -> bar OPEN timestamp) and that value flows directly into
-# trade logic, so the backtest would be silently wrong. A WARNING is not enough.
+# index) and that value flows directly into trade logic, so the backtest would
+# be silently wrong. A WARNING is not enough.
+#
+# NOTE: the bare ``time_close`` variable is NOT divergent — codegen lowers it to
+# the engine's ``time_close()`` accessor, which returns the true bar-close
+# timestamp (bar open + chart-timeframe duration via ``pine_time_close``),
+# deterministic and TV-faithful. It was previously mis-listed here as a bar-open
+# alias; that was stale. (The session-aware ``time_close(...)`` FUNCTION is a
+# separate supported builtin handled in visit_call.)
 DIVERGENT_VARS: dict[str, str] = {
     "bar_index":      "bar_index depends on the data window; PineForge and TradingView produce different values for the same script.",
     "last_bar_index": "last_bar_index is aliased to the CURRENT bar index in PineForge codegen (not the index of the last bar); backtest would be silently wrong — rejected.",
     "timenow":        "timenow is aliased to the current bar timestamp in PineForge; it is not real wall-clock time.",
-    "time_close":     "time_close is aliased to the bar OPEN timestamp in PineForge; it does not represent the bar close time; backtest would be silently wrong — rejected.",
 }
 
 # Subset of DIVERGENT_VARS escalated from WARNING to ERROR (see comment above).
-DIVERGENT_VARS_ERROR: frozenset[str] = frozenset({"last_bar_index", "time_close"})
+DIVERGENT_VARS_ERROR: frozenset[str] = frozenset({"last_bar_index"})
 
 BARSTATE_APPROX_VARS: dict[str, str] = {
     "barstate.islast": "barstate.islast is always false in PineForge batch backtests.",
@@ -305,10 +342,14 @@ UNSUPPORTED_NAMESPACE_VARS: dict[str, str] = {
 # request.security parameter rules.
 # Codegen supports symbol/timeframe/expression plus gaps/lookahead (read in
 # _eval_security_* emission and forwarded to register_security_eval).
-# ignore_invalid_symbol/currency are accepted by the parser but silently
-# dropped by codegen — reject loudly to surface unsupported behavior.
+# `currency` is still rejected loudly (it changes the returned values via FX
+# conversion, which codegen drops — silently wrong). `ignore_invalid_symbol` is
+# a guaranteed no-op here: codegen forces request.security onto the current
+# chart symbol (see the "symbol must reference current chart symbol" check),
+# which is always valid, so the flag can never change the result — accept+ignore.
 SECURITY_ALLOWED_PARAMS: frozenset[str] = frozenset(
     {"symbol", "timeframe", "expression", "gaps", "lookahead",
+     "ignore_invalid_symbol",
      # Data-adjustment constants — silently accepted and ignored by codegen;
      # the underlying engine uses a fixed unadjusted data source.
      "backadjustment", "settlement_as_close", "adjustment"}
@@ -411,6 +452,28 @@ class SupportChecker:
         self._user_enums: set[str] = set()
         self._user_funcs: set[str] = set()
         self._user_methods: set[str] = set()
+        # Drawing lifecycle gap guard (spec L.3/U.7): only bare identifiers are
+        # promoted to Series<T> by analyzer/base.py::_visit_Subscript. A history
+        # read on a drawing handle nested in a UDT field (``p.a[1]``) or on a
+        # tuple element known to be a drawing handle (``la[1]`` after
+        # ``[la, lb] = makePair()``) would otherwise silently read the current
+        # bar. Track enough lightweight declaration information to reject those
+        # shapes before codegen.
+        self._udt_drawing_fields: dict[str, set[str]] = {}
+        self._var_udt_types: dict[str, str] = {}
+        # Names (vars and function params) declared as a scalar visual-container
+        # type (table/box/line/label/linefill). A method call on one of these
+        # (``panel.cell(...)``) is a visual sink whose args may carry visual
+        # constants, so it routes through ``_visit_children_const_ok``.
+        self._visual_container_vars: set[str] = set()
+        # User helpers whose body is only a visual sink (for example
+        # ``cell(table t, ..., align) => t.cell(..., text_halign=align)``).
+        # A call to such a helper is itself a visual context, so style
+        # constants passed through its arguments are safe and should not trip
+        # the free-expression constant-namespace rejection.
+        self._visual_sink_funcs: set[str] = set()
+        self._drawing_tuple_vars: set[str] = set()
+        self._func_tuple_drawing_returns: dict[str, list[bool]] = {}
         # Track whether we are inside an if/ternary condition expression.
         self._in_conditional_depth: int = 0
         # Track whether we are inside an argument subtree that legitimately
@@ -425,6 +488,12 @@ class SupportChecker:
         # bare ``time_close`` variable) must NOT be flagged as a divergent
         # variable read. Populated as _visit_FuncCall descends into children.
         self._callee_node_ids: set[int] = set()
+        # Declaration value of each scalar variable (``name = <expr>``), so the
+        # request.security symbol check can resolve an aliased symbol through
+        # its definition — e.g. ``haTicker = ticker.heikinashi(syminfo.tickerid)``
+        # then ``request.security(haTicker, ...)``, or ``reqSym = cond ? other :
+        # syminfo.tickerid``. First binding wins (closest to declaration).
+        self._scalar_defs: dict[str, ASTNode] = {}
 
     # -- Public API --
 
@@ -446,12 +515,106 @@ class SupportChecker:
         for stmt in ast.body:
             if isinstance(stmt, TypeDecl):
                 self._user_types.add(stmt.name)
+                drawing_fields = {
+                    field.name
+                    for field in stmt.fields
+                    if self._type_name_contains_drawing(field.type_name)
+                }
+                if drawing_fields:
+                    self._udt_drawing_fields[stmt.name] = drawing_fields
             elif isinstance(stmt, EnumDecl):
                 self._user_enums.add(stmt.name)
             elif isinstance(stmt, FuncDef):
                 self._user_funcs.add(stmt.name)
+                tuple_returns = self._single_expr_tuple_drawing_mask(stmt)
+                if tuple_returns:
+                    self._func_tuple_drawing_returns[stmt.name] = tuple_returns
+                self._collect_visual_container_params(stmt)
+                if self._func_body_is_visual_sink(stmt):
+                    self._visual_sink_funcs.add(stmt.name)
             elif isinstance(stmt, MethodDef):
                 self._user_methods.add(stmt.name)
+                self._collect_visual_container_params(stmt)
+
+    def _collect_visual_container_params(self, fn) -> None:
+        """Register a function's parameters that are declared with a scalar
+        visual-container type (``table panel``, ``line ln``) so method calls on
+        them inside the body (``panel.cell(...)``) are treated as visual sinks.
+        """
+        hints = (getattr(fn, "annotations", None) or {}).get("param_type_hints") or []
+        for i, pname in enumerate(getattr(fn, "params", []) or []):
+            hint = hints[i] if i < len(hints) else None
+            if hint and str(hint).replace(" ", "") in _VISUAL_CONTAINER_TYPES:
+                self._visual_container_vars.add(pname)
+
+    def _expr_is_visual_sink_call(self, expr: ASTNode | None) -> bool:
+        if not isinstance(expr, FuncCall):
+            return False
+        ns, name = _qualified_name(expr.callee)
+        if ns is None and name in SKIP_FUNC_NAMES:
+            return True
+        if ns is not None and ns in SKIP_NAMESPACES:
+            return True
+        if ns in _DRAWING_NOOP_BY_NS and name in _DRAWING_NOOP_BY_NS[ns]:
+            return True
+        return ns is not None and ns in self._visual_container_vars
+
+    def _func_body_is_visual_sink(self, fn: FuncDef | MethodDef) -> bool:
+        if not fn.body:
+            return False
+        for stmt in fn.body:
+            expr = stmt.expr if isinstance(stmt, ExprStmt) else None
+            if not self._expr_is_visual_sink_call(expr):
+                return False
+        return True
+
+    @staticmethod
+    def _type_name_contains_drawing(type_name: str | None) -> bool:
+        if not type_name:
+            return False
+        compact = str(type_name).replace(" ", "")
+        if compact.endswith("[]"):
+            compact = f"array<{compact[:-2]}>"
+        if compact in _DRAWING_TYPE_NAMES:
+            return True
+        return any(f"<{drawing}>" in compact for drawing in _DRAWING_TYPE_NAMES)
+
+    @staticmethod
+    def _is_literal_zero_subscript(node: Subscript) -> bool:
+        return isinstance(node.index, NumberLiteral) and node.index.value == 0
+
+    def _expr_is_drawing_handle(self, expr: ASTNode | None) -> bool:
+        if isinstance(expr, FuncCall):
+            ns, name = _qualified_name(expr.callee)
+            if ns in _DRAWING_TYPE_NAMES and name in {"new", "copy"}:
+                return True
+            if ns == "linefill" and name in {"get_line1", "get_line2"}:
+                return True
+        if isinstance(expr, Identifier):
+            return expr.name in self._drawing_tuple_vars
+        if isinstance(expr, Ternary):
+            return self._expr_is_drawing_handle(expr.true_val) or self._expr_is_drawing_handle(expr.false_val)
+        return False
+
+    def _single_expr_tuple_drawing_mask(self, fn: FuncDef) -> list[bool] | None:
+        if not fn.is_single_expr or len(fn.body) != 1:
+            return None
+        stmt = fn.body[0]
+        expr = stmt.expr if isinstance(stmt, ExprStmt) else None
+        if not isinstance(expr, TupleLiteral):
+            return None
+        mask = [self._expr_is_drawing_handle(item) for item in expr.elements]
+        return mask if any(mask) else None
+
+    def _tuple_assign_drawing_mask(self, value: ASTNode | None) -> list[bool] | None:
+        if isinstance(value, TupleLiteral):
+            mask = [self._expr_is_drawing_handle(item) for item in value.elements]
+            return mask if any(mask) else None
+        if isinstance(value, FuncCall):
+            ns, name = _qualified_name(value.callee)
+            if ns is None and name in self._func_tuple_drawing_returns:
+                return self._func_tuple_drawing_returns[name]
+        return None
 
     # -- Diagnostic emission --
 
@@ -639,6 +802,24 @@ class SupportChecker:
         self._visit_children_const_ok(node)
 
     def _visit_VarDecl(self, node: VarDecl) -> None:
+        if node.name and node.value is not None:
+            self._scalar_defs.setdefault(node.name, node.value)
+        if node.type_hint in self._user_types:
+            self._var_udt_types[node.name] = node.type_hint
+        elif isinstance(node.value, FuncCall):
+            ns, name = _qualified_name(node.value.callee)
+            if name == "new" and ns in self._user_types:
+                self._var_udt_types[node.name] = ns
+        # Track scalar visual-container vars (``var table dash = table.new(...)``)
+        # so a direct ``dash.cell(..., text.align_left)`` is treated as a visual
+        # sink (mirrors the table/box/line/label/linefill PARAM tracking).
+        decl_hint = str(node.type_hint).replace(" ", "") if node.type_hint else None
+        if decl_hint in _VISUAL_CONTAINER_TYPES:
+            self._visual_container_vars.add(node.name)
+        elif isinstance(node.value, FuncCall):
+            vns, vname = _qualified_name(node.value.callee)
+            if vname == "new" and vns in _VISUAL_CONTAINER_TYPES:
+                self._visual_container_vars.add(node.name)
         if node.is_varip:
             self._err(
                 node,
@@ -655,6 +836,11 @@ class SupportChecker:
         self._visit_children(node)
 
     def _visit_TupleAssign(self, node: TupleAssign) -> None:
+        drawing_mask = self._tuple_assign_drawing_mask(node.value)
+        if drawing_mask:
+            for idx, name in enumerate(node.names):
+                if idx < len(drawing_mask) and drawing_mask[idx]:
+                    self._drawing_tuple_vars.add(name)
         if isinstance(node.value, FuncCall):
             ns, name = _qualified_name(node.value.callee)
             if ns == "ta" and name == "stoch":
@@ -665,6 +851,40 @@ class SupportChecker:
                 )
         self._visit_children(node)
 
+    def _visit_Subscript(self, node: Subscript) -> None:
+        # Best-effort defensive guard for the silent-wrong shapes called out in
+        # spec L.3/U.7. This is not a full expression type checker; it catches
+        # the known dangerous surface (UDT vars with drawing fields, and tuple
+        # destructured drawing handles) without trying to prove every nested or
+        # parameter-passed UDT expression. Literal [0] is current-bar in Pine and
+        # safe to leave to codegen's existing current-value behavior.
+        if self._is_literal_zero_subscript(node):
+            self._visit_children(node)
+            return
+        if isinstance(node.object, MemberAccess) and isinstance(node.object.object, Identifier):
+            var_name = node.object.object.name
+            udt_name = self._var_udt_types.get(var_name)
+            if udt_name is not None and node.object.member in self._udt_drawing_fields.get(udt_name, set()):
+                self._err(
+                    node,
+                    "History references on UDT drawing fields are not supported in PineForge.",
+                    hint=(
+                        f"{var_name}.{node.object.member}[...] would be read as the current-bar field, "
+                        "not prior-bar history. Copy the field to a bare drawing variable first, "
+                        "or remove the history reference."
+                    ),
+                )
+        elif isinstance(node.object, Identifier) and node.object.name in self._drawing_tuple_vars:
+            self._err(
+                node,
+                "History references on tuple-destructured drawing handles are not supported in PineForge.",
+                hint=(
+                    f"{node.object.name}[...] is a drawing handle from tuple destructuring; "
+                    "PineForge cannot historize that tuple element safely."
+                ),
+            )
+        self._visit_children(node)
+
     def _visit_FuncCall(self, node: FuncCall) -> None:
         ns, name = _qualified_name(node.callee)
 
@@ -686,6 +906,25 @@ class SupportChecker:
             self._visit_children(node)
             return
 
+        # Heikin-Ashi: supported for the chart's OWN symbol only. The engine
+        # applies the HA candle transform inside the same-symbol security eval
+        # (request.security(ticker.heikinashi(syminfo.tickerid), ...)); a
+        # cross-symbol HA construction (an alternate symbol's candles) is not.
+        if full == "ticker.heikinashi":
+            arg0 = node.args[0] if node.args else node.kwargs.get("symbol")
+            if arg0 is None or not self._is_current_symbol_expr(arg0):
+                self._err(
+                    node,
+                    "ticker.heikinashi(...) is supported only for the chart's own symbol.",
+                    hint=(
+                        "Pass syminfo.tickerid: PineForge applies the Heikin-Ashi candle "
+                        "transform to the chart symbol inside request.security, but cannot "
+                        "load an alternate symbol's HA candles."
+                    ),
+                )
+            self._visit_children(node)
+            return
+
         # Hard rejects by namespace (e.g. ticker.*).
         if ns is not None and ns in HARD_REJECT_NAMESPACE:
             self._err(
@@ -942,6 +1181,34 @@ class SupportChecker:
             self._visit_children(node)
             return
 
+        # Drawing-objects-as-data (line/box/label/linefill). Geometry methods
+        # are REAL data; *_NOOP visual setters are accepted no-ops (warned);
+        # any OTHER drawing method rejects loudly. Args carry constant-namespace
+        # members (xloc.*, yloc.*, text.align_*, style consts), so children are
+        # visited with const reads allowed. NOTE: user methods on a drawing var
+        # (egoigor ``ln.slope()``) have ns="ln" (the receiver), NOT a DRAWING_NS,
+        # so they are never gated here.
+        if ns in _DRAWING_SUPPORTED_BY_NS:
+            if name not in _DRAWING_SUPPORTED_BY_NS[ns]:
+                self._err(node, f"{ns}.{name}(...) is not implemented in PineForge runtime.")
+                self._visit_children(node)
+                return
+            if name in _DRAWING_NOOP_BY_NS[ns]:
+                self._warn(
+                    node,
+                    f"{ns}.{name}(...) is a visual no-op in PineForge backtests "
+                    f"(drawing geometry is data; color/style/size are dropped).",
+                )
+            self._visit_children_const_ok(node)
+            return
+        if ns == "chart.point":
+            if name not in SUPPORTED_CHART_POINT:
+                self._err(node, f"chart.point.{name}(...) is not implemented in PineForge runtime.")
+                self._visit_children(node)
+                return
+            self._visit_children_const_ok(node)
+            return
+
         # Drawing / charting / alert namespaces — codegen drops silently. Warn,
         # don't error: many strategies include these for the TradingView UI.
         # Their argument subtrees legitimately carry constant-namespace
@@ -962,6 +1229,21 @@ class SupportChecker:
             self._visit_children_const_ok(node)
             return
 
+        # Method call on a scalar visual-container receiver (``panel.cell(...)``
+        # where ``panel`` is a ``table`` param, ``ln.set_xy1(...)`` on a ``line``
+        # var). ``ns`` is the receiver variable/param name, not a namespace, so
+        # the namespace-form drawing/table branches above did not fire. These are
+        # visual sinks whose args legitimately carry visual constants
+        # (``text.align_*``, ``size.*``), so visit children with const reads
+        # allowed instead of tripping the free-expression const-namespace reject.
+        if ns is not None and ns in self._visual_container_vars:
+            self._visit_children_const_ok(node)
+            return
+
+        if ns is None and name in self._visual_sink_funcs:
+            self._visit_children_const_ok(node)
+            return
+
         self._visit_children(node)
 
     def _visit_Identifier(self, node: Identifier) -> None:
@@ -1238,19 +1520,38 @@ class SupportChecker:
             return False
         return node.member in allowed
 
-    def _is_current_symbol_expr(self, node: ASTNode) -> bool:
+    def _is_current_symbol_expr(self, node: ASTNode, _seen: set[str] | None = None) -> bool:
+        if _seen is None:
+            _seen = set()
         chain = _resolve_member_chain(node)
         if chain in SECURITY_CURRENT_SYMBOL_NAMES:
             return True
-        # ticker.inherit(symbol, ...) and ticker.standard(symbol) are passthrough;
-        # if their first argument is a current-symbol expression, allow it.
+        # ticker.inherit(symbol, ...) / ticker.standard(symbol) are passthrough,
+        # and ticker.heikinashi(symbol) is the chart's OWN symbol with a causal
+        # Heikin-Ashi candle transform (the engine applies it inside the security
+        # eval via register_security_eval's heikinashi flag — no alternate symbol
+        # is loaded). All allow a current-symbol first argument; a non-current
+        # arg is genuine cross-symbol construction and still falls through.
         if isinstance(node, FuncCall):
             ns, fname = _qualified_name(node.callee)
-            if ns == "ticker" and fname in ("inherit", "standard"):
-                if node.args and self._is_current_symbol_expr(node.args[0]):
+            if ns == "ticker" and fname in ("inherit", "standard", "heikinashi"):
+                if node.args and self._is_current_symbol_expr(node.args[0], _seen):
                     return True
-                if "symbol" in node.kwargs and self._is_current_symbol_expr(node.kwargs["symbol"]):
+                if "symbol" in node.kwargs and self._is_current_symbol_expr(node.kwargs["symbol"], _seen):
                     return True
+        # A ternary symbol (``cond ? other : syminfo.tickerid``) resolves to the
+        # chart symbol whenever EITHER branch does. PineForge only ever loads the
+        # chart symbol, so this is exact at any config where the chosen branch is
+        # the chart symbol; an unconditional cross-symbol expression still errors.
+        if isinstance(node, Ternary):
+            return (self._is_current_symbol_expr(node.true_val, _seen)
+                    or self._is_current_symbol_expr(node.false_val, _seen))
+        # Def-use: resolve a bare identifier through its declaration value so an
+        # aliased symbol is accepted (``haTicker = ticker.heikinashi(...)`` then
+        # ``request.security(haTicker, ...)``). Name-cycle-guarded.
+        if isinstance(node, Identifier) and node.name in self._scalar_defs and node.name not in _seen:
+            _seen.add(node.name)
+            return self._is_current_symbol_expr(self._scalar_defs[node.name], _seen)
         return False
 
     # -- Pine timeframe-literal validation --

package/release.json

@@ -1,7 +1,7 @@
 {
-  "codegen": "0.8.0",
+  "codegen": "0.9.0",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "6b81a8d07ce4daa940178d204dadad410fc7952c83ab43e92abf5d8e869c2a31"
+  "sha256": "fc828c2a32ba93bbeeffa8e0a4c4696a417a6cc64448c1b70bdce2267cd051d9"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "0.8.0",
+  "CODEGEN_VERSION": "0.9.0",
   "TA_CLASS_MAP_KEYS": [
     "sma",
     "ema",
@@ -321,12 +321,8 @@
     "plotshape"
   ],
   "SKIP_NAMESPACES": [
-    "box",
     "chart",
     "display",
-    "label",
-    "line",
-    "linefill",
     "polyline",
     "position",
     "size",
@@ -581,11 +577,13 @@
     ],
     "ta.stdev": [
       "source",
-      "length"
+      "length",
+      "biased"
     ],
     "ta.variance": [
       "source",
-      "length"
+      "length",
+      "biased"
     ],
     "ta.supertrend": [
       "factor",
@@ -1438,7 +1436,6 @@
     "request.seed": "External seed data feeds not available in PineForge.",
     "request.quandl": "External Quandl data not available in PineForge.",
     "request.currency_rate": "Currency conversion data not available in PineForge.",
-    "ticker.heikinashi": "ticker.heikinashi() chart-type modifier / cross-symbol construction not supported — PineForge runs same-symbol MTF only via request.security with the chart's own tickerid.",
     "ticker.renko": "ticker.renko() chart-type modifier / cross-symbol construction not supported — PineForge runs same-symbol MTF only via request.security with the chart's own tickerid.",
     "ticker.kagi": "ticker.kagi() chart-type modifier / cross-symbol construction not supported — PineForge runs same-symbol MTF only via request.security with the chart's own tickerid.",
     "ticker.linebreak": "ticker.linebreak() chart-type modifier / cross-symbol construction not supported — PineForge runs same-symbol MTF only via request.security with the chart's own tickerid.",
@@ -1453,8 +1450,7 @@
   "DIVERGENT_VARS": {
     "bar_index": "bar_index depends on the data window; PineForge and TradingView produce different values for the same script.",
     "last_bar_index": "last_bar_index is aliased to the CURRENT bar index in PineForge codegen (not the index of the last bar); backtest would be silently wrong — rejected.",
-    "timenow": "timenow is aliased to the current bar timestamp in PineForge; it is not real wall-clock time.",
-    "time_close": "time_close is aliased to the bar OPEN timestamp in PineForge; it does not represent the bar close time; backtest would be silently wrong — rejected."
+    "timenow": "timenow is aliased to the current bar timestamp in PineForge; it is not real wall-clock time."
   },
   "BARSTATE_APPROX_VARS": {
     "barstate.islast": "barstate.islast is always false in PineForge batch backtests.",
@@ -1580,6 +1576,7 @@
     "backadjustment",
     "expression",
     "gaps",
+    "ignore_invalid_symbol",
     "lookahead",
     "settlement_as_close",
     "symbol",