@pineforge/codegen-pyodide 0.8.0 → 0.8.1

package/pineforge_codegen/codegen/base.py

@@ -39,6 +39,7 @@ from .tables import (
     BAR_FIELDS,
     BAR_BUILTINS,
     BAR_SERIES_PUSH,
+    DRAWING_TYPE_TO_CPP,
     SECURITY_OHLC_BAR_FIELDS,
     TA_RETURNS_BOOL,
     TA_IMPLICIT_COMPUTE,
@@ -112,12 +113,17 @@ from .visit_stmt import StmtVisitor
 from .visit_expr import ExprVisitor
 from .visit_call import CallVisitor
 
+# DrawingVisitor owns the drawing-objects-as-data dispatch (line/box/label/
+# linefill/chart.point lowering onto the per-type arenas) plus _uses_drawing
+# detection and arena-cap computation. See codegen/drawing.py.
+from .drawing import DrawingVisitor
+
 
 # ---------------------------------------------------------------------------
 # CodeGen class
 # ---------------------------------------------------------------------------
 
-class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEmitter, TaSiteHelper, TypeInferer, InputHelper, NamingHelper):
+class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEmitter, TaSiteHelper, TypeInferer, InputHelper, DrawingVisitor, NamingHelper):
     """Generate C++ from an AnalyzerContext (visitor pattern).
 
     Mixin chain (Python MRO is left-to-right; method names are
@@ -177,7 +183,22 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._active_var_remap: dict[str, str] = {}
         # Set of var/series member names that belong to user functions (need cloning)
         self._func_var_members_set: set[str] = set()
+        # BUG C: function-local names emitted as ``UDT*`` pointer aliases (a UDT
+        # local initialised from a var/global UDT lvalue, mutated through, AND
+        # later rebound to a different lvalue). Member access lowers to ``->``
+        # and rebinds to ``&(...)``. Reset per function in _emit_func_def is not
+        # needed: names are function-unique and the value-copy fallback ignores
+        # entries for inactive functions.
+        self._udt_ptr_alias_locals: set[str] = set()
         self._precalc_loop_active: bool = False
+        # Names of ``var`` members that live in a FUNCTION scope (not global).
+        # These are initialized once-per-function-variant on first call (a
+        # function-local static equivalent), NOT in the constructor / on_bar
+        # preamble. See ``_emit_func_var_init_block``.
+        self._func_local_var_names: set[str] = set()
+        for _vlist in ctx.func_var_members.values():
+            for _n, _, _ in _vlist:
+                self._func_local_var_names.add(_n)
 
         # Build per-function var/series name lists for cloning.
         # For each function with call-site variants, collect ALL function-scoped
@@ -260,30 +281,61 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
         # Build cloned site remapping for cs > 0 (must happen before _ta_site_map
         # so cloned names are in _func_ta_members and get filtered out of the map)
+        #
+        # Default to the ``{orig}_cs{cs_idx}`` formula (matches the analyzer's clone
+        # naming), but defer to the analyzer's authoritative clone-name map for any
+        # site it had to disambiguate (a TA site reached through multiple enclosing
+        # functions would otherwise collide on the formula). Keeping the formula as
+        # the default leaves all non-colliding output byte-identical.
+        clone_names = getattr(ctx, "func_cs_ta_clone_names", {})
         for fname, orig_names in func_ta_originals.items():
             total_cs = ctx.func_call_site_counts.get(fname, 1)
             for cs_idx in range(1, total_cs):
+                overrides = clone_names.get((fname, cs_idx), {})
                 remap = {}
                 for orig_name in orig_names:
-                    remap[orig_name] = f"{orig_name}_cs{cs_idx}"
+                    remap[orig_name] = overrides.get(
+                        orig_name, f"{orig_name}_cs{cs_idx}")
                 self._func_cs_ta_remap[(fname, cs_idx)] = remap
                 self._func_ta_members.update(remap.values())
 
         for site in ctx.ta_call_sites:
             if site.node is not None:
                 if site.member_name not in self._func_ta_members:
+                    # Top-level (non-function) site: maps to itself.
                     self._ta_site_map[id(site.node)] = site
-                elif not any(site.member_name.endswith(f"_cs{i}") for i in range(1, 100)):
-                    # Original (cs0) function-local site — add to map for initial visit
+                elif id(site.node) not in self._ta_site_map:
+                    # Function-local site. Multiple clones share the SAME AST
+                    # node (clones copy ``node=orig.node``); the FIRST one in
+                    # ``ta_call_sites`` order is the canonical original (cs0)
+                    # whose ``member_name`` the per-call-site remap is keyed on.
+                    # Later clones (``_cs{i}``, ``_cs{i}_cs{j}``, ``_u{n}`` …)
+                    # must NOT overwrite it: doing so poisons the base name so
+                    # the active-remap lookup misses and every clone collapses
+                    # onto one member. Keep the original; the variant member is
+                    # resolved via ``_active_ta_remap`` at emit time.
                     self._ta_site_map[id(site.node)] = site
         self._ta_index_by_site_id: dict[int, int] = {
             id(site): i for i, site in enumerate(ctx.ta_call_sites)
         }
+        # Context-sensitive (call-path) instance machinery for nested stateful
+        # helpers. Built by ``_build_func_instances`` below. ``_current_instance_name``
+        # names the function clone whose body is currently being emitted (None at
+        # top level / non-variant bodies). ``_instance_dispatch`` maps
+        # ``(enclosing_instance_name, call_node_id) -> callee emit-name`` and is the
+        # authority for nested stateful-helper dispatch (see visit_call).
+        self._current_instance_name: str | None = None
+        self._instance_dispatch: dict[tuple[str | None, int], str] = {}
+        self._fresh_instances: list[dict] = []
+        self._fresh_var_members: list[tuple[str, str]] = []
+        # NOTE: _build_func_instances() runs at the top of generate() (it needs
+        # _all_member_names / _func_safe_name, which are populated later in __init__).
         # Build lookup: node id -> FixnanCallSite (counter-based)
         self._fixnan_counter = 0
         self._switch_counter = 0
         self._security_inline_counter = 0
         self._random_call_counter = 0
+        self._for_counter = 0
         # UDT / enum (needed before _collect_known_vars for input.enum)
         self._udt_defs: dict[str, list] = {}
         self._enum_defs: dict[str, list[str]] = {}
@@ -308,6 +360,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # Map input-backed var name -> its input.*() FuncCall node so we can
         # later emit a runtime get_input_*() read with the same title/default.
         self._input_var_to_call: dict[str, FuncCall] = {}
+        # Class-scope arithmetic-over-input vars (e.g. ``wilderLen = rsiLen*2-1``).
+        # Maps the derived var name -> its raw RHS expression string. When such a
+        # var feeds a TA ctor length, the runtime-reset path expands it so input
+        # overrides propagate (``(get_input_int("RSI Length",14) * 2 - 1)``); the
+        # ctor-init list still folds to the Pine-default literal via _resolve_known.
+        self._derived_input_expr: dict[str, str] = {}
         self._timeframe_period_vars: set[str] = set()
         self._collect_known_vars()
         # Track var names
@@ -337,6 +395,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._global_mutable_infos: dict[str, object] = getattr(ctx, "global_mutable_infos", {}) or {}
         self._udt_var_types: dict[str, str] = getattr(ctx, "udt_var_types", {}) or {}
         self._collection_types: dict[str, TypeSpec] = getattr(ctx, "collection_types", {}) or {}
+        # id(block_node) -> {raw_var_name: unique_member} for block-scoped var
+        # name collisions (see Analyzer._visit_VarDecl). Activated into
+        # ``_active_var_remap`` while emitting the owning block's statements.
+        self._block_var_renames: dict[int, dict[str, str]] = getattr(ctx, "block_var_renames", {}) or {}
         self._udt_field_type_specs: dict[str, dict[str, TypeSpec]] = getattr(ctx, "udt_field_type_specs", {}) or {}
         # Map UDT struct name -> set of field names that were dropped from the
         # emitted C++ struct because they had drawing-only types (label, line,
@@ -347,7 +409,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # rewrite or strip downstream references to those fields so the
         # generated C++ never references a member that doesn't exist on the
         # emitted struct. See: pineforge-codegen issue #10.
-        _DRAWING_TYPES_INIT = {"label", "line", "box", "table", "linefill", "polyline", "chart.point"}
+        # Drawing-objects-as-data: line/box/label/linefill/chart.point are now
+        # REAL data (un-dropped from UDT structs). Only table/polyline stay
+        # dropped (no C++ representation). See drawing-objects-as-data.md §4.2.
+        _DRAWING_TYPES_INIT = {"table", "polyline"}
         self._udt_omitted_fields: dict[str, set[str]] = {}
         for _type_name, _fields in self._udt_defs.items():
             _omitted = set()
@@ -378,6 +443,29 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 self._map_vars.add(_name)
             elif _spec.kind == "udt" and _spec.name:
                 self._udt_var_types.setdefault(_name, _spec.name)
+        # Table / polyline variables and params have NO C++ representation
+        # (SKIP_VAR_TYPES). A *method* call on such a receiver
+        # (``panel.cell(...)``, ``dash.merge_cells(...)``) is a visual no-op
+        # that must be dropped — but unlike the namespace form
+        # (``table.cell(...)``) the receiver is a bare var/param the
+        # namespace-based skip cannot see. Collect those names so
+        # ``_is_skip_expr`` can drop their method calls.
+        _SKIP_DECL_TYPES = set(SKIP_VAR_TYPES) | {"polyline"}
+        self._visual_drop_vars: set[str] = set()
+        for _node in self._walk_ast(self.ctx.ast):
+            if isinstance(_node, VarDecl):
+                if _node.type_hint in _SKIP_DECL_TYPES:
+                    self._visual_drop_vars.add(_node.name)
+                elif isinstance(_node.value, FuncCall):
+                    _fn, _ns = self._resolve_callee(_node.value.callee)
+                    if _fn == "new" and _ns in _SKIP_DECL_TYPES:
+                        self._visual_drop_vars.add(_node.name)
+            elif isinstance(_node, (FuncDef, MethodDef)):
+                _hints = (getattr(_node, "annotations", None) or {}).get("param_type_hints") or []
+                for _i, _p in enumerate(getattr(_node, "params", []) or []):
+                    _h = _hints[_i] if _i < len(_hints) else None
+                    if _h and str(_h).replace(" ", "") in _SKIP_DECL_TYPES:
+                        self._visual_drop_vars.add(_p)
         # Collect request.security metadata per call
         self._security_eval_info: list[dict] = []
         self._security_ta_variant_names: dict[tuple[int, int, tuple], str] = {}
@@ -388,15 +476,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             lookahead_node = item.get("lookahead_node")
             ta_range = item.get("ta_range")
 
-            tf_str = None
-            if isinstance(tf_node, StringLiteral):
-                tf_str = tf_node.value
-            elif (isinstance(tf_node, Identifier)
-                  and tf_node.name in self._known_vars
-                  and tf_node.name not in self._input_backed_vars):
-                val = self._known_vars[tf_node.name]
-                if isinstance(val, str):
-                    tf_str = val
+            # Resolve the timeframe: a literal/const/global gives a static tf;
+            # a function-parameter tf is resolved from the call sites (the
+            # evaluator is a class method, so the param is not in scope there).
+            tf_str, tf_expr = self._resolve_security_tf(
+                tf_node, item.get("containing_func", ""))
 
             is_lookahead_on = False
             if lookahead_node is not None:
@@ -447,9 +531,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             self._security_eval_info.append({
                 "sec_id": sec_id,
                 "tf": tf_str,
+                "tf_expr": tf_expr,
                 "tf_node": tf_node,
                 "gaps_on": is_gaps_on,
                 "lookahead_on": is_lookahead_on,
+                "heikinashi": bool(item.get("heikinashi", False)),
                 "ta_range": ta_range,
                 "ta_indices": sorted(ta_indices),
                 "ta_binding_stacks": ta_binding_stacks,
@@ -468,6 +554,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
         self._register_global_aggregate_member_types()
         self._uses_matrix = self._detect_matrix_usage()
+        # Drawing-objects-as-data: gate all new emission (drawing.hpp include +
+        # the per-type arenas) on this flag so non-drawing strategies stay
+        # byte-identical. Caps come from the strategy() header max_*_count.
+        self._uses_drawing = self._detect_drawing_usage()
+        self._drawing_caps = self._compute_drawing_caps() if self._uses_drawing else {}
 
         # max_bars_back: the per-variable history depth the engine's Series<T>
         # ring buffer should retain. Pine exposes this two ways — the
@@ -493,6 +584,194 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # history reads off security-helper series.
         self._max_bars_back_cap: int | None = self._compute_max_bars_back_cap()
 
+    # ------------------------------------------------------------------
+    # Context-sensitive (call-path) instance machinery
+    # ------------------------------------------------------------------
+    def _iter_func_calls(self, root) -> list:
+        """Collect every ``FuncCall`` node reachable from ``root`` (a stmt list
+        or single AST node). Order-independent; used by the instance pre-pass to
+        find nested user-function calls inside a function body."""
+        out: list = []
+        seen: set[int] = set()
+        stack: list = list(root) if isinstance(root, (list, tuple)) else [root]
+        while stack:
+            node = stack.pop()
+            if node is None:
+                continue
+            if isinstance(node, (list, tuple)):
+                stack.extend(node)
+                continue
+            if isinstance(node, dict):
+                stack.extend(node.values())
+                continue
+            if not hasattr(node, "__dict__"):
+                continue
+            nid = id(node)
+            if nid in seen:
+                continue
+            seen.add(nid)
+            if isinstance(node, FuncCall):
+                out.append(node)
+            for v in vars(node).values():
+                if isinstance(v, (list, tuple, dict)) or hasattr(v, "__dict__"):
+                    stack.append(v)
+        return out
+
+    def _build_func_instances(self) -> None:
+        """Context-sensitive cloning of nested stateful helper functions.
+
+        A stateful helper ``G`` (carrying TA state and/or ``var`` members) may be
+        reached through several distinct call paths — e.g. ``leg`` called from
+        three clones of ``f_get`` (lengths 10/20/30) *and* directly. Each path is
+        a logically-distinct instance that must drive its OWN TA/var members.
+
+        The analyzer already mints the per-path members (via range-widening), but
+        the flat ``{G}_cs{idx}`` clone namespace conflates a callee's own textual
+        call sites with the enclosing function's call sites. This pre-pass walks
+        the call graph from each natural clone and, for every nested stateful
+        call, composes the enclosing clone's active remap with the callee's
+        per-call-site remap:
+
+            composed_ta[m] = R_enclosing.get(R_callee_cs[m], R_callee_cs[m])
+
+        When the composition equals the callee's natural ``cs{j}`` remap the call
+        dispatches to the existing ``{G}_cs{j}`` clone (output stays byte-identical
+        for the common single-caller case). Otherwise a fresh instance is minted,
+        bound to the path-specific members (and FRESH ``var`` members so two paths
+        never share scalar state). ``_instance_dispatch`` records the resolved
+        emit-name per ``(enclosing_instance, call_node)``; ``_fresh_instances`` /
+        ``_fresh_var_members`` carry the extra code to emit.
+        """
+        ctx = self.ctx
+        stateful = (set(ctx.func_ta_ranges.keys())
+                    | set(ctx.func_var_members.keys())
+                    | set(ctx.func_series_vars.keys()))
+        if not stateful:
+            return
+
+        func_bodies: dict[str, list] = {}
+        for fi in ctx.func_infos:
+            node = getattr(fi, "node", None)
+            if node is not None and getattr(node, "body", None):
+                func_bodies.setdefault(fi.name, node.body)
+
+        def ta_originals(fname: str) -> list[str]:
+            return list(self._func_cs_ta_remap.get((fname, 0), {}).keys())
+
+        def var_originals(fname: str) -> list[str]:
+            return [self._safe_name(n) for n, _, _ in ctx.func_var_members.get(fname, [])]
+
+        def natural_name(fname: str, cs_idx: int) -> str:
+            return f"{self._func_safe_name(fname)}_cs{cs_idx}"
+
+        interned: dict[tuple, dict] = {}
+        worklist: list[dict] = []
+        seen_walk: set[str] = set()
+        fresh_counter = 0
+
+        # Seed with the natural clones the flat emission loop produces.
+        for fname in stateful:
+            if fname not in func_bodies:
+                continue
+            total_cs = ctx.func_call_site_counts.get(fname, 0)
+            if total_cs > 0:
+                for k in range(total_cs):
+                    worklist.append({
+                        "fname": fname,
+                        "name": natural_name(fname, k),
+                        "ta_remap": self._func_cs_ta_remap.get((fname, k), {}),
+                        "var_remap": self._func_cs_var_remap.get((fname, k), {}),
+                    })
+            else:
+                worklist.append({
+                    "fname": fname,
+                    "name": self._func_safe_name(fname),
+                    "ta_remap": {},
+                    "var_remap": {},
+                })
+
+        while worklist:
+            inst = worklist.pop()
+            if inst["name"] in seen_walk:
+                continue
+            seen_walk.add(inst["name"])
+            body = func_bodies.get(inst["fname"])
+            if not body:
+                continue
+            active_ta = inst["ta_remap"]
+            for callnode in self._iter_func_calls(body):
+                cs_info = ctx.func_call_cs_map.get(id(callnode))
+                if cs_info is None:
+                    continue
+                g_name, j = cs_info
+                if g_name not in stateful:
+                    continue
+                natural_ta = self._func_cs_ta_remap.get((g_name, j), {})
+                composed_ta = {}
+                for m in ta_originals(g_name):
+                    mid = natural_ta.get(m, m)
+                    composed_ta[m] = active_ta.get(mid, mid)
+                if composed_ta == natural_ta:
+                    # Path resolves to the callee's own cs{j} clone — reuse it.
+                    self._instance_dispatch[(inst["name"], id(callnode))] = \
+                        natural_name(g_name, j)
+                    continue
+                key = (g_name, frozenset(composed_ta.items()))
+                ginst = interned.get(key)
+                if ginst is None:
+                    fresh_counter += 1
+                    inst_name = f"{self._func_safe_name(g_name)}__ni{fresh_counter}"
+                    fvar_remap: dict[str, str] = {}
+                    for v in var_originals(g_name):
+                        fresh_member = f"{v}__ni{fresh_counter}"
+                        fvar_remap[v] = fresh_member
+                        self._fresh_var_members.append((v, fresh_member))
+                    ginst = {
+                        "fname": g_name,
+                        "name": inst_name,
+                        "ta_remap": composed_ta,
+                        "var_remap": fvar_remap,
+                    }
+                    interned[key] = ginst
+                    self._fresh_instances.append(ginst)
+                    worklist.append(ginst)
+                self._instance_dispatch[(inst["name"], id(callnode))] = ginst["name"]
+
+    def _emit_cloned_var_decl(self, orig_safe: str, cloned_safe: str,
+                              series_suffix: str, lines: list[str]) -> None:
+        """Declare a per-clone copy of a function-scoped ``var`` member, matching
+        the original's C++ type (series / matrix / array / map / drawing-handle /
+        UDT / scalar). Shared by the per-call-site clone loop and the fresh
+        context-sensitive instance loop."""
+        for vname, ptype, _init_str in self.ctx.var_members:
+            if self._safe_name(vname) == orig_safe:
+                cpp_type = PINE_TYPE_TO_CPP.get(ptype, "double")
+                if vname in self.ctx.series_vars:
+                    lines.append(f"    Series<{cpp_type}> {cloned_safe}{series_suffix};")
+                elif vname in self._matrix_specs:
+                    lines.append(f"    {self._type_spec_to_cpp(self._matrix_specs[vname])} {cloned_safe};")
+                elif vname in self._array_vars:
+                    lines.append(f"    {self._type_spec_to_cpp(self._array_spec_for_name(vname))} {cloned_safe};")
+                elif vname in self._map_vars:
+                    lines.append(f"    {self._type_spec_to_cpp(self._map_spec_for_name(vname))} {cloned_safe};")
+                elif vname in self._udt_var_types:
+                    # Drawing handle / UDT var clone must match the original's
+                    # type (Line/Label/Box/<UDT>), not the coarse PineType
+                    # default (double) — otherwise the clone can't hold the
+                    # handle and drawing access on it reads a garbage / na id.
+                    udt_t = self._udt_var_types[vname]
+                    handle_cpp = DRAWING_TYPE_TO_CPP.get(udt_t, udt_t)
+                    lines.append(f"    {handle_cpp} {cloned_safe} = {handle_cpp}{{}};")
+                else:
+                    lines.append(f"    {cpp_type} {cloned_safe};")
+                return
+        # Non-var series var
+        if orig_safe in [self._safe_name(n) for n in self.ctx.series_vars]:
+            cpp_type = self._series_type_for(orig_safe)
+            lines.append(f"    Series<{cpp_type}> {cloned_safe}{series_suffix};")
+        else:
+            lines.append(f"    double {cloned_safe} = 0.0;")
+
     @staticmethod
     def _int_literal_value(node: ASTNode | None) -> int | None:
         """Return the integer value of a (possibly unary-minus) NumberLiteral,
