@pineforge/codegen-pyodide 0.8.1 → 0.9.0

package/pineforge_codegen/codegen/drawing.py

@@ -255,7 +255,7 @@ class DrawingVisitor:
             vals = self._merge_drawing_args(node, ["price"])
             price = (self._visit_expr(vals["price"]) if vals.get("price") is not None
                      else "current_bar_.close")
-            return (f"ChartPoint{{ .index=bar_index_, "
+            return (f"ChartPoint{{ .index=(int64_t)(pine_bar_index()), "
                     f".time=(int64_t)current_bar_.timestamp, .price=({price}) }}")
         if func_name == "from_index":
             vals = self._merge_drawing_args(node, ["index", "price"])

package/pineforge_codegen/codegen/emit_top.py

@@ -118,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>")
@@ -192,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
@@ -212,7 +347,11 @@ 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
@@ -296,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'])};")
 
@@ -380,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;')
@@ -448,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
@@ -470,17 +644,16 @@ 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:
@@ -552,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():
@@ -562,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)
@@ -776,10 +953,12 @@ 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:
                 # A method receiver whose type is a drawing primitive
                 # (egoigor's ``method slope(line ln)``) must emit ``Line&`` not
@@ -821,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(...)``;
@@ -852,6 +1034,7 @@ class TopLevelEmitter:
             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"]
@@ -862,17 +1045,24 @@ class TopLevelEmitter:
             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
-            self._current_instance_name = f"{self._func_safe_name(fi.name)}_cs{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
@@ -886,6 +1076,7 @@ class TopLevelEmitter:
         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.
@@ -956,14 +1147,17 @@ class TopLevelEmitter:
 
         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
@@ -1031,24 +1225,44 @@ class TopLevelEmitter:
         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:
@@ -1059,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("")
@@ -1081,8 +1302,8 @@ class TopLevelEmitter:
         # 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 again before the real run begins
-        # (BacktestEngine::run() clears every _src_*_ series unconditionally).
+        # 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;")
@@ -1136,8 +1357,10 @@ class TopLevelEmitter:
         # 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});")
@@ -1148,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:
@@ -1158,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;")

package/pineforge_codegen/codegen/input.py

@@ -206,6 +206,23 @@ class InputHelper:
         default = self._get_input_default(node)
         default_cpp = self._visit_expr(default) if default is not None else "0"
         getter = self._input_type_to_getter(func_name, namespace)
+        # The generic ``input(...)`` overload is typed by its defval in Pine
+        # v6 (an int default yields an int input). The static getter table
+        # cannot see the default, so infer the getter from the default's
+        # literal type here. This matters for TA lengths: ``input(15)`` must
+        # route to ``get_input_int`` so the RMA/EMA ctor receives an int.
+        if func_name == "input" and namespace is None:
+            if isinstance(default, BoolLiteral):
+                getter = "get_input_bool"
+            elif isinstance(default, NumberLiteral):
+                if isinstance(default.value, bool):
+                    getter = "get_input_bool"
+                elif isinstance(default.value, int):
+                    getter = "get_input_int"
+                else:
+                    getter = "get_input_double"
+            elif isinstance(default, StringLiteral):
+                getter = "get_input_string"
         default_cpp = self._coerce_string_input_default(getter, default_cpp)
         return f'{getter}("{title}", {default_cpp})'