@pineforge/codegen-pyodide 0.7.6 → 0.8.1

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,12 +78,44 @@ 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);
+# codegen emits a benign default color (0 = na color). color.from_gradient is a
+# charting/plot helper that only tints visual output.
+COSMETIC_COLOR_FUNC: frozenset[str] = frozenset({"from_gradient"})
 SUPPORTED_TIMEFRAME_FUNC: frozenset[str] = frozenset({"change", "in_seconds"})
 SUPPORTED_RUNTIME_FUNC: frozenset[str] = frozenset({"error"})
 # log.* helpers wired into pine_log_{info,warning,error} by codegen/visit_call.
@@ -96,12 +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.",
-    "color.from_gradient":       "Charting helpers not available in PineForge backtests.",
-    # 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."
@@ -143,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.",
@@ -215,10 +255,17 @@ NOT_YET_FUNC: dict[str, str] = {
 }
 
 # Bare (no-namespace) function names that codegen has no handler for.
-# Without a handler, the generic emitter at visit_call.py:912 would
-# produce e.g. `color(arg)` — an undeclared C++ symbol. Reject loudly.
-UNSUPPORTED_BARE_FUNCS: dict[str, str] = {
-    "color": "Bare color(...) cast is not supported. Use color.new(c, alpha) or color.rgb(r, g, b, transp).",
+# Without a handler, the generic emitter at visit_call.py:912 would produce an
+# undeclared C++ symbol. Reject loudly. (Currently empty — the bare color(...)
+# cast moved to COSMETIC_BARE_FUNCS below.)
+UNSUPPORTED_BARE_FUNCS: dict[str, str] = {}
+
+# Bare (no-namespace) cosmetic casts with no backtest-logic effect. Warned
+# (not rejected); codegen emits a benign default. ``color(x)`` is a Pine color
+# cast — colors never affect trade logic, so codegen emits a default color
+# (0 = na color) and the strategy keeps running.
+COSMETIC_BARE_FUNCS: dict[str, str] = {
+    "color": "color(...) cast has no effect in PineForge backtests (visual only); it emits a default color.",
 }
 
 # Whole namespaces with NO codegen support. Any call into one of these
@@ -230,14 +277,19 @@ UNSUPPORTED_NAMESPACES: dict[str, str] = {
     "volume_row": "volume_row.* is not supported in PineForge batch backtests; same reason as footprint.*.",
 }
 
-# Member-access references with no batch-mode equivalent. Codegen would
-# silently emit "false" (visit_expr.py chart.* fallthrough) which
-# becomes epoch 0 in time arithmetic. Reject loudly.
-UNSUPPORTED_MEMBERS: dict[tuple[str, str], str] = {
-    ("chart", "left_visible_bar_time"):  "chart.left_visible_bar_time has no meaning in a batch backtest (no viewport).",
-    ("chart", "right_visible_bar_time"): "chart.right_visible_bar_time has no meaning in a batch backtest (no viewport).",
-    ("chart", "bg_color"): "chart.bg_color has no meaning in a batch backtest (no chart theme).",
-    ("chart", "fg_color"): "chart.fg_color has no meaning in a batch backtest (no chart theme).",
+# Member-access references with no batch-mode equivalent. Reject loudly.
+# (Currently empty — the chart.* cosmetic reads moved to COSMETIC_MEMBERS.)
+UNSUPPORTED_MEMBERS: dict[tuple[str, str], str] = {}
+
+# Cosmetic / chart-only member reads with no backtest-logic effect. Warned
+# (not rejected); codegen emits the benign default — chart.* falls through
+# SKIP_NAMESPACES in visit_expr.py to ``0`` (and the analyzer types chart.* as
+# COLOR, so the 0 lands in an int color slot and compiles cleanly).
+COSMETIC_MEMBERS: dict[tuple[str, str], str] = {
+    ("chart", "left_visible_bar_time"):  "chart.left_visible_bar_time has no meaning in a batch backtest (no viewport); emits 0.",
+    ("chart", "right_visible_bar_time"): "chart.right_visible_bar_time has no meaning in a batch backtest (no viewport); emits 0.",
+    ("chart", "bg_color"): "chart.bg_color has no meaning in a batch backtest (no chart theme); emits a default color.",
+    ("chart", "fg_color"): "chart.fg_color has no meaning in a batch backtest (no chart theme); emits a default color.",
 }
 
 # Constant-only namespaces whose members are drawing/visual style constants
@@ -396,6 +448,22 @@ 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()
+        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
@@ -410,6 +478,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 --
 
@@ -431,12 +505,83 @@ 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)
             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)