@@ -759,6 +1038,45 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             walk(stmt)
         return reassigned
 
+    def _arith_expr_to_str(self, node) -> str | None:
+        """Render a numeric arithmetic-over-identifiers expression to a string
+        whose token spelling matches ``_resolve_known`` / ``_runtime_ctor_arg_for_reset``
+        (e.g. ``rsiLen * 2 - 1``). Returns None for any node shape we don't fold
+        (series subscripts, ternaries, etc.) so the caller leaves the var untracked.
+        """
+        if isinstance(node, NumberLiteral):
+            v = node.value
+            if isinstance(v, float) and v == int(v):
+                return str(int(v))
+            return str(v)
+        if isinstance(node, Identifier):
+            return node.name
+        if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
+            return f"{node.object.name}.{node.member}"
+        if isinstance(node, BinOp):
+            l = self._arith_expr_to_str(node.left)
+            r = self._arith_expr_to_str(node.right)
+            if l is None or r is None:
+                return None
+            return f"{l} {node.op} {r}"
+        if isinstance(node, UnaryOp):
+            o = self._arith_expr_to_str(node.operand)
+            if o is None:
+                return None
+            return f"{node.op}{o}"
+        if isinstance(node, FuncCall):
+            callee = self._arith_expr_to_str(node.callee)
+            if callee is None:
+                return None
+            parts = []
+            for a in node.args:
+                s = self._arith_expr_to_str(a)
+                if s is None:
+                    return None
+                parts.append(s)
+            return f"{callee}({', '.join(parts)})"
+        return None
+
     def _collect_known_var(self, node: VarDecl) -> None:
         """Extract known constant value from a VarDecl."""
         # Don't inline series variables — their values change over time
