pineforge-codegen 0.10.3__tar.gz → 0.10.4__tar.gz

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pineforge-codegen
-Version: 0.10.3
+Version: 0.10.4
 Summary: PineScript v6 to C++ transpiler that targets the pineforge-engine runtime.
 Project-URL: Homepage, https://github.com/pineforge-4pass/pineforge-codegen-oss
 Project-URL: Issues, https://github.com/pineforge-4pass/pineforge-codegen-oss/issues

pineforge_codegen-0.10.4/VERSION

@@ -0,0 +1 @@
+0.10.4

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/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

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/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:

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/pineforge_codegen/codegen/base.py

@@ -1914,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)
@@ -1934,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:
@@ -4275,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};"
                 )

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/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,
@@ -1035,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
@@ -1131,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:
@@ -1976,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

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/pineforge_codegen/codegen/ta.py

@@ -31,7 +31,12 @@ from ..ast_nodes import (
     Ternary, TupleAssign, TupleLiteral, TypeDecl, TypeField, UnaryOp, VarDecl,
     WhileStmt,
 )
-from .tables import TA_IMPLICIT_APPEND, TA_IMPLICIT_COMPUTE_FULL
+from .tables import (
+    TA_CHART_PREV_CLOSE,
+    TA_CHART_PREV_CLOSE_ARG,
+    TA_IMPLICIT_APPEND,
+    TA_IMPLICIT_COMPUTE_FULL,
+)
 
 if TYPE_CHECKING:
     from ..analyzer import TACallSite
@@ -113,6 +118,10 @@ class TaSiteHelper:
 
         if ta_name in TA_IMPLICIT_COMPUTE_FULL:
             implicit = TA_IMPLICIT_COMPUTE_FULL[ta_name]
+            # issue #178: chart-context atr / tr take the previous CHART
+            # bar's close as a 4th argument (see TA_CHART_PREV_CLOSE).
+            if ta_name in TA_CHART_PREV_CLOSE:
+                implicit = f"{implicit}, {TA_CHART_PREV_CLOSE_ARG}"
             if site.compute_args:
                 explicit = ", ".join(self._visit_expr(a) for a in site.compute_args)
                 if ta_name in self._TA_IMPLICIT_REPLACE:

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/pineforge_codegen/codegen/tables.py

@@ -222,6 +222,18 @@ TA_COMPUTE_ARGS = {
     "max": [0], "min": [0], "rci": [0],
 }
 