+
+    @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 --
 
@@ -624,6 +769,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,
@@ -640,6 +803,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":
@@ -650,6 +818,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)
 
@@ -671,6 +873,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(
@@ -692,9 +913,15 @@ class SupportChecker:
             self._visit_children(node)
             return
 
-        # Bare-function rejections (e.g. `color(arg)` cast). Codegen would
-        # otherwise fall through to the generic emit at visit_call.py:912 and
-        # produce an undeclared C++ symbol.
+        # Bare cosmetic casts (e.g. `color(na)` -> default color). No backtest
+        # effect; warn and let codegen emit a benign default color.
+        if ns is None and name in COSMETIC_BARE_FUNCS:
+            self._warn(node, COSMETIC_BARE_FUNCS[name])
+            self._visit_children(node)
+            return
+
+        # Bare-function rejections. Codegen would otherwise fall through to the
+        # generic emit at visit_call.py:912 and produce an undeclared C++ symbol.
         if ns is None and self._reject_if_in(
             UNSUPPORTED_BARE_FUNCS,
             name,
@@ -865,6 +1092,16 @@ class SupportChecker:
             self._err(node, f"timeframe.{name}(...) is not implemented in PineForge runtime.")
             self._visit_children(node)
             return
+        if ns == "color" and name in COSMETIC_COLOR_FUNC:
+            # Cosmetic color builder (e.g. color.from_gradient): no backtest
+            # effect. Warn and let codegen emit a default color (0).
+            self._warn(
+                node,
+                f"color.{name}(...) has no effect in PineForge backtests "
+                f"(visual only); it emits a default color.",
+            )
+            self._visit_children(node)
+            return
         if ns == "color" and name not in SUPPORTED_COLOR_FUNC:
             self._err(node, f"color.{name}(...) is not implemented in PineForge runtime.")
             self._visit_children(node)
@@ -911,6 +1148,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
@@ -931,6 +1196,17 @@ 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
+
         self._visit_children(node)
 
     def _visit_Identifier(self, node: Identifier) -> None:
@@ -1001,7 +1277,21 @@ class SupportChecker:
             lambda k, v: f"{k}.{node.member}: {v}",
         ):
             return
-        # Specific unsupported (namespace, member) pairs (e.g. chart.left_visible_bar_time).
+        # Cosmetic / chart-only member reads (chart.fg_color/bg_color/visible
+        # bar times). No backtest-logic effect; warn and let codegen emit the
+        # benign default (chart.* -> 0 via SKIP_NAMESPACES in visit_expr.py).
+        if (
+            isinstance(node.object, Identifier)
+            and (node.object.name, node.member) in COSMETIC_MEMBERS
+        ):
+            self._warn(
+                node,
+                f"{node.object.name}.{node.member}: "
+                f"{COSMETIC_MEMBERS[(node.object.name, node.member)]}",
+            )
+            self._visit_children(node)
+            return
+        # Specific unsupported (namespace, member) pairs.
         if isinstance(node.object, Identifier) and self._reject_if_in(
             UNSUPPORTED_MEMBERS,
             (node.object.name, node.member),
@@ -1134,10 +1424,25 @@ class SupportChecker:
                 hint="Codegen only recognizes the barmerge.lookahead_* literal; other values are silently treated as lookahead_off.",
             )
         if self._is_barmerge_member(lookahead_node, "lookahead_on"):
-            self._err(
+            # lookahead_on is supported by codegen + engine: base.py forwards
+            # the flag into _security_eval_info, emit_top.py registers it via
+            # register_security_eval(..., lookahead_on=true), and the engine
+            # (engine_security.cpp) dispatches the partial HTF eval and gates
+            # the per-bucket series slot on it. The completed-HTF value becomes
+            # visible from the HTF bucket's first chart bar (TV's forward-look).
+            # We emit a WARNING (not ERROR) because lookahead_on is inherently
+            # data-sensitive: with a 0-offset HTF expression it exposes the
+            # in-progress bucket's value (TV's documented repaint), whereas the
+            # safe non-repainting idiom pairs it with a [1] offset
+            # (e.g. close[1]) to read only completed prior buckets.
+            self._warn(
                 lookahead_node,
-                "request.security lookahead_on is not supported in PineForge paid parity mode.",
-                hint="Use barmerge.lookahead_off. lookahead_on can expose future/partial HTF values and is highly data-sensitive.",
+                "request.security lookahead_on changes HTF timing: the completed "
+                "higher-timeframe value is exposed from the bucket's first chart "
+                "bar. PineForge emits this (engine-supported) but results differ "
+                "from lookahead_off and, with a 0-offset HTF expression, repaint "
+                "future data.",
+                hint="The safe non-repainting form pairs lookahead_on with a [1] offset (e.g. close[1]) to read only completed prior HTF bars.",
             )
 
         # Data-adjustment kwargs: codegen emits a numeric constant but the
@@ -1178,19 +1483,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.7.6",
+  "codegen": "0.8.1",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "5f4c3778294be55b3b234f63d0c9f8e24b3d7a2b20ff83efa5034a5c5369e492"
+  "sha256": "85ac44383967dd8c9825a276661eab568b16ecb89fcb929a3b9b638b6a4f371c"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "0.7.6",
+  "CODEGEN_VERSION": "0.8.1",
   "TA_CLASS_MAP_KEYS": [
     "sma",
     "ema",
@@ -321,12 +321,8 @@
     "plotshape"
   ],
   "SKIP_NAMESPACES": [
-    "box",
     "chart",
     "display",
-    "label",
-    "line",
-    "linefill",
     "polyline",
     "position",
     "size",
@@ -1438,8 +1434,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.",
-    "color.from_gradient": "Charting helpers not available in PineForge backtests.",
-    "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.",
@@ -1454,8 +1448,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.",
@@ -1541,9 +1534,7 @@
     "trail_points",
     "trail_price"
   ],
-  "UNSUPPORTED_BARE_FUNCS": {
-    "color": "Bare color(...) cast is not supported. Use color.new(c, alpha) or color.rgb(r, g, b, transp)."
-  },
+  "UNSUPPORTED_BARE_FUNCS": {},
   "UNSUPPORTED_NAMESPACES": {
     "footprint": "footprint.* (bid/ask volume rows) is not supported in PineForge batch backtests; it requires tick-level data the engine does not consume.",
     "volume_row": "volume_row.* is not supported in PineForge batch backtests; same reason as footprint.*."
@@ -1562,12 +1553,7 @@
     "barmerge": "is only valid as the gaps/lookahead argument of request.security(...); it has no runtime value as a free expression in PineForge.",
     "alert": "is only valid as the freq argument of alert(...); it has no runtime value as a free expression in PineForge."
   },
-  "UNSUPPORTED_MEMBERS": {
-    "chart.left_visible_bar_time": "chart.left_visible_bar_time has no meaning in a batch backtest (no viewport).",
-    "chart.right_visible_bar_time": "chart.right_visible_bar_time has no meaning in a batch backtest (no viewport).",
-    "chart.bg_color": "chart.bg_color has no meaning in a batch backtest (no chart theme).",
-    "chart.fg_color": "chart.fg_color has no meaning in a batch backtest (no chart theme)."
-  },
+  "UNSUPPORTED_MEMBERS": {},
   "UNSUPPORTED_NAMESPACE_VARS": {
     "dividends": "dividends.* is not available in PineForge — fundamental dividend data is not loaded.",
     "earnings": "earnings.* is not available in PineForge — fundamental earnings data is not loaded.",