@@ -811,6 +1129,36 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if stored:
                 self._input_backed_vars.add(node.name)
                 self._input_var_to_call[node.name] = node.value
+        # Class-scope arithmetic over known/input-backed vars
+        # (``wilderLen = rsiLen * 2 - 1``, ``n = math.round(len / 2)``).
+        # Without this branch the derived name is untracked, the TA ctor arg
+        # never folds, and the runtime-reset path silently degenerates to a
+        # period of 1. We (a) fold to a literal for the ctor-init list and
+        # (b) record the raw expression so the reset path can re-expand any
+        # input-backed operand to its get_input_*() runtime read.
+        elif isinstance(node.value, (BinOp, UnaryOp, FuncCall)):
+            expr_str = self._arith_expr_to_str(node.value)
+            if expr_str is not None:
+                import re as _re
+                tokens = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", expr_str))
+                refs_known = any(t in self._known_vars for t in tokens)
+                refs_input = any(t in self._input_backed_vars for t in tokens)
+                refs_derived = any(t in self._derived_input_expr for t in tokens)
+                if refs_known or refs_input or refs_derived:
+                    folded = self._resolve_known(expr_str)
+                    if self._is_compile_time_value(folded):
+                        try:
+                            num = float(folded)
+                            self._known_vars[node.name] = (
+                                int(num) if num == int(num) else num
+                            )
+                        except ValueError:
+                            pass
+                    if refs_input or refs_derived:
+                        # Track as input-backed so use-sites are not inlined and
+                        # the runtime-reset path emits the override-aware expr.
+                        self._derived_input_expr[node.name] = expr_str
+                        self._input_backed_vars.add(node.name)
 
     # ------------------------------------------------------------------
     # Public entry point