+# issue #178: ta.atr / ta.tr read their true range against the previous
+# CHART bar's close (close[1]) even when the call site executes sparsely —
+# the RMA advances on the executions only (TradingView pin 2026-09-06,
+# lab tv i178-sparse-atr-sense, BINANCE:BTCUSDT 60: 398/398 executions equal
+# the chart-close model, 0/398 the previous-execution model). The chart
+# context therefore passes ``BacktestEngine::prev_chart_close()`` as the
+# 4th compute() argument (the engine's always-on tracker); the per-object
+# prev_close (3-arg form) remains for request.security contexts, whose
+# ``bar.`` rewrite has no chart-close tracker.
+TA_CHART_PREV_CLOSE = {"atr", "tr"}
+TA_CHART_PREV_CLOSE_ARG = "prev_chart_close()"
+
 # TA functions whose ``.compute()`` always receives bar OHLC implicitly.
 TA_IMPLICIT_COMPUTE_FULL = {
     "atr": "current_bar_.high, current_bar_.low, current_bar_.close",

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/pineforge_codegen/codegen/types.py

@@ -135,8 +135,9 @@ class TypeInferer:
         if spec is None:
             return "double"
         if spec.kind == "primitive":
-            return {"float": "double", "int": "int", "bool": "bool",
-                    "string": "std::string", "color": "int"}.get(spec.name or "float", "double")
+            return {"float": "double", "int": "int", "int64": "int64_t",
+                    "bool": "bool", "string": "std::string",
+                    "color": "int"}.get(spec.name or "float", "double")
         if spec.kind == "udt" and spec.name:
             # Drawing handle structs (P1): map BEFORE the _udt_defs check so
             # array<line> -> std::vector<Line> and scalar line -> Line instead
@@ -269,6 +270,175 @@ class TypeInferer:
         return self._default_for_type(cpp_type)
 
     def _collection_spec_for_name(self, name: str) -> TypeSpec | None:
+        """``_collection_spec_for_name_raw`` with the wide-int element applied
+        (``_widen_array_spec_for_name``): an ``array<int>`` that stores epoch
+        milliseconds resolves as ``std::vector<int64_t>`` everywhere it is
+        read, declared or passed."""
+        return self._widen_array_spec_for_name(
+            name, self._collection_spec_for_name_raw(name)
+        )
+
+    # Element-returning array reads whose result carries the receiver's wide
+    # provenance (``_expr_returns_wide_int``).
+    _WIDE_ARRAY_ELEMENT_READS = frozenset({
+        "get", "first", "last", "pop", "shift", "remove", "max", "min",
+    })
+    # Writers whose VALUE argument decides whether an int array is wide:
+    # name -> (functional-form value index, method-form value index).
+    _ARRAY_ELEMENT_WRITERS = {
+        "push": (1, 0), "unshift": (1, 0), "set": (2, 1), "insert": (2, 1),
+        "fill": (1, 0),
+    }
+
+    @staticmethod
+    def _int_fits_int32(value: int) -> bool:
+        return -(1 << 31) <= value < (1 << 31)
+
+    def _pure_int_literal_value(self, node) -> int | None:
+        """Exact value of an expression built only from int literals and
+        ``+ - *`` / unary minus, else ``None``.
+
+        Pine ``int`` is 64-bit: ``90 * 24 * 60 * 60 * 1000`` (three months in
+        milliseconds) is 7 776 000 000 on TradingView. Emitted as C++ ``int``
+        literal arithmetic the same product overflows (wraps to -813 934 592),
+        so a ``(time - t0) > threeMonths`` expiry fires on every bar (round 8
+        family U: latibonit15 execution-signals-confluence, six lanes; lab tv
+        u-lati-levels-nq15 vs the engine, 2026-09-05). Folding the literal
+        subtree in Python keeps the exact value; the caller emits it as a
+        64-bit literal only when it does not fit ``int32`` so every in-range
+        expression is byte-identical to before.
+        """
+        if isinstance(node, NumberLiteral):
+            return node.value if isinstance(node.value, int) and not isinstance(node.value, bool) else None
+        if isinstance(node, UnaryOp) and node.op == "-":
+            inner = self._pure_int_literal_value(node.operand)
+            return -inner if inner is not None else None
+        if isinstance(node, BinOp) and node.op in ("+", "-", "*"):
+            left = self._pure_int_literal_value(node.left)
+            if left is None:
+                return None
+            right = self._pure_int_literal_value(node.right)
+            if right is None:
+                return None
+            if node.op == "+":
+                return left + right
+            if node.op == "-":
+                return left - right
+            return left * right
+        return None
+
+    def _literal_overflows_int32(self, node) -> bool:
+        value = self._pure_int_literal_value(node)
+        return value is not None and not self._int_fits_int32(value)
+
+    def _array_receiver_and_value(self, call):
+        """``(receiver_name, value_node)`` of an element-writing array call in
+        either form (``array.push(a, v)`` / ``a.push(v)``), else ``None``."""
+        if not isinstance(call, FuncCall):
+            return None
+        func_name, namespace = self._resolve_callee(call.callee)
+        if func_name not in self._ARRAY_ELEMENT_WRITERS:
+            return None
+        functional_idx, method_idx = self._ARRAY_ELEMENT_WRITERS[func_name]
+        if namespace == "array":
+            receiver = call.args[0] if call.args else call.kwargs.get("id")
+            value = (call.args[functional_idx]
+                     if len(call.args) > functional_idx
+                     else call.kwargs.get("value"))
+        elif (isinstance(call.callee, MemberAccess)
+              and isinstance(call.callee.object, Identifier)):
+            receiver = call.callee.object
+            value = (call.args[method_idx]
+                     if len(call.args) > method_idx
+                     else call.kwargs.get("value"))
+        else:
+            return None
+        if not isinstance(receiver, Identifier) or value is None:
+            return None
+        return receiver.name, value
+
+    def _wide_int_array_names(self) -> set[str]:
+        """Names of int arrays that hold a wide integer: one that receives an
+        epoch-millisecond value (``time``, ``time_close``, ``timestamp(...)``,
+        a wide callable result, ...) through ``array.push`` / ``unshift`` /
+        ``set`` / ``insert`` / ``fill``, or is built by ``array.new_int`` /
+        ``array.new<int>`` / ``array.from`` from one. Their element type is
+        ``int64_t`` (TypeSpec primitive ``int64``): Pine's ``int`` holds the
+        epoch, ``std::vector<int>`` truncates it. Cached on the instance."""
+        cached = getattr(self, "_wide_int_array_cache", None)
+        if cached is not None:
+            return cached
+        # The scan below asks ``_expr_returns_wide_int``, whose receiver typing
+        # resolves collection specs through ``_collection_spec_for_name`` and so
+        # back here: publish the (growing) set first so the recursion reads the
+        # partial answer instead of re-entering, then iterate to the fixpoint so
+        # an array filled from another wide array's elements widens too.
+        names: set[str] = set()
+        self._wide_int_array_cache = names
+
+        def scan(nodes, owner_info):
+            for child in nodes:
+                if isinstance(child, FuncCall):
+                    pair = self._array_receiver_and_value(child)
+                    if pair is not None and self._expr_returns_wide_int(
+                        pair[1], owner_info, set(), None
+                    ):
+                        names.add(pair[0])
+                    continue
+                target = None
+                value = None
+                if isinstance(child, VarDecl):
+                    target, value = child.name, child.value
+                elif (isinstance(child, Assignment)
+                      and isinstance(child.target, Identifier)):
+                    target, value = child.target.name, child.value
+                if target is None or not isinstance(value, FuncCall):
+                    continue
+                fn, ns = self._resolve_callee(value.callee)
+                if ns != "array":
+                    continue
+                candidates = []
+                if fn in ("new_int", "new"):
+                    if fn == "new":
+                        targs = (self._template_args_from_call(value)
+                                 if hasattr(value, "annotations") else [])
+                        if not targs or targs[0] != "int":
+                            continue
+                    if len(value.args) > 1:
+                        candidates.append(value.args[1])
+                    if "initial_value" in value.kwargs:
+                        candidates.append(value.kwargs["initial_value"])
+                elif fn == "from":
+                    candidates = list(value.args)
+                if any(self._expr_returns_wide_int(c, owner_info, set(), None)
+                       for c in candidates):
+                    names.add(target)
+
+        ast = getattr(self.ctx, "ast", None)
+        for _round in range(8):
+            before = len(names)
+            if ast is not None:
+                scan(self._walk_ast(ast), None)
+            for info in getattr(self.ctx, "func_infos", ()):
+                node = getattr(info, "node", None)
+                if node is not None:
+                    scan(self._walk_ast_list(node.body), info)
+            if len(names) == before:
+                break
+        return names
+
+    def _widen_array_spec_for_name(self, name, spec):
+        """``array<int>`` -> ``array<int64>`` when ``name`` is a wide int
+        array; every other spec (and ``None``) passes through unchanged."""
+        if (spec is None or spec.kind != "array" or spec.element is None
+                or spec.element.kind != "primitive"
+                or spec.element.name != "int"):
+            return spec
+        if name in self._wide_int_array_names():
+            return TypeSpec.array(TypeSpec.primitive("int64"))
+        return spec
+
+    def _collection_spec_for_name_raw(self, name: str) -> TypeSpec | None:
         """Resolve collection metadata with lexical precedence.
 
         Source-ordered callable locals shadow loop bindings and parameters once
@@ -417,7 +587,9 @@ class TypeInferer:
                     return TypeSpec.primitive("string")
                 if node.op == "/" or left.name == "float" or right.name == "float":
                     return TypeSpec.primitive("float")
-                if left.name == "int" and right.name == "int":
+                if left.name in ("int", "int64") and right.name in ("int", "int64"):
+                    if "int64" in (left.name, right.name):
+                        return TypeSpec.primitive("int64")
                     return TypeSpec.primitive("int")
             return None
         spec = self._type_spec_from_expr(node)
@@ -976,7 +1148,7 @@ class TypeInferer:
                 "percentrank", "abs", "standardize", "covariance", "binary_search",
                 "binary_search_leftmost", "binary_search_rightmost", "sort_indices",
             }
-            if method in numeric_only and elem_cpp not in ("double", "int"):
+            if method in numeric_only and elem_cpp not in ("double", "int", "int64_t"):
                 self._codegen_error(
                     None,
                     f"array.{method} requires a numeric array",
@@ -1187,7 +1359,7 @@ class TypeInferer:
         # truly untyped slot may consult the per-callsite specialization map.
         spec = declared_spec
         if spec is not None and spec.kind == "primitive":
-            if spec.name == "int":
+            if spec.name in ("int", "int64"):
                 return "int64_t"
             if spec.name == "bool":
                 return "bool"
@@ -1217,7 +1389,7 @@ class TypeInferer:
         specs = list(getattr(func_info, "param_type_specs", ()) or ())
         spec = specs[index] if index < len(specs) else None
         if spec is not None and spec.kind == "primitive":
-            if spec.name == "int":
+            if spec.name in ("int", "int64"):
                 return "int64_t"
             if spec.name == "bool":
                 return "bool"
@@ -1352,8 +1524,25 @@ class TypeInferer:
             return self._expr_is_int64_builtin(expr)
         if self._expr_is_int64_builtin(expr):
             return True
+        if isinstance(expr, (BinOp, UnaryOp)) and self._literal_overflows_int32(expr):
+            # ``90 * 24 * 60 * 60 * 1000``: an int-literal product beyond
+            # int32 is a 64-bit value in Pine (``_pure_int_literal_value``).
+            return True
         if isinstance(expr, FuncCall):
             func_name, namespace = self._resolve_callee(expr.callee)
+            if func_name in self._WIDE_ARRAY_ELEMENT_READS:
+                # An element read off a wide int array (``array.get(times, i)``
+                # / ``times.get(i)``) carries the epoch: the destination must
+                # not narrow it (``_wide_int_array_names``).
+                receiver = None
+                if namespace == "array":
+                    receiver = expr.args[0] if expr.args else expr.kwargs.get("id")
+                elif (isinstance(expr.callee, MemberAccess)
+                      and isinstance(expr.callee.object, Identifier)):
+                    receiver = expr.callee.object
+                if (isinstance(receiver, Identifier)
+                        and receiver.name in self._wide_int_array_names()):
+                    return True
             if namespace is None and func_name in {
                 "int",
                 "float",

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/pineforge_codegen/codegen/visit_call.py

@@ -1555,6 +1555,12 @@ class CallVisitor:
         if namespace == "array":
             if func_name in ("new", "new_float", "new_int", "new_bool", "new_string") or func_name in ARRAY_DRAWING_NEW_CTORS:
                 spec = self._type_spec_from_expr(node) or TypeSpec.array(TypeSpec.primitive("float"))
+                # The constructor of a wide int array (``_wide_int_array_names``)
+                # must spell the declared ``std::vector<int64_t>``: the
+                # declaration site names its target here.
+                target = getattr(self, "_array_ctor_target_name", None)
+                if target is not None:
+                    spec = self._widen_array_spec_for_name(target, spec)
                 cpp_type = self._type_spec_to_cpp(spec)
                 elem_spec = spec.element if spec.element is not None else TypeSpec.primitive("float")
                 init_default = self._default_for_spec(elem_spec)
@@ -1568,6 +1574,9 @@ class CallVisitor:
                 return f"{cpp_type}()"
             if func_name == "from":
                 spec = self._type_spec_from_expr(node) or TypeSpec.array(TypeSpec.primitive("float"))
+                target = getattr(self, "_array_ctor_target_name", None)
+                if target is not None:
+                    spec = self._widen_array_spec_for_name(target, spec)
                 elems = ", ".join(self._visit_expr(a) for a in node.args)
                 return f"{self._type_spec_to_cpp(spec)}{{{elems}}}"
             # Method calls: array.method(arr, args...)

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/pineforge_codegen/codegen/visit_expr.py

@@ -673,26 +673,40 @@ class ExprVisitor:
                     # to dead ``f5``'s first-in-order ``_ta_vwap_10`` and emitted
                     # ``use of undeclared identifier '_ta_vwap_10'``. A live read
                     # must bind to a live site.
-                    for _i, site in enumerate(self.ctx.ta_call_sites):
-                        if _i in self._dead_ta_indices:
+                    # The read's OWN site first (the analyzer keys the
+                    # synthetic call-site on this MemberAccess node), so two
+                    # bare reads are two sites, each advanced once per bar;
+                    # the first-live-site scan below stays as the fallback.
+                    _own = self._get_ta_site(node)
+                    _candidates = (
+                        [(self._ta_index_by_site_id.get(id(_own)), _own)]
+                        if _own is not None else []
+                    ) + list(enumerate(self.ctx.ta_call_sites))
+                    for _i, site in _candidates:
+                        if _i is None or _i in self._dead_ta_indices:
                             continue
                         ta_short = site.class_name.split("::")[-1].lower()
                         if site.member_name.startswith(f"_ta_{node.member}_"):
                             if node.member == "vwap":
                                 # Same implicit tail as TA_IMPLICIT_APPEND["vwap"]:
                                 # the symbol clock keys the Daily anchor reset.
+                                # The bare property is the VWAP of hlc3 (Pine
+                                # v6 reference; lab tv notrade-session-vwap-f1d,
+                                # 2026-09-05: TradingView's read equals hlc3 on
+                                # a daily bar), never of the close.
+                                _hlc3 = "((current_bar_.high + current_bar_.low + current_bar_.close) / 3.0)"
                                 return (
-                                    f"(history_advances_new_bar() ? {site.member_name}.compute("
-                                    "current_bar_.close, current_bar_.volume, current_bar_.timestamp"
+                                    f"(history_advances_new_bar() ? {self._ta_member_name(site)}.compute("
+                                    f"{_hlc3}, current_bar_.volume, current_bar_.timestamp"
                                     " PF_VWAP_SESSION_ANCHOR_ARGS(syminfo_.timezone, syminfo_.session)) "
-                                    f": {site.member_name}.recompute(current_bar_.close, "
+                                    f": {self._ta_member_name(site)}.recompute({_hlc3}, "
                                     "current_bar_.volume, current_bar_.timestamp"
                                     " PF_VWAP_SESSION_ANCHOR_ARGS(syminfo_.timezone, syminfo_.session)))"
                                 )
                             return (
-                                f"(history_advances_new_bar() ? {site.member_name}.compute("
+                                f"(history_advances_new_bar() ? {self._ta_member_name(site)}.compute("
                                 f"{TA_IMPLICIT_COMPUTE_FULL[node.member]}) : "
-                                f"{site.member_name}.recompute("
+                                f"{self._ta_member_name(site)}.recompute("
                                 f"{TA_IMPLICIT_COMPUTE_FULL[node.member]}))"
                             )
                     # No registered call site for this TA property read —
@@ -1037,6 +1051,13 @@ class ExprVisitor:
         return f"({left_cpp} {op} {right_cpp})"
 
     def _visit_binop(self, node: BinOp) -> str:
+        # An int-literal-only ``+ - *`` tree whose exact value leaves int32 is
+        # a 64-bit Pine int (``90 * 24 * 60 * 60 * 1000`` = 7 776 000 000);
+        # C++ ``int`` literal arithmetic would wrap it. Fold it here and spell
+        # the value as a 64-bit literal. In-range trees are emitted as before.
+        folded = self._pure_int_literal_value(node)
+        if folded is not None and not self._int_fits_int32(folded):
+            return f"static_cast<int64_t>({folded}LL)"
         left = self._visit_expr(node.left)
         right = self._visit_expr(node.right)
         cpp_ops = {"and": "&&", "or": "||"}

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/pineforge_codegen/codegen/visit_stmt.py

@@ -495,6 +495,11 @@ class StmtVisitor:
                 )
                 previous_input_name = self._current_input_var_name
                 self._current_input_var_name = node.name
+                # A ``var`` int array that stores epoch milliseconds is declared
+                # ``std::vector<int64_t>``; its one-shot constructor here must
+                # spell the same type (visit_call array.new_* / array.from).
+                previous_ctor_target = getattr(self, "_array_ctor_target_name", None)
+                self._array_ctor_target_name = node.name
                 try:
                     type_spec = info.get("type_spec")
                     target_cpp_type = info.get("drawing_cpp")
@@ -535,6 +540,7 @@ class StmtVisitor:
                         init_cpp = self._visit_expr(node.value)
                 finally:
                     self._current_input_var_name = previous_input_name
+                    self._array_ctor_target_name = previous_ctor_target
                 if info.get("drawing_cpp") is None:
                     init_cpp = self._typed_na_init(
                         init_cpp, member_name, info["ptype"]
@@ -618,13 +624,19 @@ class StmtVisitor:
             func_name, namespace = self._resolve_callee(node.value.callee)
             if namespace == "array" and func_name in ARRAY_NEW_CTORS | {"new", "from", "copy", "slice"}:
                 captured = self._callable_collection_bindings.get(id(node))
-                spec = (
+                spec = self._widen_array_spec_for_name(
+                    node.name,
                     captured
                     if captured is not None and captured.kind == "array"
                     else self._type_spec_from_expr(node.value)
-                        or self._array_spec_for_name(node.name)
+                        or self._array_spec_for_name(node.name),
                 )
-                init = self._visit_expr(node.value)
+                previous_target = getattr(self, "_array_ctor_target_name", None)
+                self._array_ctor_target_name = node.name
+                try:
+                    init = self._visit_expr(node.value)
+                finally:
+                    self._array_ctor_target_name = previous_target
                 self._array_vars.add(node.name)
                 self._collection_types.setdefault(node.name, spec)
                 cpp_type = self._type_spec_to_cpp(spec)

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/pineforge_codegen/symbols.py

@@ -75,7 +75,9 @@ def method_receiver_type_name(spec: TypeSpec | None) -> str | None:
     if spec is None:
         return None
     if spec.kind in {"primitive", "udt"}:
-        return spec.name
+        # A wide (epoch-millisecond) element is still Pine ``int`` to the
+        # source: a user method declared on ``array<int>`` binds to it.
+        return "int" if spec.name == "int64" else spec.name
     if spec.kind == "array" and spec.element is not None:
         element = method_receiver_type_name(spec.element)
         return f"array<{element}>" if element is not None else None
@@ -106,7 +108,7 @@ def method_receiver_cpp_token(
 
     if spec is not None:
         if spec.kind in {"primitive", "udt"} and spec.name:
-            return spec.name
+            return "int" if spec.name == "int64" else spec.name
         if spec.kind == "array" and spec.element is not None:
             return f"array_{method_receiver_cpp_token(spec.element)}"
         if spec.kind == "map" and spec.key is not None and spec.value is not None:

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/tests/test_anchor_vwap.py

@@ -52,11 +52,13 @@ def test_ta_vwap_precalc_path_threads_symbol_clock():
 
 
 def test_ta_vwap_bare_property_read_threads_symbol_clock():
+    # The bare property is the VWAP of hlc3 (tests/test_vwap_property_source.py).
     cpp = transpile(_pine("v = ta.vwap\nw = ta.vwap"))
-    calls = [c for c in _calls(cpp, "compute") if "current_bar_.close" in c and "vwap" in c]
+    hlc3 = "((current_bar_.high + current_bar_.low + current_bar_.close) / 3.0)"
+    calls = [c for c in _calls(cpp, "compute") if hlc3 in c and "vwap" in c]
     assert calls, cpp
     for call in calls:
-        assert "current_bar_.close, current_bar_.volume, current_bar_.timestamp " + SYM_TAIL in call, call
+        assert hlc3 + ", current_bar_.volume, current_bar_.timestamp " + SYM_TAIL in call, call
 
 
 def test_ta_vwap_bands_form_threads_symbol_clock():

{pineforge_codegen-0.10.3 → pineforge_codegen-0.10.4}/tests/test_codegen_new.py

@@ -168,7 +168,7 @@ x = ta.tr(false)
     assert re.search(r"_ta_tr_\d+\(false\)", cpp), cpp
     # Compute is invoked with the bar OHLC implicitly threaded in.
     assert (
-        "_ta_tr_1.compute(current_bar_.high, current_bar_.low, current_bar_.close)"
+        "_ta_tr_1.compute(current_bar_.high, current_bar_.low, current_bar_.close, prev_chart_close())"
         in cpp
     )