@pineforge/codegen-pyodide 0.8.0 → 0.8.1

package/pineforge_codegen/parser.py

@@ -576,39 +576,64 @@ class Parser:
 
     # -- Function definition --
 
+    def _parse_param_type_annotation(self) -> str | None:
+        """Consume an optional function-parameter type annotation and return it
+        as a canonical hint string ('float', 'string', 'array<line>', 'pivot',
+        'chart.point', ...), or ``None`` for a bare untyped param.
+
+        Leaves the parser positioned at the parameter name. Supports the Pine
+        qualifier prefixes (``series`` / ``simple`` / ``const`` — consumed but
+        not part of the C++ type), builtin types, user-defined / drawing type
+        names, and the ``T[]`` postfix-array shorthand (normalised to
+        ``array<T>`` by ``_parse_type_hint_string``).
+        """
+        TYPE_TOKENS = {TokenType.TYPE_INT, TokenType.TYPE_FLOAT,
+                       TokenType.TYPE_BOOL, TokenType.TYPE_STRING}
+        # Optional qualifiers — they do not affect the C++ param type.
+        while self._check(TokenType.IDENT) and self._current().value in (
+            "series", "simple", "const",
+        ):
+            self._advance()
+        # Is there a type annotation before the parameter name? A builtin type
+        # token always is; an IDENT is a type only if followed by another IDENT
+        # (``line ln``), by ``[`` (``line[] arr``), or by ``<`` (the generic
+        # collection syntax ``array<float> xs`` / ``matrix<float> m`` /
+        # ``map<string,float> mp``). Without the ``<`` case the generic type is
+        # mis-consumed as the parameter name and the whole function definition
+        # silently fails to parse (its body leaks to top-level scope).
+        has_type = False
+        if self._current().type in TYPE_TOKENS:
+            has_type = True
+        elif self._check(TokenType.IDENT):
+            nxt = self._peek().type
+            if nxt in (TokenType.IDENT, TokenType.LBRACKET, TokenType.LT):
+                has_type = True
+        if not has_type:
+            return None
+        return self._parse_type_hint_string()
+
     def _parse_func_def(self) -> FuncDef:
         """Parse: name(param1, param2) => expr_or_block"""
         start_tok = self._current()
         name = self._consume(TokenType.IDENT).value
         self._consume(TokenType.LPAREN)
-        TYPE_TOKENS = {TokenType.TYPE_INT, TokenType.TYPE_FLOAT,
-                       TokenType.TYPE_BOOL, TokenType.TYPE_STRING}
         params = []
+        param_type_hints: list = []
+        param_defaults: list = []
         while not self._check(TokenType.RPAREN):
-            # Consume optional Pine parameter type qualifiers, e.g. `series float x`,
-            # `simple string maType`, `const int n`. Each is one qualifier in front
-            # of the (optional) type and the name — NOT a separate parameter.
-            while self._check(TokenType.IDENT) and self._current().value in (
-                "series",
-                "simple",
-                "const",
-            ):
-                self._advance()
-            # Handle optional type annotation: type param (e.g., int len, float src,
-            # string s). Built-in types are dedicated tokens; user-defined types are
-            # IDENTs and handled by the "next is IDENT" check below.
-            if self._current().type in TYPE_TOKENS:
-                self._advance()  # skip the type annotation
+            # Consume the optional type annotation (builtin / user / drawing /
+            # ``T[]``), returning the canonical hint string. Handles ``float[] arr``,
+            # ``line[] ln``, ``color c``, ``SDZone z``, ``string tf``, as well as
+            # the untyped bare-name case.
+            hint = self._parse_param_type_annotation()
             param_name = self._consume(TokenType.IDENT).value
-            if self._check(TokenType.IDENT):
-                # 'param_name' was actually a (user-defined) type name parsed as IDENT,
-                # next is the real name.
-                param_name = self._consume(TokenType.IDENT).value
-            # Skip default value: param = expr
+            pdefault = None
             if self._check(TokenType.EQUALS):
                 self._advance()  # consume '='
-                self._parse_expression()  # consume default value (discarded)
+                pdefault = self._parse_expression()  # default value
             params.append(param_name)
+            param_type_hints.append(hint)
+            param_defaults.append(pdefault)
             self._match(TokenType.COMMA)
         self._consume(TokenType.RPAREN)
         self._skip_newlines()
@@ -625,6 +650,13 @@ class Parser:
             expr = self._parse_expression()
             node = FuncDef(name=name, params=params, body=[ExprStmt(expr=expr)], is_single_expr=True)
 
+        # Record per-param type hints + defaults (mirrors _parse_method_def) so
+        # the analyzer can type UDT/string/array params and the codegen can emit
+        # them with the correct C++ type (``pivot hi``, ``std::string s``).
+        node.annotations = {
+            "param_type_hints": param_type_hints,
+            "param_defaults": param_defaults,
+        }
         return self._set_loc(node, start_tok)
 
     def _parse_type_or_enum_decl(self):
@@ -701,7 +733,8 @@ class Parser:
             if self._current().type in TYPE_KEYWORDS:
                 param_type = self._parse_type_hint_string()
             elif (self._current().type == TokenType.IDENT
-                  and self._peek().type == TokenType.IDENT):
+                  and self._peek().type in (TokenType.IDENT, TokenType.LBRACKET, TokenType.LT)):
+                # ``line ln`` / ``float[] arr`` / ``array<float> xs`` typed param.
                 param_type = self._parse_type_hint_string()
             p = self._consume(TokenType.IDENT).value
             pdefault = None

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.",
@@ -411,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
@@ -425,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 --
 
@@ -446,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 --
 
@@ -639,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,
@@ -655,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":
@@ -665,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)
 
@@ -686,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(
@@ -942,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
@@ -962,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:
@@ -1238,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.8.0",
+  "codegen": "0.8.1",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "6b81a8d07ce4daa940178d204dadad410fc7952c83ab43e92abf5d8e869c2a31"
+  "sha256": "85ac44383967dd8c9825a276661eab568b16ecb89fcb929a3b9b638b6a4f371c"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "0.8.0",
+  "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,7 +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.",
-    "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 +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.",