@@ -869,9 +1217,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
 
     def generate(self) -> str:
         """Generate C++ source from the AnalyzerContext."""
+        # Context-sensitive instance pre-pass (needs the naming helpers populated
+        # in __init__). Computes nested stateful-helper dispatch + fresh instances.
+        self._build_func_instances()
         # Pre-scan for strategy series vars
         self._prescan_strategy_series()
         self._security_ohlc_hist_fields_by_sec: dict[int, set[str]] = {}
+        # request.security TA call-sites read at a history offset (``ta.ema(...)[k>=1]``).
+        # Maps sec_id -> set of TA call-site indices needing an HTF history Series.
+        self._security_ta_hist_idx_by_sec: dict[int, set[int]] = {}
 
         lines: list[str] = []
 
@@ -897,6 +1251,12 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     continue
                 spec = field_specs.get(f.name) or self._type_spec_from_hint_name(f.type_name)
                 cpp_type = self._type_spec_to_cpp(spec)
+                # Pine ``int`` is 64-bit (it routinely holds UNIX-ms timestamps
+                # and large bar indices); emit UDT int fields as ``int64_t`` so a
+                # field initialised from ``time``/``current_bar_.timestamp`` does
+                # not truncate / narrow-init.
+                if cpp_type == "int":
+                    cpp_type = "int64_t"
                 if f.default:
                     default = self._visit_expr(f.default)
                 else:
