@pineforge/codegen-pyodide 0.8.0 → 0.9.0

package/pineforge_codegen/codegen/emit_top.py

@@ -90,6 +90,7 @@ from ..analyzer import FuncInfo
 from ..symbols import TypeSpec
 from .tables import (
     BAR_SERIES_PUSH,
+    DRAWING_TYPE_TO_CPP,
     PINE_TYPE_TO_CPP,
     RUNTIME_REGISTER_SECURITY_EVAL_FN,
     RUNTIME_REGISTER_SECURITY_LOWER_TF_EVAL_FN,
@@ -117,6 +118,8 @@ class TopLevelEmitter:
         lines.append("#include <string>")
         lines.append("#include <vector>")
         lines.append("#include <tuple>")
+        lines.append("#include <optional>")
+        lines.append("#include <type_traits>")
         lines.append("#include <memory>")
         lines.append("#include <mutex>")
         lines.append("#include <unordered_map>")
@@ -136,6 +139,11 @@ class TopLevelEmitter:
             float_spec = TypeSpec.primitive("float")
             if any(spec.element != float_spec for spec in self._matrix_specs.values()):
                 lines.append('#include <pineforge/generic_matrix.hpp>')
+        # Drawing-objects-as-data runtime (line/box/label/linefill arenas +
+        # ChartPoint). Gated on _uses_drawing so non-drawing strategies stay
+        # byte-identical — mirrors the matrix.hpp gating above.
+        if getattr(self, "_uses_drawing", False):
+            lines.append('#include <pineforge/drawing.hpp>')
         lines.append("")
         # Compatibility shim for the namespace-wrap refactor: unqualified
         # references to BacktestEngine / Bar / na<T>() / ta::* / etc. resolve
@@ -186,6 +194,139 @@ class TopLevelEmitter:
                 return True
         return False
 
+    @staticmethod
+    def _script_state_member_name(decl_line: str) -> str | None:
+        """Extract a generated class-member name from one declaration line.
+
+        ``CodeGen.generate`` emits the complete persistent script state as a
+        contiguous block of one-line declarations before the constructor.  The
+        rollback checkpoint is derived from that block rather than from a
+        second, hand-maintained inventory: adding a new TA/helper/collection
+        member therefore automatically makes it part of Pine's historical
+        execution rollback.
+
+        The supported declaration shapes are the only shapes emitted in that
+        block today::
+
+            Type name;
+            Type name = value;
+            Type name(args);
+            Type name{args};
+
+        A declaration that does not match fails generation loudly.  Silently
+        omitting an unfamiliar member would be materially worse: it would let
+        state leak between ``calc_on_order_fills`` executions.
+        """
+        text = decl_line.strip()
+        if not text:
+            return None
+        if not text.endswith(";"):
+            raise AssertionError(
+                f"unexpected generated script-state declaration: {decl_line!r}"
+            )
+        text = text[:-1].rstrip()
+        if " = " in text:
+            text = text.split(" = ", 1)[0].rstrip()
+        else:
+            # Series<T> members can carry a max_bars_back ctor suffix and
+            # drawing arenas use brace initialization.  Both suffixes start in
+            # the final declarator token; C++ types emitted here never contain
+            # parentheses or braces.
+            last_space = text.rfind(" ")
+            if last_space < 0:
+                raise AssertionError(
+                    f"missing type in generated script-state declaration: {decl_line!r}"
+                )
+            declarator = text[last_space + 1:]
+            cut = len(declarator)
+            for marker in ("(", "{"):
+                pos = declarator.find(marker)
+                if pos >= 0:
+                    cut = min(cut, pos)
+            text = text[:last_space + 1] + declarator[:cut]
+
+        name = text.rsplit(" ", 1)[-1].strip()
+        if not name or not (name[0].isalpha() or name[0] == "_") \
+                or not all(ch.isalnum() or ch == "_" for ch in name):
+            raise AssertionError(
+                f"cannot identify generated script-state member: {decl_line!r}"
+            )
+        return name
+
+    def _collect_script_state_members(self, declaration_lines: list[str]) -> list[str]:
+        """Return every rollback-relevant generated member in declaration order.
+
+        Precalculated TA result vectors and their mode flag are immutable once
+        the engine starts its broker walk.  Copying an O(number-of-bars) cache
+        before every COOF execution would be both unnecessary and catastrophic,
+        so those implementation caches are the sole exclusions.  The live TA
+        objects themselves remain captured because dynamic/magnifier runs call
+        ``compute`` and mutate them.
+        """
+        members: list[str] = []
+        seen: set[str] = set()
+        for line in declaration_lines:
+            name = self._script_state_member_name(line)
+            if name is None:
+                continue
+            if name == "_use_precalc" or name.startswith("_precalc_"):
+                continue
+            if name in seen:
+                raise AssertionError(f"duplicate generated script-state member: {name}")
+            seen.add(name)
+            members.append(name)
+        return members
+
+    def _emit_script_state_hooks(self, lines: list[str], members: list[str]) -> None:
+        """Emit the engine's Pine rollback checkpoint hook implementation.
+
+        The checkpoint owns value copies of all generated mutable state.  Every
+        runtime container used by generated code (Series, std::vector/map,
+        PineMatrix/generic matrices, UDTs and drawing arenas) has value
+        semantics, so copying recursively preserves data without retaining
+        pointers into live state.  Drawing handles themselves are stable ids;
+        their arenas are captured in the same checkpoint.
+
+        The static assertions deliberately turn any future non-copyable member
+        into a compile failure instead of a nominal, shallow rollback.  Engine
+        broker/order state lives in the base class and is intentionally absent:
+        fills must survive while Pine script variables roll back.
+        """
+        lines.append("    struct _PFScriptState {")
+        for idx, name in enumerate(members):
+            lines.append(
+                f"        decltype(GeneratedStrategy::{name}) _pf_value_{idx};"
+            )
+        lines.append("    };")
+        lines.append(
+            "    static_assert(std::is_copy_constructible_v<_PFScriptState>, "
+            '"generated Pine state must be deep-copy constructible");'
+        )
+        lines.append(
+            "    static_assert(std::is_copy_assignable_v<_PFScriptState>, "
+            '"generated Pine state must be deep-copy assignable");'
+        )
+        lines.append("    std::optional<_PFScriptState> _pf_script_state_checkpoint_;")
+        lines.append("")
+        lines.append("    void snapshot_script_state() override {")
+        lines.append("        _pf_script_state_checkpoint_.emplace(_PFScriptState{")
+        for name in members:
+            lines.append(f"            {name},")
+        lines.append("        });")
+        lines.append("    }")
+        lines.append("")
+        lines.append("    void restore_script_state() override {")
+        lines.append("        if (!_pf_script_state_checkpoint_) return;")
+        for idx, name in enumerate(members):
+            lines.append(
+                f"        this->{name} = _pf_script_state_checkpoint_->_pf_value_{idx};"
+            )
+        lines.append("    }")
+        lines.append("")
+        lines.append("    void commit_script_state() override {")
+        lines.append("        snapshot_script_state();")
+        lines.append("    }")
+
     def _typed_na_init(self, cpp_val: str, name: str, ptype) -> str:
         """Re-type a bare ``na<double>()`` initializer to match a non-double
         member's C++ type. A ``var int x = na`` resolves its RHS to
@@ -206,11 +347,35 @@ class TopLevelEmitter:
     def _emit_constructor(self, lines: list[str]) -> None:
         init_parts: list[str] = []
         # TA members with ctor args
-        for site in self.ctx.ta_call_sites:
+        for ta_idx, site in enumerate(self.ctx.ta_call_sites):
+            # Skip dead-code function TA sites entirely — their buffers never
+            # run and their ctor args (bare param names) can never be sized.
+            if ta_idx in self._dead_ta_indices:
+                continue
             if site.ctor_args:
+                # If a ctor arg is neither a compile-time literal nor expandable
+                # to an input-backed runtime expression, the old code silently
+                # emitted period 1 with no overwriting reset — a wrong indicator
+                # masquerading as a working one. Refuse loudly instead. Args that
+                # DO expand to a runtime expr (input-backed / arithmetic-over-input,
+                # incl. function-derived lengths) are safe: the `!_ta_initialized_`
+                # reset overwrites the placeholder before the first compute.
+                for a in site.ctor_args:
+                    r = self._resolve_known(a)
+                    if (not self._is_compile_time_value(r)
+                            and self._runtime_ctor_arg_for_reset(a) is None):
+                        self._codegen_error(
+                            getattr(site, "node", None),
+                            f"Unsupported TA constructor length '{a}' for "
+                            f"{site.class_name}: it is neither a compile-time "
+                            f"constant nor derived from an input, so PineForge "
+                            f"cannot size the indicator buffer.",
+                            hint=("Use a literal, an input.*() value, or "
+                                  "arithmetic over those for TA lengths."),
+                        )
                 resolved = [self._resolve_known(a) for a in site.ctor_args]
-                # If any ctor arg isn't a compile-time value, use default 1
-                # (TA in user functions with runtime params)
+                # Compile-time placeholder for the init list; the runtime reset
+                # (when the arg is input-derived) overwrites it on the first bar.
                 safe_resolved = []
                 for r in resolved:
                     if self._is_compile_time_value(r):
@@ -240,11 +405,24 @@ class TopLevelEmitter:
             safe = self._safe_name(name)
             if name in self._array_vars or name in self._map_vars:
                 continue
+            # Function-scoped ``var`` members are initialized once-per-variant
+            # on first call (see _emit_func_var_init_block); exclude them from
+            # the constructor so they are not double-initialized and so their
+            # (possibly bar-dependent) initializer is lowered in the function's
+            # own scope (with its active var remap for clones).
+            if name in getattr(self, "_func_local_var_names", ()):
+                continue
             # UDT-typed var members (``var SDZone z = na``) default-construct to
             # na via the struct's in-class ``__pf_na = true``; a ctor init like
             # ``z(na<double>())`` would not type-match the struct member.
             if name in self._udt_var_types and self._udt_var_types[name] in self._udt_defs:
                 continue
+            # Drawing handle var member (L-N3): ``var line x`` / ``var box b``
+            # default-construct to {-1} (na). A ``b(na<double>())`` ctor init
+            # would not type-match the handle struct — skip it (the in-class
+            # member default is the once-only persistent na init).
+            if name in self._udt_var_types and self._udt_var_types[name] in DRAWING_TYPE_TO_CPP:
+                continue
             if name not in self.ctx.series_vars:
                 cpp_val = self._resolve_known(init_expr)
                 cpp_val = self._typed_na_init(cpp_val, name, ptype)
@@ -257,6 +435,9 @@ class TopLevelEmitter:
         if sp.get("process_orders_on_close") is True:
             ctor_body.append("        process_orders_on_close_ = true;")
 
+        if sp.get("calc_on_order_fills") is True:
+            ctor_body.append("        calc_on_order_fills_ = true;")
+
         if "initial_capital" in sp and isinstance(sp["initial_capital"], (int, float)):
             ctor_body.append(f"        initial_capital_ = {float(sp['initial_capital'])};")
 
@@ -341,6 +522,7 @@ class TopLevelEmitter:
         lines.append('        if (key == "pyramiding") { pyramiding_ = std::stoi(value); return; }')
         lines.append('        if (key == "slippage") { slippage_ = std::stoi(value); return; }')
         lines.append('        if (key == "process_orders_on_close") { process_orders_on_close_ = (value == "true" || value == "1"); return; }')
+        lines.append('        if (key == "calc_on_order_fills") { calc_on_order_fills_ = (value == "true" || value == "1"); return; }')
         lines.append('        if (key == "close_entries_rule") { close_entries_rule_any_ = (value == "ANY" || value == "any" || value == "1"); return; }')
         lines.append('        if (key == "default_qty_type") {')
         lines.append('            if (value == "fixed" || value == "strategy.fixed" || value == "0") default_qty_type_ = QtyType::FIXED;')
@@ -362,20 +544,22 @@ class TopLevelEmitter:
             lines.append("        security_eval_states_.clear();")
             for info in self._security_eval_info:
                 tf = info.get("tf")
-                tf_expr = None
+                tf_expr = info.get("tf_expr")
                 if tf:
                     tf_expr = f'"{tf}"'
-                else:
-                    tf_node = info.get("tf_node")
-                    if tf_node is not None:
-                        if isinstance(tf_node, Identifier) and tf_node.name in self._timeframe_period_vars:
-                            tf_expr = "script_tf_"
-                        else:
-                            raw_tf_expr = self._visit_expr(tf_node)
-                            tf_expr = self._runtime_ctor_arg_for_reset(raw_tf_expr) or raw_tf_expr
+                elif not tf_expr:
+                    # No static tf and no resolvable runtime expression — fall
+                    # back to the chart timeframe so registration still compiles
+                    # (e.g. a request.security inside a dead-code UDF, or one
+                    # whose tf is a function param called with mixed timeframes).
+                    tf_expr = "input_tf_"
                 if tf_expr:
                     la = "true" if info["lookahead_on"] else "false"
                     go = "true" if info.get("gaps_on") else "false"
+                    # Heikin-Ashi same-symbol read: emit the 6th arg only when set
+                    # so every non-HA strategy's generated code stays byte-identical
+                    # (the engine param defaults to false).
+                    ha_arg = ", true" if info.get("heikinashi") else ""
                     sec_id = info["sec_id"]
                     # The runtime registration function is named in tables.py
                     # to keep a single source of truth and to avoid embedding
@@ -391,7 +575,7 @@ class TopLevelEmitter:
                         lines.append(
                             f"        {RUNTIME_REGISTER_SECURITY_EVAL_FN}"
                             f"({sec_id}, {tf_expr}, "
-                            f"input_tf_, {la}, {go});")
+                            f"input_tf_, {la}, {go}{ha_arg});")
             lines.append("    }")
 
     # Map strategy series member name to push expression
@@ -407,14 +591,45 @@ class TopLevelEmitter:
         "initial_capital": "initial_capital_",
     }
 
+    @staticmethod
+    def _emit_history_series_write(
+            lines: list[str], pad: str, member: str, value: str) -> None:
+        """Emit one Pine-series write without conflating history with isnew.
+
+        Historical fill recalculations keep ``barstate.isnew`` true, but a
+        post-close recalculation restored from the completed ordinary-close
+        checkpoint must replace that bar's current history slot rather than
+        append a duplicate slot.  The engine exposes those independent facts
+        as ``is_first_tick_`` and ``history_advances_new_bar()`` respectively.
+        """
+        lines.append(
+            f"{pad}if (history_advances_new_bar()) {member}.push({value});"
+        )
+        lines.append(f"{pad}else {member}.update({value});")
+
     def _emit_on_bar(self, lines: list[str]) -> None:
         lines.append("    void on_bar(const Bar& bar) override {")
 
+        # reset_run_state() owns engine/broker state, while these generated
+        # Series members belong to the strategy object. Clear all of them on
+        # the first genuine history slot of bar zero, unconditionally: a site
+        # may live behind a branch that does not execute on bar zero. This is a
+        # narrow synthetic-buffer reset, not a promise that every generated
+        # member/init latch supports full same-handle reruns. The post-C rollback
+        # execution has history_advances_new_bar()==false, so it preserves the
+        # committed slot.
+        for info in self._inline_history_members:
+            lines.append(
+                "        if (history_advances_new_bar() && bar_index_ == 0) "
+                f"{info['member_name']}.clear();"
+            )
+
         # a. Push bar field series (with bar magnifier support)
         for field_name in sorted(self.ctx.series_bar_fields):
             push_expr = BAR_SERIES_PUSH.get(field_name, f"current_bar_.{field_name}")
-            lines.append(f"        if (is_first_tick_) _s_{field_name}.push({push_expr});")
-            lines.append(f"        else _s_{field_name}.update({push_expr});")
+            self._emit_history_series_write(
+                lines, "        ", f"_s_{field_name}", push_expr
+            )
 
         # a1. Push history-referenced scalar bar builtins (time[n], bar_index[n],
         #     hl2[n], …). They land in ``series_vars`` and are declared as Series
@@ -429,22 +644,25 @@ class TopLevelEmitter:
             if _bname in self._var_names:
                 continue
             _bexpr = BAR_BUILTINS.get(_bname)
-            if _bexpr is None or f"{_bname}(" in _bexpr:
+            if _bexpr is None or _bexpr.strip().startswith(f"{_bname}("):
                 continue
             _bsafe = self._safe_name(_bname)
-            lines.append(f"        if (is_first_tick_) {_bsafe}.push({_bexpr});")
-            lines.append(f"        else {_bsafe}.update({_bexpr});")
+            self._emit_history_series_write(lines, "        ", _bsafe, _bexpr)
 
         # a2. Push strategy series
         for svar in sorted(self._strategy_series_vars):
             member = svar.replace("_strat_", "")
             push_expr = self._STRAT_SERIES_PUSH.get(member, "0")
-            lines.append(f"        {svar}.push({push_expr});")
+            self._emit_history_series_write(lines, "        ", svar, push_expr)
 
         # b. Var init / carry-forward
         if self.ctx.var_members:
             lines.append("        if (!_var_initialized) {")
             for name, ptype, init_expr in self.ctx.var_members:
+                # Function-scoped ``var`` members are init'd once-per-variant
+                # on first call (see _emit_func_var_init_block), not here.
+                if name in getattr(self, "_func_local_var_names", ()):
+                    continue
                 safe = self._safe_name(name)
                 if name in self._array_vars:
                     for stmt in self.ctx.ast.body:
@@ -507,7 +725,9 @@ class TopLevelEmitter:
                 if name in self._array_vars:
                     continue
                 if name in self.ctx.series_vars:
-                    lines.append(f"            if (is_first_tick_) {safe}.push({safe}[0]);")
+                    self._emit_history_series_write(
+                        lines, "            ", safe, f"{safe}[0]"
+                    )
                     # Also carry-forward cloned copies for per-call-site function variants
                     carry_emitted: set[str] = set()
                     for (fname, cs_idx), remap in self._func_cs_var_remap.items():
@@ -517,7 +737,9 @@ class TopLevelEmitter:
                             cloned = remap[safe]
                             if cloned not in carry_emitted:
                                 carry_emitted.add(cloned)
-                                lines.append(f"            if (is_first_tick_) {cloned}.push({cloned}[0]);")
+                                self._emit_history_series_write(
+                                    lines, "            ", cloned, f"{cloned}[0]"
+                                )
             lines.append("        }")
 
         # c. Push non-var series (they start fresh each bar with a push)
@@ -545,6 +767,7 @@ class TopLevelEmitter:
                         default_cpp = self._visit_expr(default) if default is not None else "0"
                         title = self._get_input_title(stmt.value, var_name=stmt.name)
                         getter = self._input_type_to_getter(func_name_i, namespace_i)
+                        default_cpp = self._coerce_string_input_default(getter, default_cpp)
                         cpp_val = f'{getter}("{title}", {default_cpp})'
                         static_vars.append(f"{safe} = {cpp_val};")
 
@@ -709,11 +932,17 @@ class TopLevelEmitter:
         base = fi.node.name if fi.node else ""
         return self._func_safe_name(f"_udt_{udt}_{base}")
 
-    def _emit_func_def(self, fi: FuncInfo, lines: list[str], call_site_idx: int | None = None) -> None:
+    def _emit_func_def(self, fi: FuncInfo, lines: list[str], call_site_idx: int | None = None,
+                       instance: dict | None = None) -> None:
         """Emit a user-defined function as a class method.
 
         If call_site_idx is not None, emit a per-call-site variant with
         TA member names remapped to call-site-specific copies.
+
+        If ``instance`` is provided (a fresh context-sensitive instance minted by
+        ``_build_func_instances``), emit a uniquely-named clone whose TA/var
+        members come from the instance's composed remaps instead of the flat
+        ``_func_cs_*_remap`` tables.
         """
         node = fi.node
         if node is None:
@@ -724,12 +953,19 @@ class TopLevelEmitter:
         # Determine param types and set context for type inference inside body
         param_strs = []
         self._current_func_param_types = {}
+        self._current_func_param_specs = {}
         self._current_func_series_params = set()
         self._udt_param_udt = {}
         func_sv = self.ctx.func_series_vars.get(fi.name, set())
         for i, p in enumerate(node.params):
+            spec = None
             if is_udt and i == 0 and fi.udt_type_name:
-                cpp_t = f"{fi.udt_type_name}&"
+                # A method receiver whose type is a drawing primitive
+                # (egoigor's ``method slope(line ln)``) must emit ``Line&`` not
+                # the unknown ``line&``. Register _udt_param_udt so the body's
+                # getters dispatch through the §4.3 drawing path (L.6d / U.5).
+                recv_cpp = DRAWING_TYPE_TO_CPP.get(fi.udt_type_name, fi.udt_type_name)
+                cpp_t = f"{recv_cpp}&"
                 safe_p = self._safe_name(p)
                 self._udt_param_udt[safe_p] = fi.udt_type_name
                 self._udt_param_udt[p] = fi.udt_type_name
@@ -739,6 +975,24 @@ class TopLevelEmitter:
                 # This param uses history access (e.g. src[1]) — pass as Series
                 cpp_t = "const Series<double>&"
                 self._current_func_series_params.add(p)
+            elif i < len(getattr(fi, "param_type_specs", [])) and fi.param_type_specs[i] is not None:
+                # Precise per-param TypeSpec (declared hint or call-site inference):
+                # ``pivot hi`` -> ``pivot&``, ``line ln`` -> ``Line&``, an untyped
+                # ``s`` used as a string -> ``std::string``. UDT / collection
+                # params pass by reference (Pine UDTs/arrays are reference types,
+                # so mutations propagate and member access compiles).
+                spec = fi.param_type_specs[i]
+                cpp_t = self._type_spec_to_cpp(spec)
+                if spec.kind == "udt":
+                    self._udt_param_udt[p] = spec.name
+                    self._udt_param_udt[self._safe_name(p)] = spec.name
+                    cpp_t = f"{cpp_t}&"
+                elif spec.kind in ("array", "map"):
+                    elem = spec.element if spec.kind == "array" else spec.value
+                    if elem is not None and elem.kind == "udt":
+                        self._udt_param_udt[p] = elem.name
+                        self._udt_param_udt[self._safe_name(p)] = elem.name
+                    cpp_t = f"{cpp_t}&"
             elif i < len(fi.param_types):
                 pt = fi.param_types[i]
                 cpp_t = PINE_TYPE_TO_CPP.get(pt, "double")
@@ -746,6 +1000,9 @@ class TopLevelEmitter:
                 cpp_t = "double"
             param_strs.append(f"{cpp_t} {self._safe_name(p)}")
             self._current_func_param_types[p] = cpp_t
+            if spec is not None:
+                self._current_func_param_specs[p] = spec
+                self._current_func_param_specs[self._safe_name(p)] = spec
 
         # Determine return type: tuple, UDT, or scalar.
         # The UDT branch handles user functions whose body is ``T.new(...)``;
@@ -757,28 +1014,69 @@ class TopLevelEmitter:
             tuple_types_list = self._infer_tuple_types(node, fi.tuple_element_count)
             ret_type = f"std::tuple<{', '.join(tuple_types_list)}>"
         elif getattr(fi, "udt_return_type", None):
-            ret_type = fi.udt_return_type
+            # A function returning a drawing handle must emit the C++ handle
+            # struct (Line/Box/Label/Linefill), not the unknown lowercase name.
+            ret_type = DRAWING_TYPE_TO_CPP.get(fi.udt_return_type, fi.udt_return_type)
+        elif getattr(fi, "return_type_spec", None) is not None:
+            # Array-returning function (``f() => array.from(...)``) — emit the
+            # vector type from the inferred element TypeSpec.
+            ret_type = self._type_spec_to_cpp(fi.return_type_spec)
         else:
             ret_type = PINE_TYPE_TO_CPP.get(fi.return_type, "double")
 
         # For per-call-site variants, suffix the function name and activate TA + var remapping
         func_name = self._emit_udt_method_cpp_name(fi) if is_udt else self._func_safe_name(fi.name)
-        if call_site_idx is not None:
+        var_init_flag: str | None = None
+        if instance is not None:
+            # Fresh context-sensitive instance: name + composed remaps come from
+            # the instance record. No textual cs index (dispatch is via the
+            # instance map), but it IS a state-isolated variant.
+            func_name = instance["name"]
+            self._active_ta_remap = instance["ta_remap"]
+            self._active_var_remap = instance["var_remap"]
+            self._active_fixnan_remap = instance.get("fixnan_remap", {})
+            self._in_ta_func_variant = True
+            self._active_call_site_idx = None
+            self._current_instance_name = instance["name"]
+            var_init_flag = f"_fvinit_{instance['name']}"
+        elif call_site_idx is not None:
             func_name = f"{func_name}_cs{call_site_idx}"
             remap = self._func_cs_ta_remap.get((fi.name, call_site_idx), {})
             self._active_ta_remap = remap
             var_remap = self._func_cs_var_remap.get((fi.name, call_site_idx), {})
             self._active_var_remap = var_remap
+            self._active_fixnan_remap = self._func_cs_fixnan_remap.get((fi.name, call_site_idx), {})
             self._in_ta_func_variant = True
             self._active_call_site_idx = call_site_idx
+            # Use the actual emitted name. Plain UDFs are unchanged; UDT
+            # methods carry their `_udt_Type_method` prefix. This identity is
+            # shared with _build_func_instances and synthetic-history member
+            # registration, so method call paths can dispatch independently.
+            self._current_instance_name = func_name
         else:
             self._active_ta_remap = {}
             self._active_var_remap = {}
+            self._active_fixnan_remap = {}
             self._in_ta_func_variant = False
             self._active_call_site_idx = None
+            self._current_instance_name = None
 
         prev_func_locals = self._current_func_locals
+        prev_func_local_types = self._current_func_local_types
+        prev_func_body = getattr(self, "_current_func_body", None)
+        prev_func_name = getattr(self, "_active_func_name", None)
+        # The function body is the lexical scope used by the UDT-alias analysis
+        # (BUG C): a local initialised from a var/global UDT lvalue and later
+        # mutated through must alias, not value-copy.
+        self._current_func_body = node.body
+        self._active_func_name = fi.name
+        # Pointer-aliased UDT locals are function-scoped: a name like ``p_ivot``
+        # may be a rebinding pointer alias in one function and a ``pivot&``
+        # parameter in another, so reset per function to avoid cross-contamination.
+        prev_ptr_alias = self._udt_ptr_alias_locals
+        self._udt_ptr_alias_locals = set()
         self._current_func_locals = {n for n, _, _ in self.ctx.func_var_members.get(fi.name, [])}
+        self._current_func_local_types = {}
         # Plain (non-persistent) scalar locals are emitted inline and live in
         # no other set; collect them so the unknown-identifier guard in
         # _visit_ident does not mistake them for undeclared symbols.
@@ -786,24 +1084,47 @@ class TopLevelEmitter:
 
         lines.append(f"    {ret_type} {func_name}({', '.join(param_strs)}) {{")
 
+        # Function-scoped ``var`` one-shot initializer: Pine ``var`` inside a
+        # function is a function-local static — its initializer runs exactly
+        # once, on the first call to THIS variant, with the first bar's values
+        # the function actually sees. Each clone (cs0/cs1/…) is independent.
+        self._emit_func_var_init_block(fi, call_site_idx, lines, flag_override=var_init_flag)
+
         emitted_return = False
         if node.is_single_expr and node.body:
             expr = node.body[0].expr if isinstance(node.body[0], ExprStmt) else None
-            if expr:
+            if expr and self._call_is_void(expr):
+                # void setter as the sole body expr — emit as statement, fall
+                # through to the default return.
+                self._visit_stmt(node.body[0], lines, indent=2)
+            elif expr:
                 lines.append(f"        return {self._visit_expr(expr)};")
                 emitted_return = True
         else:
             for i, s in enumerate(node.body):
                 if i == len(node.body) - 1 and isinstance(s, ExprStmt):
-                    lines.append(f"        return {self._visit_expr(s.expr)};")
-                    emitted_return = True
+                    # A void drawing setter / delete / visual-noop, or a dropped
+                    # table/polyline method call (``panel.cell(...)``), used as
+                    # the last statement cannot be the return value (it lowers to
+                    # a void / no-op C++ call). Emit it as a plain statement
+                    # (which ``_is_skip_expr`` drops) and let the default-return
+                    # path below supply the function's result.
+                    if self._call_is_void(s.expr) or self._is_skip_expr(s.expr):
+                        self._visit_stmt(s, lines, indent=2)
+                    else:
+                        lines.append(f"        return {self._visit_expr(s.expr)};")
+                        emitted_return = True
                 elif i == len(node.body) - 1 and isinstance(s, (SwitchStmt, IfStmt)):
                     # Switch/if as last statement = return expression in PineScript
                     # Emit as: double _ret = 0; if/switch assigns _ret; return _ret;
-                    default_ret = (
-                        f"{ret_type}{{}}" if ret_type in self._udt_defs
-                        else self._default_for_type(ret_type)
-                    )
+                    # A drawing-handle / UDT return type must brace-init its
+                    # default (``Label _func_ret = Label{};``) — falling through
+                    # to ``_default_for_type`` would emit ``0.0`` and clang would
+                    # reject ``Label _func_ret = 0.0;``.
+                    if ret_type in self._udt_defs or ret_type in DRAWING_TYPE_TO_CPP.values():
+                        default_ret = f"{ret_type}{{}}"
+                    else:
+                        default_ret = self._default_for_type(ret_type)
                     lines.append(f"        {ret_type} _func_ret = {default_ret};")
                     self._visit_if_switch_expr(s, "_func_ret", lines, indent=2)
                     lines.append(f"        return _func_ret;")
@@ -818,41 +1139,130 @@ class TopLevelEmitter:
                 default_vals = ", ".join(["0.0"] * fi.tuple_element_count)
                 lines.append(f"        return std::make_tuple({default_vals});")
             else:
-                default_ret = (
-                    f"{ret_type}{{}}" if ret_type in self._udt_defs
-                    else self._default_for_type(ret_type)
-                )
+                if ret_type in self._udt_defs or ret_type in DRAWING_TYPE_TO_CPP.values():
+                    default_ret = f"{ret_type}{{}}"
+                else:
+                    default_ret = self._default_for_type(ret_type)
                 lines.append(f"        return {default_ret};")
 
         lines.append("    }")
         self._current_func_param_types = {}
+        self._current_func_param_specs = {}
         self._current_func_series_params = set()
         self._udt_param_udt = {}
         self._current_func_locals = prev_func_locals
+        self._current_func_local_types = prev_func_local_types
+        self._current_func_body = prev_func_body
+        self._active_func_name = prev_func_name
+        self._udt_ptr_alias_locals = prev_ptr_alias
         self._active_ta_remap = {}
         self._active_var_remap = {}
+        self._active_fixnan_remap = {}
         self._in_ta_func_variant = False
         self._active_call_site_idx = None
+        self._current_instance_name = None
+
+    def _func_var_init_flag_name(self, fname: str, call_site_idx: int | None) -> str:
+        suffix = f"_cs{call_site_idx}" if call_site_idx is not None else ""
+        return f"_fvinit_{self._func_safe_name(fname)}{suffix}"
+
+    def _emit_func_var_init_block(self, fi: FuncInfo, call_site_idx: int | None,
+                                  lines: list[str], flag_override: str | None = None) -> None:
+        """Emit the one-shot initializer block for a function's ``var`` members.
+
+        Pine ``var`` declared inside a function is a function-local static:
+        the initializer runs exactly once on the FIRST call to this variant
+        (using the first bar's values the function actually sees) and the
+        result persists for the strategy's lifetime. Each per-call-site clone
+        is an independent instance with its own flag and its own set of
+        (remapped) members.
+
+        This closes the gap where a function-scoped ``var line x = line.new(...)``
+        (or any non-compile-time initializer — drawing handles, UDT ctors,
+        arrays, runtime expressions) was declared as a default-constructed
+        class member but its initializer was dropped, leaving the member ``na``
+        / uninitialised and causing "drawing access on na handle" at runtime.
+        """
+        members = self.ctx.func_var_members.get(fi.name)
+        if not members:
+            return
+        flag = flag_override or self._func_var_init_flag_name(fi.name, call_site_idx)
+        # ``_active_var_remap`` is already set for this variant by the caller,
+        # so lowering each init expression here correctly resolves references
+        # to sibling var members (which are themselves remapped for clones).
+        init_lines: list[str] = []
+        for name, ptype, _init_str in members:
+            init_ast = self.ctx.var_member_init_exprs.get(name)
+            safe = self._safe_name(name)
+            target = self._active_var_remap.get(safe, safe)
+            if name in self.ctx.series_vars:
+                if init_ast is None:
+                    continue
+                init_cpp = self._visit_expr(init_ast)
+                init_cpp = self._typed_na_init(init_cpp, name, ptype)
+                init_lines.append(f"        {target}.push({init_cpp});")
+                continue
+            if init_ast is None:
+                # No initializer to lower (e.g. bare ``var box b``); leave the
+                # member at its default-constructed value.
+                continue
+            # Skip a plain ``na`` initializer for drawing handles / UDTs whose
+            # default-constructed member is already the na sentinel; assigning
+            # ``na<double>()`` would not type-match the handle / struct.
+            udt_t = self._udt_var_types.get(name)
+            is_drawing = udt_t in DRAWING_TYPE_TO_CPP if udt_t else False
+            is_udt = udt_t in self._udt_defs if udt_t else False
+            from ..ast_nodes import NaLiteral
+            if (is_drawing or is_udt) and isinstance(init_ast, NaLiteral):
+                continue
+            init_cpp = self._visit_expr(init_ast)
+            init_lines.append(f"        {target} = {init_cpp};")
+        if not init_lines:
+            return
+        lines.append(f"        if (!{flag}) {{")
+        lines.extend(init_lines)
+        lines.append(f"            {flag} = true;")
+        lines.append("        }")
 
     def _emit_precalculate_and_run(self, lines: list[str]) -> None:
-        has_static_ta = any(getattr(site, "is_static", False) for site in self.ctx.ta_call_sites)
+        has_static_ta = any(
+            self._ta_site_uses_precalc(site)
+            for _ti, site in enumerate(self.ctx.ta_call_sites)
+            if _ti not in self._dead_ta_indices
+        )
         if not has_static_ta:
             return
 
+        replayed_source_series: list[str] = []
+        for stmt in self.ctx.ast.body:
+            if not isinstance(stmt, VarDecl):
+                continue
+            if stmt.name not in self._global_member_vars:
+                continue
+            if not (isinstance(stmt.value, FuncCall) and self._is_source_input(stmt.value)):
+                continue
+            if stmt.name in self.ctx.series_vars:
+                replayed_source_series.append(self._safe_name(stmt.name))
+        replayed_source_series = sorted(set(replayed_source_series))
+
         lines.append("    void precalculate(const Bar* bars, int n) {")
         lines.append("        _use_precalc = false;")
         lines.append("        if (n <= 0 || bars == nullptr) return;")
         lines.append("")
 
         # Resize precalculated vectors
-        for site in self.ctx.ta_call_sites:
-            if getattr(site, "is_static", False):
+        for _ti, site in enumerate(self.ctx.ta_call_sites):
+            if _ti in self._dead_ta_indices:
+                continue
+            if self._ta_site_uses_precalc(site):
                 lines.append(f"        _precalc_{site.member_name}.resize(n);")
 
         # Reset indicators to clean slate
         lines.append("")
-        for site in self.ctx.ta_call_sites:
-            if getattr(site, "is_static", False):
+        for _ti, site in enumerate(self.ctx.ta_call_sites):
+            if _ti in self._dead_ta_indices:
+                continue
+            if self._ta_site_uses_precalc(site):
                 resolved = [self._resolve_known(a) for a in site.ctor_args]
                 safe_resolved = []
                 for r in resolved:
@@ -863,6 +1273,13 @@ class TopLevelEmitter:
         lines.append("")
         for field_name in sorted(self.ctx.series_bar_fields):
             lines.append(f"        _s_{field_name}.clear();")
+        for safe in replayed_source_series:
+            lines.append(f"        {safe}.clear();")
+        if self._script_has_input_source():
+            lines.append("        _src_open_.clear(); _src_high_.clear(); _src_low_.clear();")
+            lines.append("        _src_close_.clear(); _src_volume_.clear();")
+            lines.append("        _src_hl2_.clear(); _src_hlc3_.clear();")
+            lines.append("        _src_ohlc4_.clear(); _src_hlcc4_.clear();")
 
         # Start precalculation loop
         lines.append("")
@@ -874,11 +1291,76 @@ class TopLevelEmitter:
             push_expr_bars = push_expr.replace("current_bar_.", "bars[i].")
             lines.append(f"            _s_{field_name}.push({push_expr_bars});")
 
+        # Advance the native input.source() backing series (_src_open_ etc.)
+        # from bars[i] too. A static TA site's compute args can reference an
+        # input.source()-derived member (e.g. ``ta.stdev(bbSourceInput, 20)``)
+        # which resolves at runtime to ``get_input_source(...)`` reading one
+        # of these series — normally advanced once per real bar by
+        # ``_push_source_series()`` inside ``dispatch_bar()``, which this
+        # standalone precalc loop never calls. Without this, every static TA
+        # site fed by an input.source() reads an empty series (0.0) for the
+        # entire precalculation, silently corrupting its precalculated
+        # values (e.g. a Bollinger Band's stdev collapsing to 0). Gated on
+        # ``_src_series_active_`` to stay a no-op for scripts with no
+        # input.source() usage; cleared before and after the precalc pass so
+        # replayed source history cannot leak into the real run.
+        lines.append("            if (_src_series_active_) {")
+        lines.append("                const double _pc_o = bars[i].open;")
+        lines.append("                const double _pc_h = bars[i].high;")
+        lines.append("                const double _pc_l = bars[i].low;")
+        lines.append("                const double _pc_c = bars[i].close;")
+        lines.append("                const double _pc_v = bars[i].volume;")
+        lines.append("                _src_open_.push(_pc_o);   _src_high_.push(_pc_h);   _src_low_.push(_pc_l);")
+        lines.append("                _src_close_.push(_pc_c);  _src_volume_.push(_pc_v);")
+        lines.append("                _src_hl2_.push((_pc_h + _pc_l) / 2.0);")
+        lines.append("                _src_hlc3_.push((_pc_h + _pc_l + _pc_c) / 3.0);")
+        lines.append("                _src_ohlc4_.push((_pc_o + _pc_h + _pc_l + _pc_c) / 4.0);")
+        lines.append("                _src_hlcc4_.push((_pc_h + _pc_l + _pc_c + _pc_c) / 4.0);")
+        lines.append("            }")
+
+        # Replay every top-level ``X = input.source(...)`` (or bare
+        # ``X = input(close)``) assignment. A static TA site's compute args
+        # often don't reference ``get_input_source(...)`` inline — they
+        # reference the top-level variable the script bound it to (e.g.
+        # ``bbSourceInput = input.source(close, "BB Source")`` then
+        # ``ta.stdev(bbSourceInput, 20)``). That variable is deliberately
+        # NOT covered by the ``_inputs_initialized_`` once-only static-input
+        # block above (see ``is_static_global_input``'s ``_is_source_input``
+        # exclusion) because it tracks a live per-bar series, not a frozen
+        # config value — under normal per-bar dispatch it is reassigned every
+        # real bar. This precalc loop has no other path that reassigns it, so
+        # without this replay every is_static site downstream of it would
+        # keep reading its ctor-initialized 0.0 for the whole precalculation
+        # even with the ``_src_*_`` fix above.
+        for stmt in self.ctx.ast.body:
+            if not isinstance(stmt, VarDecl):
+                continue
+            if stmt.name not in self._global_member_vars:
+                continue
+            if not (isinstance(stmt.value, FuncCall) and self._is_source_input(stmt.value)):
+                continue
+            safe = self._safe_name(stmt.name)
+            default = self._get_input_default(stmt.value)
+            base = self._source_defval_to_base_series(default)
+            title = self._get_input_title(stmt.value, var_name=stmt.name)
+            cpp_val = f'get_input_source("{title}", {base})[0]'
+            # A source var subscripted elsewhere in the script (e.g. ``src[1]``)
+            # is declared ``Series<double>``, not a scalar double, mirroring
+            # the normal per-bar path's ``{safe}.push({cpp_val})`` (see
+            # ``_visit_var_decl``'s ``node.name in self.ctx.series_vars``
+            # branch) — a plain ``=`` there is a compile error.
+            if stmt.name in self.ctx.series_vars:
+                lines.append(f'            {safe}.push({cpp_val});')
+            else:
+                lines.append(f'            {safe} = {cpp_val};')
+
         # Set _precalc_loop_active = True
         self._precalc_loop_active = True
         try:
-            for site in self.ctx.ta_call_sites:
-                if getattr(site, "is_static", False):
+            for _ti, site in enumerate(self.ctx.ta_call_sites):
+                if _ti in self._dead_ta_indices:
+                    continue
+                if self._ta_site_uses_precalc(site):
                     compute_args = self._ta_compute_args_for_site(site)
                     compute_args_bars = compute_args.replace("current_bar_.", "bars[i].")
                     lines.append(f"            _precalc_{site.member_name}[i] = {site.member_name}.compute({compute_args_bars});")
@@ -889,8 +1371,10 @@ class TopLevelEmitter:
 
         # Reset indicators and series for the real backtest run
         lines.append("")
-        for site in self.ctx.ta_call_sites:
-            if getattr(site, "is_static", False):
+        for _ti, site in enumerate(self.ctx.ta_call_sites):
+            if _ti in self._dead_ta_indices:
+                continue
+            if self._ta_site_uses_precalc(site):
                 resolved = [self._resolve_known(a) for a in site.ctor_args]
                 safe_resolved = []
                 for r in resolved:
@@ -899,6 +1383,13 @@ class TopLevelEmitter:
 
         for field_name in sorted(self.ctx.series_bar_fields):
             lines.append(f"        _s_{field_name}.clear();")
+        for safe in replayed_source_series:
+            lines.append(f"        {safe}.clear();")
+        if self._script_has_input_source():
+            lines.append("        _src_open_.clear(); _src_high_.clear(); _src_low_.clear();")
+            lines.append("        _src_close_.clear(); _src_volume_.clear();")
+            lines.append("        _src_hl2_.clear(); _src_hlc3_.clear();")
+            lines.append("        _src_ohlc4_.clear(); _src_hlcc4_.clear();")
 
         lines.append("")
         lines.append("        _use_precalc = true;")