@pineforge/codegen-pyodide 0.10.2 → 0.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pineforge/codegen-pyodide",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "Gate-validated Pyodide payload for the PineScript v6 -> C++ transpiler: archive (run in Pyodide), unpacked source, introspected tables, and release metadata.",
   "type": "module",
   "main": "index.mjs",

package/pineforge_codegen/codegen/base.py

@@ -5,6 +5,7 @@ results from AnalyzerContext instead of walking the AST to collect info.
 """
 
 from __future__ import annotations
+import re
 
 from dataclasses import dataclass
 
@@ -309,6 +310,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # Set of var/series member names that belong to user functions (need cloning)
         self._func_var_members_set: set[str] = set()
         self._precalc_loop_active: bool = False
+        # Top-level lazy-edge TA sites hoisted to every-bar evaluation for the
+        # statement currently being lowered: FuncCall id -> local name, and
+        # Subscript id -> ``_hist_call_*`` member (see ``ta.py``).
+        self._hoisted_ta_values: dict[int, str] = {}
+        self._hoisted_hist_reads: dict[int, str] = {}
         # Names of ``var`` members that live in a callable scope (not global).
         # Their exact declaration statements own initialization; they must not
         # be initialized by the constructor or the global on_bar preamble.
@@ -934,6 +940,8 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         self._register_global_aggregate_member_types()
         self._uses_map = self._detect_map_usage()
         self._uses_matrix = self._detect_matrix_usage()
+        self._uses_pine_time = self._detect_pine_time_usage()
+        self._uses_vwap_anchor = self._detect_vwap_usage()
         # Drawing-objects-as-data: gate all new emission (drawing.hpp include +
         # the per-type arenas) on this flag so non-drawing strategies stay
         # byte-identical. Caps come from the strategy() header max_*_count.
@@ -2110,6 +2118,45 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                     return True
         return False
 
+    def _detect_pine_time_usage(self) -> bool:
+        """True if emitted C++ calls the engine's pine_time()/pine_time_close().
+
+        Gates the PF_PINE_TIME_SESSION_DAY_ARGS prelude shim (emit_top.py) so
+        scripts that never call ``time(tf[, session[, tz]])`` /
+        ``time_close(...)`` stay byte-identical. A ``var`` initializer is
+        also text-scanned, mirroring ``_detect_matrix_usage``.
+        """
+        pat = re.compile(r"(?<![\w.])time(?:_close)?\s*\(")
+        for _, _, init_str in self.ctx.var_members:
+            if init_str and pat.search(str(init_str)):
+                return True
+        for node in self._walk_ast(self.ctx.ast):
+            if isinstance(node, FuncCall) and (node.args or node.kwargs):
+                fn, ns = self._resolve_callee(node.callee)
+                if ns is None and fn in ("time", "time_close"):
+                    return True
+        return False
+
+    def _detect_vwap_usage(self) -> bool:
+        """True if emitted C++ calls ta::VWAP / ta::VWAPBands compute().
+
+        Gates the PF_VWAP_SESSION_ANCHOR_ARGS prelude shim (emit_top.py):
+        ``ta.vwap(...)`` calls, the bare ``ta.vwap`` property read, and
+        ``var`` initializers are covered.
+        """
+        for _, _, init_str in self.ctx.var_members:
+            if init_str and "ta.vwap" in str(init_str):
+                return True
+        for node in self._walk_ast(self.ctx.ast):
+            if isinstance(node, FuncCall):
+                fn, ns = self._resolve_callee(node.callee)
+                if ns == "ta" and fn == "vwap":
+                    return True
+            elif isinstance(node, MemberAccess) and node.member == "vwap":
+                if getattr(node.object, "name", None) == "ta":
+                    return True
+        return False
+
     def _detect_generic_matrix_usage(self) -> bool:
         """True if emitted C++ mentions a non-float matrix specialization."""
         float_spec = TypeSpec.primitive("float")
@@ -3760,7 +3807,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # request.security helper-call results read at a history offset
         # (``myHelper()[k]``). Maps (sec_id, node-id) -> backing Series metadata.
         self._security_expr_hist_by_node: dict[tuple[int, int], dict] = {}
-        self._prepare_lazy_saturated_roc3_sites()
+        self._prepare_lazy_source_clock_sites()
 
         lines: list[str] = []
 
@@ -3993,11 +4040,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 )
             lines.append("")
 
-        # Source-shaped lazy ROC call clocks are generated support types, not
-        # script state themselves. Their per-callsite instances are declared
-        # below inside GeneratedStrategy and therefore join the automatic COOF
-        # checkpoint inventory.
-        self._emit_lazy_saturated_roc3_helper(lines)
+        # Hold-last source clocks (change/mom/roc below a top-level lazy edge)
+        # are generated support types, not script state themselves. Their
+        # per-callsite instances are declared below inside GeneratedStrategy
+        # and therefore join the automatic COOF checkpoint inventory.
+        self._emit_lazy_source_clock_helper(lines)
 
         # 2. Open class
         lines.append("class GeneratedStrategy : public BacktestEngine {")
@@ -4153,20 +4200,21 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 lines.append(f"    std::vector<{vtype}> _precalc_{site.member_name};")
         lines.append("    bool _use_precalc = false;")
 
-        for clock_name in self._lazy_saturated_roc3_clock_by_node.values():
-            lines.append(
-                f"    {self._lazy_saturated_roc3_type_name} {clock_name};"
-            )
-        if self._lazy_saturated_roc3_clock_by_node:
-            # Dedicated eager close[3] fallback. Its fixed four-slot capacity
-            # is independent of the user's max_bars_back directive, which may
-            # legitimately be smaller than the offset this generated route
-            # requires. It is ordinary copyable script state and therefore
-            # joins the automatic COOF checkpoint below.
+        for info in self._lazy_source_clock_by_node.values():
             lines.append(
-                "    Series<double> "
-                f"{self._lazy_saturated_roc3_history_name}{{4}};"
+                f"    {self._lazy_source_clock_type_name} {info['clock']};"
             )
+            # Held-source history on the chart clock. A literal length sizes
+            # it exactly (independent of the user's max_bars_back directive,
+            # which may legitimately be smaller than this generated route
+            # needs); a runtime length uses the Series default capacity. Both
+            # are ordinary copyable script state and join the automatic COOF
+            # checkpoint below.
+            literal = info["length_literal"]
+            capacity = f"{{{literal + 1}}}" if literal is not None and literal >= 1 else ""
+            lines.append(f"    Series<double> {info['hist']}{capacity};")
+            if info["chart"] is not None:
+                lines.append(f"    Series<double> {info['chart']}{capacity};")
 
         # Security evaluator TA members (cloned from expression dependencies)
         # Skip for user function call expressions — their TA deps are internal to the function

package/pineforge_codegen/codegen/emit_top.py

@@ -136,6 +136,28 @@ class TopLevelEmitter:
         lines.append('#include <pineforge/log.hpp>')
         lines.append('#include <pineforge/str_utils.hpp>')
         lines.append('#include <pineforge/session_time.hpp>')
+        # Feature-guarded argument tails (lab experiment cells build the
+        # candidate codegen against the BASE engine too): the symbol clock
+        # (syminfo tz + session) reaches time()/time_close() and ta.vwap only
+        # when the engine header advertises the overloads; otherwise the
+        # macros expand to nothing and the calls collapse to the legacy
+        # 5-arg pine_time / 3-arg VWAP::compute shapes (session filter in
+        # UTC, UTC-day VWAP anchor — the honest "factor absent" behaviour).
+        # Gated on the pre-scans so scripts without such calls stay
+        # byte-identical. The expansion carries no extra parentheses so the
+        # preprocessed call is byte-identical to the plain 7-arg form.
+        if getattr(self, "_uses_pine_time", False):
+            lines.append("#ifdef PF_PINE_TIME_HAS_SESSION_DAY")
+            lines.append("#define PF_PINE_TIME_SESSION_DAY_ARGS(tz, sess) , tz, sess")
+            lines.append("#else")
+            lines.append("#define PF_PINE_TIME_SESSION_DAY_ARGS(tz, sess)")
+            lines.append("#endif")
+        if getattr(self, "_uses_vwap_anchor", False):
+            lines.append("#ifdef PF_VWAP_HAS_SESSION_ANCHOR")
+            lines.append("#define PF_VWAP_SESSION_ANCHOR_ARGS(tz, sess) , tz, sess")
+            lines.append("#else")
+            lines.append("#define PF_VWAP_SESSION_ANCHOR_ARGS(tz, sess)")
+            lines.append("#endif")
         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).
@@ -912,28 +934,38 @@ class TopLevelEmitter:
 
         # A GeneratedStrategy handle may execute multiple batch runs or
         # streaming lifecycles. BacktestEngine resets broker/base state, but
-        # generated members survive. Reset source-shaped lazy ROC clocks and
-        # their forced eager-fallback close history at the first genuine slot
-        # of each lifecycle. This lives in on_bar rather than a generated run
-        # wrapper because stream_begin() enters the base run path directly.
-        # COOF post-close recalculations have history_advances_new_bar()==false
-        # and therefore preserve the current committed clock/base.
-        if self._lazy_saturated_roc3_clock_by_node:
+        # generated members survive. Reset the hold-last source clocks
+        # (change/mom/roc below a top-level lazy edge) and their held-source
+        # Series at the first genuine slot of each lifecycle, then freeze this
+        # bar's base and record it once per chart bar. This lives in on_bar
+        # rather than a generated run wrapper because stream_begin() enters the
+        # base run path directly. COOF post-close recalculations have
+        # history_advances_new_bar()==false and therefore keep the same base.
+        if self._lazy_source_clock_by_node:
             lines.append(
                 "        if (history_advances_new_bar() && bar_index_ == 0) {"
             )
-            for clock_name in self._lazy_saturated_roc3_clock_by_node.values():
-                lines.append(f"            {clock_name}.reset();")
-            lines.append(
-                f"            {self._lazy_saturated_roc3_history_name}.clear();"
-            )
+            for info in self._lazy_source_clock_by_node.values():
+                lines.append(f"            {info['clock']}.reset();")
+                lines.append(f"            {info['hist']}.clear();")
+                if info["chart"] is not None:
+                    lines.append(f"            {info['chart']}.clear();")
             lines.append("        }")
-            self._emit_history_series_write(
-                lines,
-                "        ",
-                self._lazy_saturated_roc3_history_name,
-                "current_bar_.close",
-            )
+            for info in self._lazy_source_clock_by_node.values():
+                lines.append(f"        {info['clock']}.begin_bar(bar_index_);")
+                self._emit_history_series_write(
+                    lines,
+                    "        ",
+                    info["hist"],
+                    f"{info['clock']}.bar_base_source",
+                )
+                if info["chart"] is not None:
+                    self._emit_history_series_write(
+                        lines,
+                        "        ",
+                        info["chart"],
+                        self._visit_expr(info["chart_source"]),
+                    )
 
         # reset_run_state() owns engine/broker state, while these generated
         # Series members belong to the strategy object. Clear all of them on
@@ -1196,9 +1228,15 @@ class TopLevelEmitter:
         # an input (the default-sized construction already matches Pine).
         self._emit_ta_runtime_reset(lines, indent=2)
 
-        # d. Visit each statement
+        # d. Visit each statement. A stateful ``ta.*`` site below a lazy
+        #    ``and``/``or`` RHS or ternary arm of a top-level statement is
+        #    evaluated every bar BEFORE the statement (TV rule, see ``ta.py``).
         for stmt in self.ctx.ast.body:
-            self._visit_stmt(stmt, lines, indent=2)
+            self._emit_lazy_edge_ta_hoists(stmt, lines, indent=2)
+            try:
+                self._visit_stmt(stmt, lines, indent=2)
+            finally:
+                self._clear_lazy_edge_ta_hoists()
 
         # e. ``// @pf-trace`` pragma block — emitted last so trace values
         #    reflect every assignment / strategy call made earlier in the