@@ -961,6 +1321,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     lines.append(
                         f"    Series<double> {self._security_ohlc_hist_series_cpp(sec_id, field)}{_mbb};"
                     )
+                self._security_ta_hist_idx_by_sec[sec_id] = (
+                    self._collect_security_ta_hist_indices(expr_node)
+                )
+                for name in self._security_ta_hist_series_names(sec_id):
+                    lines.append(f"    Series<double> {name}{_mbb};")
                 continue
             if returns_tuple and tuple_size and tuple_size > 0 and isinstance(expr_node, TupleLiteral):
                 hist_fields: set[str] = set()
@@ -982,6 +1347,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 lines.append(
                     f"    Series<double> {self._security_ohlc_hist_series_cpp(sec_id, field)}{_mbb};"
                 )
+            self._security_ta_hist_idx_by_sec[sec_id] = (
+                self._collect_security_ta_hist_indices(expr_node)
+            )
+            for name in self._security_ta_hist_series_names(sec_id):
+                lines.append(f"    Series<double> {name}{_mbb};")
 
         if self._security_calls:
             lines.append('    std::unordered_map<std::string, Series<double>> _security_helper_series_;')
@@ -1031,8 +1401,20 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 continue
             seen_var_members.add(name)
             safe = self._safe_name(name)
