@pineforge/codegen-pyodide 0.10.2 → 0.10.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pineforge/codegen-pyodide",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "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/analyzer/base.py

@@ -5973,7 +5973,19 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                         callee=MemberAccess(object=Identifier(name="ta"), member=node.member),
                         args=[], kwargs={},
                     )
-                    return self._handle_ta_call(node.member, synthetic_call)
+                    before = len(self._ta_call_sites)
+                    result = self._handle_ta_call(node.member, synthetic_call)
+                    # The site belongs to THIS read: key it on the AST node the
+                    # codegen will meet (the MemberAccess), not on the synthetic
+                    # call nobody else holds. Without this a bare ``ta.vwap``
+                    # inside request.security() could not find its own site and
+                    # was lowered to the first live CHART member (advanced by the
+                    # chart bar AND every requested sub-bar, read through
+                    # history_advances_new_bar()); a second top-level read bound
+                    # to the first read's member as well.
+                    if len(self._ta_call_sites) > before:
+                        self._ta_call_sites[-1].node = node
+                    return result
                 return PineType.FLOAT
 
             # math.* properties

package/pineforge_codegen/analyzer/call_handlers.py

@@ -437,9 +437,15 @@ class CallHandlers:
             all_args = [default_arg]
 
         if func_name == "vwap" and not all_args:
-            default_src = Identifier(name="close")
+            # The bare ``ta.vwap`` property is the VWAP of hlc3 (Pine v6
+            # reference: "It uses hlc3 as its source series"); TradingView's
+            # own read equals hlc3 on a daily bar (lab tv
+            # notrade-session-vwap-f1d, NYSE:F 1D 2025-07-01..08-31, 42/42,
+            # 2026-09-05), where the engine used to read the bar's close.
+            default_src = Identifier(name="hlc3")
             self._visit(default_src)
-            self._series_bar_fields.add("close")
+            for field in ("high", "low", "close"):
+                self._series_bar_fields.add(field)
             all_args = [default_src]
 
         # Handle ta.highest(length) / ta.lowest(length) with 1 arg:

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.
@@ -1906,7 +1914,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 self._collection_types[name] = spec
             elif ns == "array" and fn in ({"new", "from"} | set(ARRAY_NEW_CTORS)):
                 self._array_vars.add(name)
-                spec = self._type_spec_from_expr(expr) or self._array_spec_for_name(name)
+                spec = self._widen_array_spec_for_name(
+                    name,
+                    self._type_spec_from_expr(expr) or self._array_spec_for_name(name),
+                )
                 self._collection_types[name] = spec
             elif ns == "map" and fn == "new":
                 self._map_vars.add(name)
@@ -1926,7 +1937,10 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             fn2, ns2 = self._resolve_callee(expr.callee)
             if ns2 == "array" and fn2 in ({"new", "from"} | set(ARRAY_NEW_CTORS)):
                 self._array_vars.add(name)
-                spec2 = self._type_spec_from_expr(expr) or self._array_spec_for_name(name)
+                spec2 = self._widen_array_spec_for_name(
+                    name,
+                    self._type_spec_from_expr(expr) or self._array_spec_for_name(name),
+                )
                 self._collection_types[name] = spec2
                 continue
             if name in self._matrix_specs:
@@ -2110,6 +2124,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 +3813,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 +4046,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 +4206,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():
+        for info in self._lazy_source_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.
-            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
@@ -4227,7 +4281,9 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 )
             ):
                 self._array_vars.add(name)
-                array_spec = exact_member_spec or self._array_spec_for_name(name)
+                array_spec = self._widen_array_spec_for_name(
+                    name, exact_member_spec or self._array_spec_for_name(name)
+                )
                 lines.append(
                     f"    {self._type_spec_to_cpp(array_spec)} {safe};"
                 )

package/pineforge_codegen/codegen/emit_top.py

@@ -89,6 +89,7 @@ from ..analyzer import FuncInfo
 from ..symbols import PineType, method_receiver_cpp_token
 from .tables import (
     BAR_SERIES_PUSH,
+    TA_CHART_PREV_CLOSE_ARG,
     DRAWING_TYPE_TO_CPP,
     PINE_TYPE_TO_CPP,
     RUNTIME_REGISTER_SECURITY_EVAL_FN,
@@ -136,6 +137,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 +935,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
@@ -1003,6 +1036,11 @@ class TopLevelEmitter:
                 # declaration statements, not in the global on_bar preamble.
                 if name in getattr(self, "_func_local_var_names", ()):
                     continue
+                # A wide int array member (``std::vector<int64_t>``, see
+                # ``_wide_int_array_names``) needs its first-bar constructor
+                # spelled with the same element type: name the target for
+                # visit_call's ``array.new_*`` / ``array.from`` lowering.
+                self._array_ctor_target_name = name
                 safe = self._safe_name(name)
                 runtime_info = self._runtime_scalar_var_init_by_member.get(name)
                 if (runtime_info is not None
@@ -1099,6 +1137,7 @@ class TopLevelEmitter:
                             if cloned not in init_emitted:
                                 init_emitted.add(cloned)
                                 lines.append(f"            {cloned}.push({cpp_val});")
+            self._array_ctor_target_name = None
             lines.append("            _var_initialized = true;")
             lines.append("        } else {")
             for name, _, _ in self.ctx.var_members:
@@ -1196,9 +1235,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
@@ -1938,6 +1983,14 @@ class TopLevelEmitter:
                 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].")
+                    # issue #178: the precalc pre-pass walks the bar array
+                    # itself, so the previous CHART close is bars[i - 1]
+                    # (the engine's prev_chart_close() tracker only advances
+                    # at on_bar dispatch).
+                    compute_args_bars = compute_args_bars.replace(
+                        TA_CHART_PREV_CLOSE_ARG,
+                        "(i > 0 ? bars[i - 1].close : na<double>())",
+                    )
                     lines.append(f"            _precalc_{site.member_name}[i] = {site.member_name}.compute({compute_args_bars});")
         finally:
             self._precalc_loop_active = False