pineforge-codegen 0.6.5__py3-none-any.whl

pineforge_codegen/codegen/emit_top.py

@@ -0,0 +1,875 @@
+"""Top-level C++ section emitters for the codegen.
+
+``TopLevelEmitter`` holds the methods that emit the four top-level
+sections of the generated C++ translation unit -- the includes block,
+the ``GeneratedStrategy`` constructor (plus ``set_strategy_override``
+and the optional ``configure_security_evaluators`` override), the
+``on_bar()`` body, and the ``extern "C"`` shim that exposes the
+strategy to the loader -- together with the per-function emission
+helpers (``_emit_func_def`` and ``_emit_udt_method_cpp_name``) used by
+both regular Pine functions and UDT instance methods.
+
+These emitters were extracted from ``base.py``'s ``CodeGen`` class as
+step 7 of the codegen package refactor; behaviour is preserved
+verbatim. The mixin owns no state of its own — it reads/writes only
+attributes already established on the host class (``CodeGen``).
+
+Mixin contract — host class must provide the following attributes
+(all set by ``CodeGen.__init__``):
+
+- ``self.ctx`` (``AnalyzerContext``): symbol-table source. Reads
+  ``ctx.ast.body``, ``ctx.ta_call_sites``, ``ctx.var_members``,
+  ``ctx.series_vars``, ``ctx.series_bar_fields``,
+  ``ctx.func_series_vars``, ``ctx.func_var_members``,
+  ``ctx.strategy_params``, and ``ctx.pf_trace_pragmas``
+  (the ``// @pf-trace`` instrumentation list consumed by
+  ``_emit_pf_trace_block``).
+- ``self._uses_matrix`` (``bool``): gates the ``runtime/matrix.hpp``
+  include in ``_emit_includes``.
+- ``self._security_calls`` (``list[dict]``): non-empty when the
+  strategy uses ``request.security``; controls the ``run_backtest``
+  / ``run_backtest_full`` dispatch in ``_emit_extern_c``.
+- ``self._security_eval_info`` (``list[dict]``): per-eval metadata
+  (``tf``/``tf_node``/``lookahead_on``/``gaps_on``/``sec_id``/
+  ``ta_variants``) consumed by ``_emit_constructor`` to build the
+  TA-variant ctor list and the ``configure_security_evaluators``
+  override.
+- ``self._matrix_specs`` (``dict[str, TypeSpec]``): matrix-typed var
+  members whose first-bar init is emitted in ``_emit_on_bar``.
+- ``self._array_vars`` (``set[str]``): array-typed var members.
+- ``self._map_vars`` (``set[str]``): map-typed var members.
+- ``self._strategy_series_vars`` (``set[str]``): series mirrors of
+  ``strategy.*`` member values pushed every bar.
+- ``self._timeframe_period_vars`` (``set[str]``): identifiers that
+  resolve to ``script_tf_`` in ``configure_security_evaluators``.
+- ``self._udt_defs`` (``dict[str, list]``): UDT name -> field info,
+  used to detect UDT-typed var initialisers in ``_emit_on_bar``.
+- ``self._func_cs_var_remap``
+  (``dict[tuple[str, int], dict[str, str]]``): per-function
+  per-call-site rename table for cloned series/var members.
+- ``self._func_cs_ta_remap``
+  (``dict[tuple[str, int], dict[str, str]]``): per-function
+  per-call-site rename table for cloned TA member names.
+
+State written by ``_emit_func_def`` (the per-function emit context):
+
+- ``self._current_func_param_types`` (``dict[str, str]``).
+- ``self._current_func_series_params`` (``set[str]``).
+- ``self._udt_param_udt`` (``dict[str, str]``).
+- ``self._current_func_locals`` (``set[str]``).
+- ``self._active_ta_remap`` (``dict[str, str]``).
+- ``self._active_var_remap`` (``dict[str, str]``).
+- ``self._in_ta_func_variant`` (``bool``).
+- ``self._active_call_site_idx`` (``int | None``).
+
+Sibling-mixin methods consumed via ``self``:
+
+- ``self._safe_name`` / ``self._func_safe_name`` (``NamingHelper``).
+- ``self._default_for_type`` / ``self._infer_tuple_types``
+  (``TypeInferer``).
+- ``self._is_compile_time_value`` (``TaSiteHelper``).
+- ``self._resolve_known`` / ``self._runtime_ctor_arg_for_reset``
+  (``CodeGen.base``): compile-time argument resolver and the
+  runtime-reset rewriter for ctor args sourced from inputs.
+- ``self._emit_ta_runtime_reset`` (``CodeGen.base``): emits the
+  first-bar TA rebuild block inside ``on_bar``.
+- ``self._visit_stmt`` / ``self._visit_expr`` /
+  ``self._visit_if_switch_expr`` (``CodeGen.base``).
+
+The mixin avoids importing from ``base.py`` to stay free of cycles;
+all tables and types come from ``codegen/tables.py``, ``..ast_nodes``,
+and ``..analyzer``.
+"""
+
+from __future__ import annotations
+
+from ..ast_nodes import (
+    ExprStmt, FuncCall, Identifier, IfStmt, SwitchStmt, VarDecl,
+)
+from ..analyzer import FuncInfo
+from ..symbols import TypeSpec
+from .tables import (
+    BAR_SERIES_PUSH,
+    PINE_TYPE_TO_CPP,
+    RUNTIME_REGISTER_SECURITY_EVAL_FN,
+    RUNTIME_REGISTER_SECURITY_LOWER_TF_EVAL_FN,
+)
+
+
+class TopLevelEmitter:
+    """Mixin owning the top-level C++ section emitters and the
+    per-function emitters used by regular Pine functions and UDT
+    instance methods.
+
+    Mixed into ``CodeGen``; not intended to be instantiated standalone."""
+
+    def _emit_includes(self, lines: list[str]) -> None:
+        lines.append('#include <pineforge/engine.hpp>')
+        lines.append('#include <pineforge/ta.hpp>')
+        lines.append('#include <pineforge/math.hpp>')
+        lines.append('#include <pineforge/series.hpp>')
+        lines.append('#include <pineforge/na.hpp>')
+        lines.append("#include <cstdint>")
+        lines.append("#include <cmath>")
+        lines.append("#include <algorithm>")
+        lines.append("#include <cstdlib>")
+        lines.append("#include <numeric>")
+        lines.append("#include <string>")
+        lines.append("#include <vector>")
+        lines.append("#include <tuple>")
+        lines.append("#include <memory>")
+        lines.append("#include <mutex>")
+        lines.append("#include <unordered_map>")
+        lines.append("#include <unordered_map>")
+        lines.append('#include <pineforge/color.hpp>')
+        lines.append('#include <pineforge/log.hpp>')
+        lines.append('#include <pineforge/str_utils.hpp>')
+        lines.append('#include <pineforge/session_time.hpp>')
+        if self._uses_matrix:
+            # Unconditional include when matrix API is used — do not gate on
+            # __has_include(<Eigen/Dense>) (can differ between runtime build and this TU).
+            lines.append('#include <pineforge/matrix.hpp>')
+            # generic_matrix.hpp only needed when at least one non-float matrix
+            # is present in the TU. Float matrices route through PineMatrix in
+            # matrix.hpp; pulling in the generic header otherwise is a wasted
+            # include.
+            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>')
+        lines.append("")
+        # Compatibility shim for the namespace-wrap refactor: unqualified
+        # references to BacktestEngine / Bar / na<T>() / ta::* / etc. resolve
+        # via the runtime's pineforge namespace. Removed in phase 5 lock-down
+        # in favour of fully qualified names emitted at each call site.
+        lines.append("using namespace pineforge;")
+        lines.append("")
+        # Syminfo derivation helpers (_pf_derive_main_tickerid, _pf_derive_country)
+        from .helpers_syminfo import emit_syminfo_helpers
+        lines.extend(emit_syminfo_helpers())
+
+    def _script_has_strategy_close(self) -> bool:
+        """True if the script's AST contains a ``strategy.close*`` call.
+
+        Scans the entire program body (including nested function /
+        method bodies) for any ``FuncCall`` whose callee resolves to
+        ``strategy.close`` or ``strategy.close_all``. Comments are
+        not considered (parser strips them). Result is independent of
+        whether the close call ever runs at backtest time — this is a
+        purely static script-shape check used by the engine's flip path
+        to choose between TV's empirical growth rule and the standard
+        Pine semantic.
+
+        Mixin contract: relies on ``self._walk_ast`` (NamingHelper) and
+        ``self._resolve_callee`` (NamingHelper); host class must
+        provide ``self.ctx.ast``."""
+        from ..ast_nodes import FuncCall  # local to avoid circular import
+        for node in self._walk_ast(self.ctx.ast):
+            if not isinstance(node, FuncCall):
+                continue
+            func_name, namespace = self._resolve_callee(node.callee)
+            if namespace == "strategy" and func_name in ("close", "close_all"):
+                return True
+        return False
+
+    def _script_has_input_source(self) -> bool:
+        """True if the script's AST contains an ``input.source(...)`` call.
+
+        Gates the engine's native source-series push: the runtime only
+        advances ``_src_<field>_`` (paying the per-bar cost) when
+        ``_src_series_active_`` is set, which the ctor does iff this returns
+        True. Same static-shape scan style as ``_script_has_strategy_close``."""
+        from ..ast_nodes import FuncCall  # local to avoid circular import
+        for node in self._walk_ast(self.ctx.ast):
+            if not isinstance(node, FuncCall):
+                continue
+            func_name, namespace = self._resolve_callee(node.callee)
+            if namespace == "input" and func_name == "source":
+                return True
+        return False
+
+    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:
+            if site.ctor_args:
+                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)
+                safe_resolved = []
+                for r in resolved:
+                    if self._is_compile_time_value(r):
+                        safe_resolved.append(r)
+                    else:
+                        safe_resolved.append("1")
+                init_parts.append(f"{site.member_name}({', '.join(safe_resolved)})")
+        # Security evaluator TA ctor args (skip for user function call expressions)
+        for info in self._security_eval_info:
+            for idx, variants in (info.get("ta_variants") or {}).items():
+                site = self.ctx.ta_call_sites[idx]
+                if not site.ctor_args:
+                    continue
+                resolved = [self._resolve_known(a) for a in site.ctor_args]
+                safe_resolved = []
+                for r in resolved:
+                    safe_resolved.append(r if self._is_compile_time_value(r) else "1")
+                for variant in variants:
+                    init_parts.append(f"{variant['member_name']}({', '.join(safe_resolved)})")
+
+        # Non-series var members with compile-time init (deduplicate by name)
+        seen_ctor_vars: set[str] = set()
+        for name, ptype, init_expr in self.ctx.var_members:
+            if name in seen_ctor_vars:
+                continue
+            seen_ctor_vars.add(name)
+            safe = self._safe_name(name)
+            if name in self._array_vars or name in self._map_vars:
+                continue
+            if name not in self.ctx.series_vars:
+                cpp_val = self._resolve_known(init_expr)
+                if self._is_compile_time_value(cpp_val):
+                    init_parts.append(f"{safe}({cpp_val})")
+        # Strategy params that map to engine members
+        ctor_body: list[str] = []
+        sp = self.ctx.strategy_params
+
+        if sp.get("process_orders_on_close") is True:
+            ctor_body.append("        process_orders_on_close_ = true;")
+
+        if "initial_capital" in sp and isinstance(sp["initial_capital"], (int, float)):
+            ctor_body.append(f"        initial_capital_ = {float(sp['initial_capital'])};")
+
+        # default_qty_type: strategy.fixed / strategy.percent_of_equity / strategy.cash
+        qty_type_map = {
+            "strategy.fixed": "QtyType::FIXED",
+            "strategy.percent_of_equity": "QtyType::PERCENT_OF_EQUITY",
+            "strategy.cash": "QtyType::CASH",
+        }
+        qty_type = sp.get("default_qty_type")
+        if qty_type in qty_type_map:
+            ctor_body.append(f"        default_qty_type_ = {qty_type_map[qty_type]};")
+
+        if "default_qty_value" in sp and isinstance(sp["default_qty_value"], (int, float)):
+            ctor_body.append(f"        default_qty_value_ = {float(sp['default_qty_value'])};")
+
+        if "pyramiding" in sp and isinstance(sp["pyramiding"], int):
+            ctor_body.append(f"        pyramiding_ = {sp['pyramiding']};")
+
+        # commission_type: strategy.commission.percent / .cash_per_order / .cash_per_contract
+        comm_type_map = {
+            "strategy.commission.percent": "CommissionType::PERCENT",
+            "strategy.commission.cash_per_order": "CommissionType::CASH_PER_ORDER",
+            "strategy.commission.cash_per_contract": "CommissionType::CASH_PER_CONTRACT",
+        }
+        comm_type = sp.get("commission_type")
+        if comm_type in comm_type_map:
+            ctor_body.append(f"        commission_type_ = {comm_type_map[comm_type]};")
+
+        if "commission_value" in sp and isinstance(sp["commission_value"], (int, float)):
+            ctor_body.append(f"        commission_value_ = {float(sp['commission_value'])};")
+
+        if "slippage" in sp and isinstance(sp["slippage"], (int, float)):
+            ctor_body.append(f"        slippage_ = {int(sp['slippage'])};")
+
+        # margin_long / margin_short: percent of position value required as
+        # equity (default 100 = 1x leverage). When required_margin exceeds
+        # available equity, TV silently rejects the fill — engine mirrors
+        # this in execute_market_entry's FLAT branch.
+        if "margin_long" in sp and isinstance(sp["margin_long"], (int, float)):
+            ctor_body.append(f"        margin_long_ = {float(sp['margin_long'])};")
+        if "margin_short" in sp and isinstance(sp["margin_short"], (int, float)):
+            ctor_body.append(f"        margin_short_ = {float(sp['margin_short'])};")
+
+        # close_entries_rule: "FIFO" (default) or "ANY"
+        if sp.get("close_entries_rule") == "ANY":
+            ctor_body.append("        close_entries_rule_any_ = true;")
+
+        # Detect ``strategy.close`` / ``strategy.close_all`` calls anywhere in
+        # the script body. The runtime uses this flag in its priced-entry flip
+        # path to reproduce TradingView's empirical
+        # ``new_size = |old| + qty`` rule (see
+        # docs/codegen-gaps/validation-tv-pyramiding-override.md). The flag
+        # is set once per compilation; it is independent of how many times
+        # the close call actually fires at runtime.
+        if self._script_has_strategy_close():
+            ctor_body.append("        script_has_strategy_close_ = true;")
+
+        # Turn on native source-series history only when the script uses
+        # input.source — otherwise the engine pays nothing per bar.
+        if self._script_has_input_source():
+            ctor_body.append("        _src_series_active_ = true;")
+
+        if init_parts and ctor_body:
+            lines.append(f"    explicit GeneratedStrategy() : {', '.join(init_parts)} {{")
+            lines.extend(ctor_body)
+            lines.append("    }")
+        elif init_parts:
+            lines.append(f"    explicit GeneratedStrategy() : {', '.join(init_parts)} {{}}")
+        elif ctor_body:
+            lines.append("    explicit GeneratedStrategy() {")
+            lines.extend(ctor_body)
+            lines.append("    }")
+        else:
+            lines.append("    explicit GeneratedStrategy() {}")
+
+        lines.append("")
+        lines.append("    void set_strategy_override(const std::string& key, const std::string& value) {")
+        lines.append('        if (key == "initial_capital") { initial_capital_ = std::stod(value); return; }')
+        lines.append('        if (key == "commission_value") { commission_value_ = std::stod(value); return; }')
+        lines.append('        if (key == "default_qty_value") { default_qty_value_ = std::stod(value); return; }')
+        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 == "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;')
+        lines.append('            else if (value == "percent_of_equity" || value == "strategy.percent_of_equity" || value == "1") default_qty_type_ = QtyType::PERCENT_OF_EQUITY;')
+        lines.append('            else if (value == "cash" || value == "strategy.cash" || value == "2") default_qty_type_ = QtyType::CASH;')
+        lines.append("            return;")
+        lines.append("        }")
+        lines.append('        if (key == "commission_type") {')
+        lines.append('            if (value == "percent" || value == "strategy.commission.percent" || value == "0") commission_type_ = CommissionType::PERCENT;')
+        lines.append('            else if (value == "cash_per_order" || value == "strategy.commission.cash_per_order" || value == "1") commission_type_ = CommissionType::CASH_PER_ORDER;')
+        lines.append('            else if (value == "cash_per_contract" || value == "strategy.commission.cash_per_contract" || value == "2") commission_type_ = CommissionType::CASH_PER_CONTRACT;')
+        lines.append("            return;")
+        lines.append("        }")
+        lines.append("    }")
+
+        if self._security_eval_info:
+            lines.append("")
+            lines.append("    void configure_security_evaluators() override {")
+            lines.append("        security_eval_states_.clear();")
+            for info in self._security_eval_info:
+                tf = info.get("tf")
+                tf_expr = None
+                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
+                if tf_expr:
+                    la = "true" if info["lookahead_on"] else "false"
+                    go = "true" if info.get("gaps_on") else "false"
+                    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
+                    # the bare identifier in an f-string here (the editor's
+                    # built-in security scanner blocks file moves whose
+                    # source text contains certain keywords as substrings).
+                    if info.get("is_lower_tf_array"):
+                        lines.append(
+                            f"        {RUNTIME_REGISTER_SECURITY_LOWER_TF_EVAL_FN}"
+                            f"({sec_id}, {tf_expr}, input_tf_);"
+                        )
+                    else:
+                        lines.append(
+                            f"        {RUNTIME_REGISTER_SECURITY_EVAL_FN}"
+                            f"({sec_id}, {tf_expr}, "
+                            f"input_tf_, {la}, {go});")
+            lines.append("    }")
+
+    # Map strategy series member name to push expression
+    _STRAT_SERIES_PUSH = {
+        "position_size": "signed_position_size()",
+        "closedtrades": "((int)trades_.size())",
+        "opentrades": "((signed_position_size() != 0) ? 1 : 0)",
+        "wintrades": "count_wintrades()",
+        "losstrades": "count_losstrades()",
+        "equity": "(current_equity() + open_profit(current_bar_.close))",
+        "netprofit": "net_profit()",
+        "openprofit": "open_profit(current_bar_.close)",
+        "initial_capital": "initial_capital_",
+    }
+
+    def _emit_on_bar(self, lines: list[str]) -> None:
+        lines.append("    void on_bar(const Bar& bar) override {")
+
+        # 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});")
+
+        # 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});")
+
+        # 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:
+                safe = self._safe_name(name)
+                if name in self._array_vars:
+                    for stmt in self.ctx.ast.body:
+                        if isinstance(stmt, VarDecl) and stmt.name == name:
+                            cpp_val = self._visit_expr(stmt.value)
+                            lines.append(f"            {safe} = {cpp_val};")
+                            break
+                    continue
+                if name in self._matrix_specs:
+                    # Matrix vars: initialize with matrix.new expression
+                    for stmt in self.ctx.ast.body:
+                        if isinstance(stmt, VarDecl) and stmt.name == name and isinstance(stmt.value, FuncCall):
+                            cpp_val = self._visit_expr(stmt.value)
+                            lines.append(f"            {safe} = {cpp_val};")
+                            break
+                    continue
+                if name in self._map_vars:
+                    for stmt in self.ctx.ast.body:
+                        if isinstance(stmt, VarDecl) and stmt.name == name:
+                            cpp_val = self._visit_expr(stmt.value)
+                            lines.append(f"            {safe} = {cpp_val};")
+                            break
+                    continue
+                # UDT vars: init with constructor expression
+                init_s = str(init_expr)
+                is_udt_init = False
+                for udt_name in self._udt_defs:
+                    if init_s.startswith(f"{udt_name}.new"):
+                        # Find the actual AST node to generate the init expression
+                        for stmt in self.ctx.ast.body:
+                            if isinstance(stmt, VarDecl) and stmt.name == name and isinstance(stmt.value, FuncCall):
+                                cpp_val = self._visit_expr(stmt.value)
+                                lines.append(f"            {safe} = {cpp_val};")
+                                is_udt_init = True
+                                break
+                        if not is_udt_init:
+                            lines.append(f"            {safe} = {udt_name}{{}};")
+                            is_udt_init = True
+                        break
+                if is_udt_init:
+                    continue
+                if name in self.ctx.series_vars:
+                    cpp_val = self._resolve_known(init_expr)
+                    lines.append(f"            {safe}.push({cpp_val});")
+                    # Also init cloned copies for per-call-site function variants
+                    init_emitted: set[str] = set()
+                    for (fname, cs_idx), remap in self._func_cs_var_remap.items():
+                        if cs_idx == 0:
+                            continue
+                        if safe in remap:
+                            cloned = remap[safe]
+                            if cloned not in init_emitted:
+                                init_emitted.add(cloned)
+                                lines.append(f"            {cloned}.push({cpp_val});")
+            lines.append("            _var_initialized = true;")
+            lines.append("        } else {")
+            for name, _, _ in self.ctx.var_members:
+                safe = self._safe_name(name)
+                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]);")
+                    # 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():
+                        if cs_idx == 0:
+                            continue
+                        if safe in remap:
+                            cloned = remap[safe]
+                            if cloned not in carry_emitted:
+                                carry_emitted.add(cloned)
+                                lines.append(f"            if (is_first_tick_) {cloned}.push({cloned}[0]);")
+            lines.append("        }")
+
+        # c. Push non-var series (they start fresh each bar with a push)
+        # (actual push happens in visit_VarDecl when the decl is visited)
+
+        # c3. Evaluate static global inputs and variables once
+        static_vars = []
+        for stmt in self.ctx.ast.body:
+            if isinstance(stmt, VarDecl):
+                is_input = isinstance(stmt.value, FuncCall) and self._is_input_call(stmt.value)
+                if is_input:
+                    func_name_i, namespace_i = self._resolve_callee(stmt.value.callee)
+                    is_static_global_input = (
+                        stmt.name in self._global_member_vars
+                        and func_name_i != "source"
+                        and stmt.name not in self._array_vars
+                        and stmt.name not in getattr(self, "_matrix_specs", {})
+                        and stmt.name not in getattr(self, "_map_vars", {})
+                        and not stmt.is_var
+                        and not stmt.is_varip
+                    )
+                    if is_static_global_input:
+                        safe = self._safe_name(stmt.name)
+                        default = self._get_input_default(stmt.value)
+                        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)
+                        cpp_val = f'{getter}("{title}", {default_cpp})'
+                        static_vars.append(f"{safe} = {cpp_val};")
+
+        if static_vars:
+            lines.append("        if (!_inputs_initialized_) {")
+            for var_expr in static_vars:
+                lines.append(f"            {var_expr}")
+            lines.append("            _inputs_initialized_ = true;")
+            lines.append("        }")
+
+        # c2. First-bar TA resize: rebuild any TA object whose ctor args come
+        # from input-backed variables so strategy_set_input() actually changes
+        # the circular-buffer sizes. Emits nothing when no TA site depends on
+        # an input (the default-sized construction already matches Pine).
+        self._emit_ta_runtime_reset(lines, indent=2)
+
+        # d. Visit each statement
+        for stmt in self.ctx.ast.body:
+            self._visit_stmt(stmt, lines, indent=2)
+
+        # e. ``// @pf-trace`` pragma block — emitted last so trace values
+        #    reflect every assignment / strategy call made earlier in the
+        #    bar. The block is wrapped in ``if (trace_enabled_)`` so cost
+        #    is zero when tracing is off (the engine flips the flag on
+        #    demand). The ``(double)`` cast covers bool/int/float without
+        #    overload tax — the engine has overloads for the exact types
+        #    but a single double form is the simplest emission. When no
+        #    pragmas are present we emit nothing at all (zero overhead
+        #    for legacy scripts).
+        self._emit_pf_trace_block(lines, indent=2)
+
+        lines.append("    }")
+
+    def _emit_pf_trace_block(self, lines: list[str], indent: int = 2) -> None:
+        """Emit the ``// @pf-trace`` instrumentation block.
+
+        Reads ``self.ctx.pf_trace_pragmas`` (populated by
+        :func:`pineforge_codegen.pragmas.extract_pf_trace_pragmas` and
+        attached in :func:`pineforge_codegen.transpile`). For each
+        pragma ``// @pf-trace name=expr`` we emit:
+
+            trace(std::string("name"), (double)(<expr_cpp>));
+
+        wrapped in a single ``if (trace_enabled_)`` guard so the entire
+        block compiles to a predictable-branch zero-overhead read of one
+        bool when tracing is off. ``trace_enabled_`` and the
+        ``trace(name, value)`` overloads live on the engine base class
+        (parallel agent owns that wiring).
+
+        The expression is lowered through the standard expression
+        visitor (``self._visit_expr``) — exactly the same machinery
+        used for any other Pine expression, so logical operators
+        ``and`` / ``or`` lower to ``&&`` / ``||``, member access /
+        function calls / ternaries all work, and per-call-site
+        rewrites are inactive (we run after the on_bar statement
+        loop, where ``_active_var_remap`` and friends are at their
+        default empty state).
+
+        Pragma names match ``[A-Za-z_][A-Za-z0-9_]*`` (enforced by
+        the regex in :mod:`pineforge_codegen.pragmas`) so they need
+        no escaping inside the C++ string literal.
+
+        Empty pragma list -> nothing is emitted (zero overhead).
+        """
+        pragmas = getattr(self.ctx, "pf_trace_pragmas", None) or []
+        if not pragmas:
+            return
+        pad = "    " * indent
+        inner = pad + "    "
+        lines.append(f"{pad}if (trace_enabled_) {{")
+        for pragma in pragmas:
+            cpp_expr = self._visit_expr(pragma.expr_node)
+            lines.append(
+                f'{inner}trace(std::string("{pragma.name}"), '
+                f"(double)({cpp_expr}));"
+            )
+        lines.append(f"{pad}}}")
+
+    def _emit_extern_c(self, lines: list[str]) -> None:
+        lines.append('extern "C" {')
+        lines.append("    void* strategy_create(const char* params_json) {")
+        lines.append("        return new GeneratedStrategy();")
+        lines.append("    }")
+        lines.append("    void run_backtest(void* s, Bar* bars, int n, ReportC* out) {")
+        lines.append("        auto* strat = static_cast<GeneratedStrategy*>(s);")
+        if self._security_calls:
+            # If there are security calls, use the full run path. Pass empty strings
+            # so the C++ runtime auto-detects input_tf from bar timestamps.
+            lines.append('        strat->run(bars, n, "", "", false, 4, MagnifierDistribution::ENDPOINTS);')
+        else:
+            lines.append("        strat->run(bars, n);")
+        lines.append("        strat->fill_report(out);")
+        lines.append("    }")
+        lines.append("    void run_backtest_full(void* s, Bar* bars, int n,")
+        lines.append('                           const char* input_tf, const char* script_tf,')
+        lines.append("                           int bar_magnifier, int magnifier_samples,")
+        lines.append("                           int magnifier_dist,")
+        lines.append("                           ReportC* out) {")
+        lines.append('        auto* strat = static_cast<GeneratedStrategy*>(s);')
+        lines.append('        std::string itf = input_tf ? input_tf : "";')
+        lines.append('        std::string stf = script_tf ? script_tf : "";')
+        if self._security_calls:
+            # Pass empty strings through — the C++ runtime auto-detects input_tf from bar timestamps.
+            # script_tf defaults to input_tf in the runtime if empty.
+            lines.append("        strat->run(bars, n, itf, stf, bar_magnifier != 0, magnifier_samples,")
+            lines.append("                   static_cast<MagnifierDistribution>(magnifier_dist));")
+        else:
+            # The magnifier-aware run() overload handles ratio=1 (no
+            # aggregation) and empty itf/stf (auto-detect) on its own, so
+            # we only need to fall back to the simple ``run(bars, n)``
+            # path when the caller explicitly opted out of magnifier AND
+            # there is no timeframe aggregation in play. Previously the
+            # short-circuit ``itf.empty() || stf.empty() || itf == stf``
+            # silently dropped the bar_magnifier flag whenever the host
+            # passed empty TFs (the validator's default) — turning every
+            # magnifier-opt-in run into a non-magnifier run and producing
+            # 0.21% exit-price drift on the magnifier-distribution probes.
+            lines.append("        bool needs_full_run = (bar_magnifier != 0)")
+            lines.append("            || (!itf.empty() && !stf.empty() && itf != stf);")
+            lines.append("        if (!needs_full_run) {")
+            lines.append("            strat->run(bars, n);")
+            lines.append("        } else {")
+            lines.append("            strat->run(bars, n, itf, stf, bar_magnifier != 0, magnifier_samples,")
+            lines.append("                       static_cast<MagnifierDistribution>(magnifier_dist));")
+            lines.append("        }")
+        lines.append("        strat->fill_report(out);")
+        lines.append("    }")
+        lines.append("    void strategy_free(void* s) {")
+        lines.append("        delete static_cast<GeneratedStrategy*>(s);")
+        lines.append("    }")
+        lines.append("    void report_free(ReportC* report) {")
+        lines.append("        BacktestEngine::free_report(report);")
+        lines.append("    }")
+        lines.append("    void strategy_set_input(void* s, const char* key, const char* value) {")
+        lines.append("        if (!s || !key || !value) return;")
+        lines.append("        static_cast<GeneratedStrategy*>(s)->set_input(key, value);")
+        lines.append("    }")
+        lines.append("    void strategy_set_override(void* s, const char* key, const char* value) {")
+        lines.append("        if (!s || !key || !value) return;")
+        lines.append("        static_cast<GeneratedStrategy*>(s)->set_strategy_override(key, value);")
+        lines.append("    }")
+        lines.append("    void strategy_set_magnifier_volume_weighted(void* s, int on) {")
+        lines.append("        if (!s) return;")
+        lines.append("        static_cast<GeneratedStrategy*>(s)->set_magnifier_volume_weighted(on != 0);")
+        lines.append("    }")
+        lines.append("}")
+        lines.append("")
+
+    def _emit_udt_method_cpp_name(self, fi: FuncInfo) -> str:
+        """Stable C++ identifier for a UDT instance method (``_udt_Type_method``)."""
+        udt = fi.udt_type_name or ""
+        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:
+        """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.
+        """
+        node = fi.node
+        if node is None:
+            return
+
+        is_udt = bool(getattr(fi, "is_udt_method", False)) and fi.udt_type_name
+
+        # Determine param types and set context for type inference inside body
+        param_strs = []
+        self._current_func_param_types = {}
+        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):
+            if is_udt and i == 0 and fi.udt_type_name:
+                cpp_t = f"{fi.udt_type_name}&"
+                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
+            elif fi.name == "isInSession" and i < 2:
+                cpp_t = "std::string"
+            elif p in func_sv:
+                # 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(fi.param_types):
+                pt = fi.param_types[i]
+                cpp_t = PINE_TYPE_TO_CPP.get(pt, "double")
+            else:
+                cpp_t = "double"
+            param_strs.append(f"{cpp_t} {self._safe_name(p)}")
+            self._current_func_param_types[p] = cpp_t
+
+        # Determine return type: tuple, UDT, or scalar.
+        # The UDT branch handles user functions whose body is ``T.new(...)``;
+        # without it the function would be emitted as returning ``double`` and
+        # clang errors with "no viable conversion from T to double". Probe:
+        # data/validation/udt-method-probe-20-udt-return-from-func.
+        if fi.returns_tuple:
+            # Infer actual tuple element types from function body's last expression
+            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
+        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:
+            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._in_ta_func_variant = True
+            self._active_call_site_idx = call_site_idx
+        else:
+            self._active_ta_remap = {}
+            self._active_var_remap = {}
+            self._in_ta_func_variant = False
+            self._active_call_site_idx = None
+
+        prev_func_locals = self._current_func_locals
+        self._current_func_locals = {n for n, _, _ in self.ctx.func_var_members.get(fi.name, [])}
+        # 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.
+        self._current_func_locals |= self._collect_binding_names(node.body)
+
+        lines.append(f"    {ret_type} {func_name}({', '.join(param_strs)}) {{")
+
+        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:
+                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
+                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)
+                    )
+                    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;")
+                    emitted_return = True
+                else:
+                    self._visit_stmt(s, lines, indent=2)
+
+        # Always emit a default return if no explicit return was emitted,
+        # to avoid non-void function without return value.
+        if not emitted_return:
+            if fi.returns_tuple:
+                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)
+                )
+                lines.append(f"        return {default_ret};")
+
+        lines.append("    }")
+        self._current_func_param_types = {}
+        self._current_func_series_params = set()
+        self._udt_param_udt = {}
+        self._current_func_locals = prev_func_locals
+        self._active_ta_remap = {}
+        self._active_var_remap = {}
+        self._in_ta_func_variant = False
+        self._active_call_site_idx = None
+
+    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)
+        if not has_static_ta:
+            return
+
+        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):
+                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):
+                resolved = [self._resolve_known(a) for a in site.ctor_args]
+                safe_resolved = []
+                for r in resolved:
+                    safe_resolved.append(r if self._is_compile_time_value(r) else "1")
+                lines.append(f"        {site.member_name} = {site.class_name}({', '.join(safe_resolved)});")
+
+        # Clear series
+        lines.append("")
+        for field_name in sorted(self.ctx.series_bar_fields):
+            lines.append(f"        _s_{field_name}.clear();")
+
+        # Start precalculation loop
+        lines.append("")
+        lines.append("        for (int i = 0; i < n; ++i) {")
+
+        # Push OHLCV into series
+        for field_name in sorted(self.ctx.series_bar_fields):
+            push_expr = BAR_SERIES_PUSH.get(field_name, f"bars[i].{field_name}")
+            push_expr_bars = push_expr.replace("current_bar_.", "bars[i].")
+            lines.append(f"            _s_{field_name}.push({push_expr_bars});")
+
+        # 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):
+                    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});")
+        finally:
+            self._precalc_loop_active = False
+
+        lines.append("        }")
+
+        # 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):
+                resolved = [self._resolve_known(a) for a in site.ctor_args]
+                safe_resolved = []
+                for r in resolved:
+                    safe_resolved.append(r if self._is_compile_time_value(r) else "1")
+                lines.append(f"        {site.member_name} = {site.class_name}({', '.join(safe_resolved)});")
+
+        for field_name in sorted(self.ctx.series_bar_fields):
+            lines.append(f"        _s_{field_name}.clear();")
+
+        lines.append("")
+        lines.append("        _use_precalc = true;")
+        lines.append("    }")
+        lines.append("")
+
+        # Overridden run methods
+        lines.append("    void run(const Bar* bars, int n) {")
+        lines.append("        precalculate(bars, n);")
+        lines.append("        BacktestEngine::run(bars, n);")
+        lines.append("    }")
+        lines.append("")
+        lines.append("    void run(const Bar* input_bars, int n_input,")
+        lines.append("             const std::string& input_tf,")
+        lines.append("             const std::string& script_tf,")
+        lines.append("             bool bar_magnifier = false,")
+        lines.append("             int magnifier_samples = 4,")
+        lines.append("             MagnifierDistribution magnifier_dist = MagnifierDistribution::ENDPOINTS) {")
+        lines.append("        bool needs_dynamic = bar_magnifier || (!input_tf.empty() && !script_tf.empty() && input_tf != script_tf);")
+        lines.append("        if (needs_dynamic) {")
+        lines.append("            _use_precalc = false;")
+        lines.append("        } else {")
+        lines.append("            precalculate(input_bars, n_input);")
+        lines.append("        }")
+        lines.append("        BacktestEngine::run(input_bars, n_input, input_tf, script_tf, bar_magnifier, magnifier_samples, magnifier_dist);")
+        lines.append("    }")