-            # Detect array vars from init expression
-            if "array.new" in str(init_str) or "array.from" in str(init_str) or name in self._array_vars:
+            # Detect array vars from init expression. Guard the substring
+            # heuristic against a UDT constructor that merely WRAPS array.new /
+            # array.from in its arguments — e.g.
+            # ``var draw d = draw.new(array.new<line>(), array.new<line>())``
+            # must declare as ``draw``, not ``std::vector<double>``. (Drawing
+            # made this latent collision reachable.)
+            _init_str_s = str(init_str)
+            _is_udt_ctor_init = any(
+                _init_str_s.startswith(f"{u}.new") for u in self._udt_defs
+            )
+            if (not _is_udt_ctor_init) and (
+                "array.new" in _init_str_s or "array.from" in _init_str_s
+                or name in self._array_vars
+            ):
                 self._array_vars.add(name)
                 lines.append(f"    {self._type_spec_to_cpp(self._array_spec_for_name(name))} {safe};")
                 continue
@@ -1063,6 +1445,17 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # decl as ``double`` and the later ``z = SDZone{...}`` would not
             # compile (assigning SDZone to double).
             init_s = str(init_str)
+            # Drawing handle var member (L-N2): a ``var line x`` declares as the
+            # C++ handle struct (Series<Line> when also history-referenced).
+            # Drawing names are NOT in _udt_defs, so the udt branch below would
+            # self-zero them to double; handle them first.
+            _draw_cpp = DRAWING_TYPE_TO_CPP.get(self._udt_var_types.get(name))
+            if _draw_cpp is not None:
+                if name in self.ctx.series_vars:
+                    lines.append(f"    Series<{_draw_cpp}> {safe}{_mbb};")
+                else:
+                    lines.append(f"    {_draw_cpp} {safe};")
+                continue
             udt_type = self._udt_var_types.get(name)
             if udt_type not in self._udt_defs:
                 udt_type = None
@@ -1131,7 +1524,13 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 # data/validation/udt-method-probe-19-array-of-udt-method,
                 # data/validation/udt-method-probe-20-udt-return-from-func.
                 udt_t = self._udt_var_types[name]
-                lines.append(f"    {udt_t} {safe} = {udt_t}{{}};")
+                # Drawing handle global (L-N6 / U): map line/box/label/linefill
+                # to the C++ handle struct (the default is na, id=-1).
+                _draw_cpp = DRAWING_TYPE_TO_CPP.get(udt_t)
+                if _draw_cpp is not None:
+                    lines.append(f"    {_draw_cpp} {safe} = {_draw_cpp}{{}};")
+                else:
+                    lines.append(f"    {udt_t} {safe} = {udt_t}{{}};")
             else:
                 expr = self.ctx.global_expr_map.get(name) if hasattr(self.ctx, "global_expr_map") else None
                 cpp_type = self._infer_type(expr) if expr is not None else PINE_TYPE_TO_CPP.get(ptype, "double")
@@ -1148,37 +1547,55 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 if cloned_safe in emitted_clones:
                     continue  # already declared by another function's clone
                 emitted_clones.add(cloned_safe)
-                # Determine the type by finding the original declaration
-                orig_name = orig_safe  # _safe_name was already applied
-                # Check if it's a var member (Series) or plain series
-                found = False
-                for vname, ptype, init_str in self.ctx.var_members:
-                    if self._safe_name(vname) == orig_safe:
-                        cpp_type = PINE_TYPE_TO_CPP.get(ptype, "double")
-                        if vname in self.ctx.series_vars:
-                            lines.append(f"    Series<{cpp_type}> {cloned_safe}{_mbb};")
-                        elif vname in self._matrix_specs:
-                            lines.append(f"    {self._type_spec_to_cpp(self._matrix_specs[vname])} {cloned_safe};")
-                        elif vname in self._array_vars:
-                            lines.append(f"    {self._type_spec_to_cpp(self._array_spec_for_name(vname))} {cloned_safe};")
-                        elif vname in self._map_vars:
-                            lines.append(f"    {self._type_spec_to_cpp(self._map_spec_for_name(vname))} {cloned_safe};")
-                        else:
-                            lines.append(f"    {cpp_type} {cloned_safe};")
-                        found = True
-                        break
-                if not found:
-                    # Non-var series var
-                    if orig_safe in [self._safe_name(n) for n in self.ctx.series_vars]:
-                        cpp_type = self._series_type_for(orig_safe)
-                        lines.append(f"    Series<{cpp_type}> {cloned_safe}{_mbb};")
-                    else:
-                        lines.append(f"    double {cloned_safe} = 0.0;")
+                self._emit_cloned_var_decl(orig_safe, cloned_safe, _mbb, lines)
+
+        # 8c2. Fresh var members for context-sensitive helper instances (nested
+        #      helpers reached through >1 distinct call path). Each fresh instance
+        #      gets its OWN scalar/series state so two paths never collide.
+        for orig_safe, fresh_safe in self._fresh_var_members:
+            if fresh_safe in emitted_clones:
+                continue
+            emitted_clones.add(fresh_safe)
+            self._emit_cloned_var_decl(orig_safe, fresh_safe, _mbb, lines)
+
+        # 8d. Drawing-objects-as-data arenas (gated on _uses_drawing so
+        #     non-drawing strategies emit byte-identical C++). Each arena is a
+        #     per-strategy member -> reset-per-run is automatic. Caps come from
+        #     the strategy() header max_*_count (default 50; linefill default 50).
+        if self._uses_drawing:
+            caps = self._drawing_caps or {}
+            lines.append(f"    DrawingArena<LineRec> _pf_lines_{{{caps.get('line', 50)}}};")
+            lines.append(f"    DrawingArena<BoxRec> _pf_boxes_{{{caps.get('box', 50)}}};")
+            lines.append(f"    DrawingArena<LabelRec> _pf_labels_{{{caps.get('label', 50)}}};")
+            lines.append(f"    DrawingArena<LinefillRec> _pf_linefills_{{{caps.get('linefill', 50)}}};")
 
         # 9. _var_initialized flag
         if self.ctx.var_members:
             lines.append("    bool _var_initialized = false;")
 
+        # 9a. Per-function-variant ``var`` init flags. A function-scoped
+        #     ``var`` (Pine "init once" semantics) is a function-local static:
+        #     its initializer runs on the FIRST call to that function variant
+        #     (with the first bar's values the function actually sees) and the
+        #     result persists for the strategy's lifetime. Each clone (cs0,
+        #     cs1, ...) is an independent instance with its own flag.
+        #     ``func_var_members`` is keyed by the plain Pine function name
+        #     (``fi.name``), so this matches both plain UDFs and UDT methods.
+        for fi in self.ctx.func_infos:
+            if fi.name not in self.ctx.func_var_members:
+                continue
+            total_cs = self.ctx.func_call_site_counts.get(fi.name, 0)
+            if total_cs > 0:
+                for cs_idx in range(total_cs):
+                    lines.append(f"    bool _fvinit_{self._func_safe_name(fi.name)}_cs{cs_idx} = false;")
+            else:
+                lines.append(f"    bool _fvinit_{self._func_safe_name(fi.name)} = false;")
+
+        # 9a2. ``var`` init flags for fresh context-sensitive helper instances.
+        for inst in self._fresh_instances:
+            if inst["fname"] in self.ctx.func_var_members and inst["var_remap"]:
+                lines.append(f"    bool _fvinit_{inst['name']} = false;")
+
         # 9b. _ta_initialized_ flag for runtime TA re-sizing (first on_bar only).
         if self.ctx.ta_call_sites:
             lines.append("    bool _ta_initialized_ = false;")
@@ -1198,7 +1615,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             total_cs = self.ctx.func_call_site_counts.get(fi.name, 0)
             has_ta = fi.name in self.ctx.func_ta_ranges
             has_series = fi.name in self.ctx.func_series_vars or fi.name in self.ctx.func_var_members
-            if (has_ta or has_series) and total_cs > 0:
+            # A function whose ONLY reason to need per-call-site cloning is a
+            # security-tf-monomorphized request.security (no TA/series state
+            # of its own — see Analyzer._check_mixed_callsite_security_tf)
+            # still needs N separate emitted bodies so self._active_call_site_idx
+            # is set while each is emitted (read by the request.security
+            # use-site lowering in visit_call.py to pick the right clone's
+            # sec_id).
+            needs_security_clone = fi.name in self.ctx.func_security_clone_only
+            if (has_ta or has_series or needs_security_clone) and total_cs > 0:
                 # Emit one variant per call site
                 for cs_idx in range(total_cs):
                     self._emit_func_def(fi, lines, call_site_idx=cs_idx)
@@ -1207,7 +1632,20 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 self._emit_func_def(fi, lines)
                 lines.append("")
 
+        # 10a. Fresh context-sensitive instances of nested stateful helpers
+        #      (reached through >1 distinct call path). Each is bound to its own
+        #      path-specific TA + var members; see _build_func_instances.
+        if self._fresh_instances:
+            fi_by_name = {fi.name: fi for fi in self.ctx.func_infos}
+            for inst in self._fresh_instances:
+                fi = fi_by_name.get(inst["fname"])
+                if fi is None:
+                    continue
+                self._emit_func_def(fi, lines, instance=inst)
+                lines.append("")
+
         # 11. on_bar()
+        self._current_instance_name = None
         self._emit_on_bar(lines)
         lines.append("")
 
@@ -1319,6 +1757,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
     def _is_skip_expr(self, node) -> bool:
         """Check if an expression should be skipped (visual/unsupported)."""
         if isinstance(node, FuncCall):
+            # chart.point.* resolves to namespace "chart" (a SKIP_NAMESPACE) but
+            # is REAL data (a ChartPoint aggregate literal). Never skip it.
+            if self._is_chart_point_callee(node.callee):
+                return False
             func_name, namespace = self._resolve_callee(node.callee)
             if func_name in SKIP_FUNC_NAMES:
                 return True
@@ -1326,6 +1768,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 return True
             if namespace in SKIP_VAR_TYPES:
                 return True
+            # Method call on a table/polyline-typed receiver var/param
+            # (``panel.cell(...)``). These types have no C++ representation, so
+            # the call is a visual no-op — drop it (mirrors the namespace form).
+            if namespace in self._visual_drop_vars:
+                return True
             # strategy.risk.* — handled in _visit_stmt, not skipped
         if isinstance(node, MemberAccess):
             if isinstance(node.object, Identifier) and node.object.name in SKIP_NAMESPACES:
@@ -1373,6 +1820,24 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         """
         import re
         ident_re = re.compile(r"[A-Za-z_][A-Za-z_0-9]*")
+
+        # Expand class-scope derived vars (``wilderLen`` -> ``(rsiLen * 2 - 1)``)
+        # to their raw RHS so the input-backed leaves become get_input_*() reads
+        # below. Recursive (bounded) to handle chains of derived vars; guards
+        # against cycles.
+        def _expand_derived(s: str, seen: frozenset = frozenset(), depth: int = 0) -> str:
+            if depth > 32:
+                return s
+            def _rep(m: re.Match) -> str:
+                nm = m.group(0)
+                if nm in self._derived_input_expr and nm not in seen:
+                    inner = self._derived_input_expr[nm]
+                    return "(" + _expand_derived(inner, seen | {nm}, depth + 1) + ")"
+                return nm
+            return ident_re.sub(_rep, s)
+
+        arg_str = _expand_derived(arg_str)
+
         tokens = ident_re.findall(arg_str)
         input_tokens = [t for t in tokens if t in self._input_backed_vars]
         if not input_tokens: