@pineforge/codegen-pyodide 0.10.4 → 1.0.0-rc.1

package/pineforge_codegen/codegen/visit_expr.py

@@ -87,8 +87,11 @@ classes from ``..ast_nodes``.
 
 from __future__ import annotations
 
+from ..errors import Phase
+from ..external_requests import UNPINNED_ANNOTATION
 from ..ast_nodes import (
     ASTNode,
+    Assignment,
     BinOp,
     BoolLiteral,
     ColorLiteral,
@@ -103,8 +106,11 @@ from ..ast_nodes import (
     TupleLiteral,
     UnaryOp,
 )
+from .helpers import pine_index_int_cast, unary_sign_cpp
+from .types import COLLECTION_MUTATING_METHODS
 from .tables import (
     ADJUSTMENT_MAP,
+    ALERT_FREQ_VALUES,
     BAR_BUILTINS,
     BAR_FIELDS,
     BAR_SERIES_PUSH,
@@ -180,6 +186,50 @@ _RELATIONAL_OPS: frozenset[str] = frozenset({"==", "!=", "<", ">", "<=", ">="})
 # na-bool is engine-indistinguishable from ``false`` (na<bool>() == false).
 _NA_SCALAR_CPP: frozenset[str] = frozenset({"int", "int64_t", "double"})
 
+# What a binary operand no effect of the other operand can change is built
+# from (``_binop_operand_is_order_free``): literals and variables, these
+# calls, and operators over them.
+_ORDER_FREE_LITERALS = (
+    NumberLiteral, StringLiteral, BoolLiteral, NaLiteral, ColorLiteral,
+)
+_ORDER_FREE_CALL_NAMESPACES = frozenset({"str", "math", "color", "ta"})
+_ORDER_FREE_CALLS = frozenset({"nz", "na", "int", "float", "bool", "string"})
+# Builtin calls with an effect whose order is observable
+# (``_expr_has_ordered_effect``): an order, a log line, a script stop.
+_ORDERED_EFFECT_CALLS: frozenset[tuple[str, str]] = frozenset({
+    ("strategy", "entry"), ("strategy", "order"), ("strategy", "exit"),
+    ("strategy", "close"), ("strategy", "close_all"),
+    ("strategy", "cancel"), ("strategy", "cancel_all"),
+    ("log", "info"), ("log", "warning"), ("log", "error"),
+    ("runtime", "error"),
+})
+# Every call of these namespaces but a ``get_*`` getter creates, copies,
+# changes or deletes a drawing; the method forms are ``set_*``,
+# ``cell_set_*`` and these.
+_DRAWING_EFFECT_NAMESPACES = frozenset({
+    "label", "line", "box", "table", "polyline", "linefill",
+})
+_DRAWING_EFFECT_METHODS = frozenset({"delete", "cell", "merge_cells"})
+
+
+def _ast_children(node):
+    """The AST nodes directly under ``node``: its fields, lists, tuples (a
+    ``switch`` case) and dicts (keyword arguments), not its annotations."""
+    for name, value in vars(node).items():
+        if name not in ("loc", "annotations"):
+            yield from _ast_nodes_in(value)
+
+
+def _ast_nodes_in(value):
+    if isinstance(value, ASTNode):
+        yield value
+    elif isinstance(value, (list, tuple)):
+        for item in value:
+            yield from _ast_nodes_in(item)
+    elif isinstance(value, dict):
+        for item in value.values():
+            yield from _ast_nodes_in(item)
+
 
 class ExprVisitor:
     """Expression-level visitor methods shared across the codegen.
@@ -194,6 +244,16 @@ class ExprVisitor:
     def _visit_expr(self, node: ASTNode | None) -> str:
         if node is None:
             return "/* null */"
+        if self._budget is not None:
+            self._budget_visit_count += 1
+            if self._budget_visit_count % 128 == 0:
+                self._budget.check(node.loc, Phase.CODEGEN)
+        if node.annotations and UNPINNED_ANNOTATION in node.annotations:
+            return self._unpinned_read(node)
+        if self._security_fallback_frame is not None:
+            delegated = self._security_fallback_delegate(node)
+            if delegated is not None:
+                return delegated
         if isinstance(node, NumberLiteral):
             return str(node.value)
         if isinstance(node, StringLiteral):
@@ -213,10 +273,7 @@ class ExprVisitor:
         if isinstance(node, UnaryOp):
             return self._visit_unaryop(node)
         if isinstance(node, Ternary):
-            c = self._visit_expr(node.condition)
-            t = self._visit_expr(node.true_val)
-            f = self._visit_expr(node.false_val)
-            return f"(({c}) ? ({t}) : ({f}))"
+            return self._visit_ternary(node)
         if isinstance(node, FuncCall):
             return self._visit_func_call(node)
         if isinstance(node, Subscript):
@@ -240,9 +297,55 @@ class ExprVisitor:
             return f"std::make_tuple({elems})"
         return "/* unknown */"
 
+    # A ``?:`` chain continued in its false arms (``a ? x : b ? y : z``) of at
+    # least this many links is emitted without the per-link brackets: they add
+    # three bracket levels per link and clang stops at 256
+    # (``-fbracket-depth``).  C++'s conditional operator is right-associative,
+    # so ``a ? x : b ? y : z`` reads ``a ? x : (b ? y : z)``.  Shorter chains
+    # keep their historical spelling byte for byte.
+    _FLAT_TERNARY_CHAIN = 32
+
+    def _visit_ternary(self, node: Ternary) -> str:
+        links = [node]
+        while isinstance(links[-1].false_val, Ternary):
+            links.append(links[-1].false_val)
+        string_na = self._ternary_string_na(links)
+        if len(links) < self._FLAT_TERNARY_CHAIN:
+            c = self._coerce_bool_expr(
+                self._visit_expr(node.condition), node.condition
+            )
+            t = self._ternary_arm(node.true_val, string_na)
+            f = self._ternary_arm(node.false_val, string_na)
+            return f"(({c}) ? ({t}) : ({f}))"
+        arms = []
+        for link in links:
+            c = self._coerce_bool_expr(
+                self._visit_expr(link.condition), link.condition
+            )
+            t = self._ternary_arm(link.true_val, string_na)
+            arms.append(f"({c}) ? ({t}) : ")
+        return f"({''.join(arms)}({self._ternary_arm(links[-1].false_val, string_na)}))"
+
+    def _ternary_string_na(self, links: list[Ternary]) -> bool:
+        """A ``?:`` chain whose every value arm but a bare ``na`` is a
+        string: its ``na`` arm is the string na (``cond ? "BUY" : na``, as
+        libraries return a signal). It used to emit ``na<double>()`` beside a
+        ``std::string``, which does not compile."""
+        arms = [link.true_val for link in links] + [links[-1].false_val]
+        values = [arm for arm in arms if not self._is_na_expr(arm)]
+        if len(values) == len(arms) or not values:
+            return False
+        return all(self._infer_type(arm) == "std::string" for arm in values)
+
+    def _ternary_arm(self, arm, string_na: bool) -> str:
+        if string_na and self._is_na_expr(arm):
+            return "na<std::string>()"
+        return self._visit_expr(arm)
+
     # ------------------------------------------------------------------
     # Target-typed RHS lowering (drawing handles are C++ structs, not doubles)
     # ------------------------------------------------------------------
+
     def _is_na_expr(self, node) -> bool:
         """True for a bare ``na`` (keyword NaLiteral or ``na`` identifier)."""
         return (isinstance(node, NaLiteral)
@@ -341,7 +444,7 @@ class ExprVisitor:
             if drawing_target is not None:
                 return f"{drawing_target}{{}}"
             if target_cpp_type in self._udt_defs:
-                return f"{target_cpp_type}{{}}"
+                return f"{self._safe_name(target_cpp_type)}{{}}"
             if self._is_nullable_collection_cpp_type(target_cpp_type):
                 # Maps and matrices use default construction for a typed
                 # ``na`` ID. Their ``*.new`` factories create a valid ID,
@@ -376,6 +479,30 @@ class ExprVisitor:
             )
         return self._visit_expr(value_node)
 
+    def _unpinned_read(self, node: ASTNode) -> str:
+        """A read of a request no data is pinned for
+        (``external_requests``): the run stops with the request named, and
+        the value the expression would have is only there for its type. A
+        request lowered onto pinned data stops the run so only when its data
+        is missing (``_request_data_missing``)."""
+        notes = node.annotations
+        marker = notes[UNPINNED_ANNOTATION]
+        node.annotations = {k: v for k, v in notes.items() if k != UNPINNED_ANNOTATION}
+        try:
+            value = self._visit_expr(node)
+        finally:
+            node.annotations = notes
+        if isinstance(marker, dict):
+            # Evaluated first: a recorded request sets its flag where it is
+            # evaluated, which may be this read.
+            stop = (f'pine_runtime_error(std::string('
+                    f'"{self._cpp_string_escape(marker["message"])}"))')
+            return (f"([&]() {{ auto _pf_read = {value}; "
+                    f"if ({self._request_data_missing(marker['ref'])}) {stop}; "
+                    f"return _pf_read; }}())")
+        return (f'([&]() {{ pine_runtime_error(std::string("{self._cpp_string_escape(marker)}")); '
+                f"return {value}; }}())")
+
     def _visit_ident(self, node: Identifier) -> str:
         name = node.name
         # Bare 'na' identifier → na<double>()
@@ -406,7 +533,7 @@ class ExprVisitor:
             if isinstance(val, (int, float)):
                 return str(val)
             if isinstance(val, str):
-                return f'std::string("{val}")'
+                return f'std::string("{self._cpp_string_escape(val)}")'
         # TA runtime-reset lowering: an input-backed var renders as its
         # override-aware getter (not the member name), because the reset may
         # run before the input members are initialised (evaluate_security path).
@@ -430,12 +557,11 @@ class ExprVisitor:
             ):
                 return "(int64_t)pine_color::black"
         # Series var — read current value
-        safe = self._safe_name(name)
-        # Apply per-call-site var remap (for function-local vars)
-        if self._active_var_remap and safe in self._active_var_remap:
-            safe = self._active_var_remap[safe]
+        safe = self._call_site_var_name(node, self._safe_name(name))
         if self._binding_is_series(name, safe):
             return f"{safe}[0]"
+        if name in self._nonfinite_int_names() and name not in self._current_func_locals:
+            return self._nonfinite_int_read(safe)
         # Safety net: by here the name resolved to none of the builtins,
         # constants, parameters, or declared variables handled above, so
         # ``return safe`` would emit a bare identifier that is an *undeclared
@@ -457,6 +583,14 @@ class ExprVisitor:
             )
         return safe
 
+    def _nonfinite_int_read(self, safe: str) -> str:
+        """A read of a ``_nonfinite_int_names`` name: an infinity reads na, as
+        the int's ``na<int>()`` did, except as the operand of an ordering
+        comparison (``_visit_binop_operand``), which orders it as the number."""
+        if getattr(self, "_nonfinite_int_raw", False):
+            return safe
+        return f"(std::isfinite({safe}) ? {safe} : na<double>())"
+
     def _ident_is_resolvable(self, name: str) -> bool:
         """True when a bare identifier maps to a builtin, constant, parameter,
         or any declared variable/type/enum/function — i.e. emitting it will not
@@ -499,11 +633,16 @@ class ExprVisitor:
         """Lower an assignment target with UDT journal capture enabled."""
 
         previous = getattr(self, "_udt_mutable_expr_depth", 0)
+        previous_target = getattr(self, "_udt_assignment_target", None)
         self._udt_mutable_expr_depth = previous + 1
+        # A UDT array field assigned rebinds the field itself, not the array
+        # it holds (``_visit_member_access``).
+        self._udt_assignment_target = node
         try:
             return self._visit_expr(node)
         finally:
             self._udt_mutable_expr_depth = previous
+            self._udt_assignment_target = previous_target
 
     def _visit_member_access(self, node: MemberAccess) -> str:
         # UDT field whose type was a drawing primitive (label/line/box/
@@ -540,9 +679,18 @@ class ExprVisitor:
                 or mutable_collection
                 else "read"
             )
-            return f"{arena}.{access}({owner}).{node.member}"
+            field = f"{arena}.{access}({owner}).{self._safe_name(node.member)}"
+            if (self._udt_array_field_cpp(field_spec, owner_spec.name) is not None
+                    and node is not getattr(self, "_udt_assignment_target", None)):
+                # A ``_PFArrayField<T>``: every read, element write and method
+                # call reaches the array it holds.
+                return f"(*{field})"
+            return field
         if isinstance(node.object, Identifier):
             ns = node.object.name
+            if ns == "alert" and node.member in ALERT_FREQ_VALUES:
+                # TradingView's const string values (its own tape spells them).
+                return f'std::string("{ALERT_FREQ_VALUES[node.member]}")'
             if ns == "strategy":
                 # Direction constants
                 if node.member == "long":
@@ -654,7 +802,7 @@ class ExprVisitor:
             if ns == "ta":
                 if node.member == "tr":
                     return ("(std::isnan(_s_close[1]) ? "
-                            "(current_bar_.high - current_bar_.low) : "
+                            "na<double>() : "
                             "std::max(current_bar_.high - current_bar_.low, "
                             "std::max(std::abs(current_bar_.high - _s_close[1]), "
                             "std::abs(current_bar_.low - _s_close[1]))))")
@@ -685,7 +833,6 @@ class ExprVisitor:
                     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"]:
@@ -794,7 +941,7 @@ class ExprVisitor:
                 if node.member == "islast":
                     return "barstate_islast_"
                 if node.member == "isnew":
-                    return "is_first_tick_"
+                    return "is_first_tick()"
                 if node.member == "isconfirmed":
                     return "is_last_tick_"
                 if node.member == "ishistory":
@@ -813,6 +960,11 @@ class ExprVisitor:
             if ns == "adjustment":
                 # adjustment.none / dividends / splits. Unknown member -> "none" (0).
                 return ADJUSTMENT_MAP.get(node.member, "0")
+            if ns == "barmerge":
+                # A barmerge constant held or compared as a value (the
+                # analyzer types it int): on 1, off 0. A request's gaps or
+                # lookahead reads the constant as written.
+                return "1" if node.member in ("gaps_on", "lookahead_on") else "0"
             if ns == "dayofweek":
                 return DAYOFWEEK_MAP.get(node.member, "0")
             if ns == "session":
@@ -820,20 +972,74 @@ class ExprVisitor:
                     return 'std::string("regular")'
                 if node.member == "extended":
                     return 'std::string("extended")'
-                # session.is* predicates backed by engine session_ismarket_ etc.
-                # session.isfirstbar_regular / islastbar_regular are aliased to
-                # their non-_regular counterparts (engine has one session string;
-                # see session_time.hpp limitation comment).
-                if node.member == "ismarket":
-                    return "pine_session_ismarket(syminfo_.session, syminfo_.timezone, current_bar_.timestamp)"
-                if node.member == "ispremarket":
-                    return "pine_session_ispremarket(syminfo_.session, syminfo_.timezone, current_bar_.timestamp)"
-                if node.member == "ispostmarket":
-                    return "pine_session_ispostmarket(syminfo_.session, syminfo_.timezone, current_bar_.timestamp)"
-                if node.member in ("isfirstbar", "isfirstbar_regular"):
+                # session.isfirstbar / islastbar mark the chart's session day,
+                # which the engine widens by the pre- and post-market bars an
+                # extended-hours chart holds, and session.isfirstbar_regular /
+                # islastbar_regular the regular session's day: the host's
+                # session_is*bar_ and session_is*bar_regular_ facts
+                # (tests/test_e2e_session_ismarket.py).
+                if node.member in ("ismarket", "ispremarket", "ispostmarket"):
+                    # A chart bar is in market when the kernel's in-session
+                    # fact holds it (session_ismarket_): the bar read at its
+                    # interval's first eligible instant, so a bar that opens
+                    # in a break and holds the reopen is in market, as
+                    # TradingView's TSE:7203 and CBOT:ZC1! 60-minute tapes
+                    # flag it, and a D/W/M bar is
+                    # (tests/test_e2e_session_windows.py). A run without a
+                    # timeframe gets no such fact (script_tf_ is empty); there
+                    # the session calendar answers at the bar's open
+                    # (codegen/session_market.py). The time-of-day predicates
+                    # read the instant alone: ismarket's reads a bar that
+                    # opens in a break out of market, and until engine lane
+                    # W11-ENG-TIME-COLOR it also missed the Sunday-evening
+                    # open of a ":23456" session and every "0000-2400" bar
+                    # (tests/test_e2e_session_ismarket.py).
+                    # A bar in market is in neither extended session; off it,
+                    # the engine's windows decide. A request.security payload
+                    # runs on its own bars, whose timeframe the chart's facts
+                    # do not describe, so it keeps the predicates at the
+                    # security bar's time, with a warning.
+                    args = "(syminfo_.session, syminfo_.timezone, current_bar_.timestamp)"
+                    predicate = f"pine_session_{node.member}{args}"
+                    if self._security_payload_depth:
+                        if id(node) not in self._warned_security_session_sites:
+                            self._warned_security_session_sites.add(id(node))
+                            # A bar that opens in a break and holds the reopen
+                            # is in market (the chart's reading); pre- and
+                            # post-market read a break as neither. A D/W/M bar
+                            # holds whole session days, where the predicate
+                            # reads its open's time of day.
+                            daily = {"ismarket": "always in market",
+                                     "ispremarket": "never pre-market",
+                                     "ispostmarket": "never post-market"}[node.member]
+                            opens = ("a bar that opens in a session break and holds "
+                                     "the reopen reads as out of market, and "
+                                     if node.member == "ismarket" else "")
+                            self._codegen_warning(
+                                node,
+                                f"session.{node.member} inside request.security keeps "
+                                "the time-of-day predicate at the security bar's open "
+                                f"time, which can differ from TradingView: {opens}"
+                                f"a D/W/M bar, {daily} on TradingView, reads its "
+                                "open's time of day. The chart's own session flags "
+                                "read the engine's session facts.",
+                            )
+                        return predicate
+                    self._uses_session_market = True
+                    ismarket = ("(script_tf_.empty() ? _pf_session_market_(syminfo_.session, "
+                                "syminfo_.timezone, script_tf_, current_bar_.timestamp) "
+                                ": session_ismarket_)")
+                    if node.member == "ismarket":
+                        return ismarket
+                    return f"(!{ismarket} && {predicate})"
+                if node.member == "isfirstbar":
                     return "session_isfirstbar_"
-                if node.member in ("islastbar", "islastbar_regular"):
+                if node.member == "islastbar":
                     return "session_islastbar_"
+                if node.member == "isfirstbar_regular":
+                    return "session_isfirstbar_regular_"
+                if node.member == "islastbar_regular":
+                    return "session_islastbar_regular_"
                 return "false"
             if ns == "syminfo":
                 _syminfo = SYMINFO_MEMBER_MAP.get(node.member)
@@ -916,7 +1122,10 @@ class ExprVisitor:
             if name in self._enum_defs:
                 members = self._enum_defs[name]
                 if node.member in members:
-                    return f"{name}_{node.member}"
+                    return (
+                        f"{self._safe_name(name)}_"
+                        f"{self._safe_name(node.member)}"
+                    )
 
         # Unknown member access — emit as string constant (e.g., enum values)
         obj = self._visit_expr(node.object)
@@ -935,9 +1144,9 @@ class ExprVisitor:
                 or name in self._current_func_locals
                 or name in self._udt_var_types
             ):
-                safe = self._safe_name(name)
-                if self._active_var_remap and safe in self._active_var_remap:
-                    safe = self._active_var_remap[safe]
+                safe = self._call_site_var_name(
+                    node.object, self._safe_name(name)
+                )
                 return f"{safe}.{node.member}"
             if name not in self.ctx.series_vars:
                 # Unknown identifier — likely an enum value
@@ -1026,6 +1235,23 @@ class ExprVisitor:
             f"({compare}); }}())"
         )
 
+    def _relational_wrapper(self, op: str, left_node, right_node) -> str | None:
+        """The wrapper ``_lower_relational`` gives a relational: ``"float"``
+        (the fixed-band comparator), ``"int"`` (the KI-71 na comparator) or
+        None (the plain C++ operator). Both wrappers bind each operand once,
+        the left one first."""
+        if op in _RELATIONAL_OPS:
+            lt = self._infer_type(left_node)
+            rt = self._infer_type(right_node)
+            if lt in _NA_SCALAR_CPP and rt in _NA_SCALAR_CPP:
+                if "double" in (lt, rt):
+                    return "float"
+                lk = self._operand_na_kind(left_node, lt)
+                rk = self._operand_na_kind(right_node, rt)
+                if "int" in (lk, rk):
+                    return "int"
+        return None
+
     def _lower_relational(self, op: str, left_node, right_node,
                           left_cpp: str, right_cpp: str) -> str:
         """Lower a Pine relational with Pine's na and float-precision rules.
@@ -1037,17 +1263,11 @@ class ExprVisitor:
         KI-71 wrapper only when an operand can carry the INT_MIN ``na`` sentinel.
         Non-relational operators and nonnumeric operands fall through unchanged.
         """
-        if op in _RELATIONAL_OPS:
-            lt = self._infer_type(left_node)
-            rt = self._infer_type(right_node)
-            if lt in _NA_SCALAR_CPP and rt in _NA_SCALAR_CPP:
-                if "double" in (lt, rt):
-                    return self._emit_float_relational(op, left_cpp, right_cpp)
-                lk = self._operand_na_kind(left_node, lt)
-                rk = self._operand_na_kind(right_node, rt)
-                int_na = "int" in (lk, rk)
-                if int_na:
-                    return self._emit_na_relational(op, left_cpp, right_cpp)
+        wrapper = self._relational_wrapper(op, left_node, right_node)
+        if wrapper == "float":
+            return self._emit_float_relational(op, left_cpp, right_cpp)
+        if wrapper == "int":
+            return self._emit_na_relational(op, left_cpp, right_cpp)
         return f"({left_cpp} {op} {right_cpp})"
 
     def _visit_binop(self, node: BinOp) -> str:
@@ -1056,12 +1276,237 @@ class ExprVisitor:
         # 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):
+        if (folded is not None and not self._int_fits_int32(folded)
+                and self._int_fits_int64(folded)):
             return f"static_cast<int64_t>({folded}LL)"
-        left = self._visit_expr(node.left)
-        right = self._visit_expr(node.right)
+        if node.op in ("%", "/"):
+            # Both lower through doubles, which hold an int product's exact
+            # value: compute a product operand in 64 bits (``_lower_binop``).
+            for operand in (node.left, node.right):
+                if isinstance(operand, BinOp) and operand.op == "*":
+                    self._wide_int_products.add(id(operand))
+        left = self._visit_binop_operand(node.left, node.op)
+        right = self._visit_binop_operand(node.right, node.op)
+        if (self._int_arith_leaves_int32(node)
+                and self._fold_int32_overflow_cpp(node.op, left, right) is None):
+            # Both operands are 32-bit C++ ints and the value can leave
+            # int32: Pine's int is 64-bit (``days * 86400000``). Operands the
+            # C++ spells as int literals keep their fold (``_lower_binop``).
+            return self._left_operand_first(
+                node, left, right,
+                lambda left, right: self._wide_int_arith_cpp(
+                    node, left, right,
+                    lambda left, right: self._lower_binop(node, left, right, widened=True)),
+            )
+        return self._left_operand_first(
+            node, left, right,
+            lambda left, right: self._lower_binop(node, left, right),
+        )
+
+    def _visit_binop_operand(self, operand, op: str) -> str:
+        """An operand's C++. An ordering comparison reads a
+        ``_nonfinite_int_names`` name's infinity as the number TradingView
+        orders it by (``_nonfinite_int_read``)."""
+        if (op in self.NONFINITE_INT_ORDERING_OPS
+                and isinstance(operand, Identifier)
+                and operand.name in self._nonfinite_int_names()):
+            previous = getattr(self, "_nonfinite_int_raw", False)
+            self._nonfinite_int_raw = True
+            try:
+                return self._visit_expr(operand)
+            finally:
+                self._nonfinite_int_raw = previous
+        return self._visit_expr(operand)
+
+    def _left_operand_first(self, node: BinOp, left: str, right: str, lower) -> str:
+        """``lower(left, right)``: the C++ of ``node`` over its rendered
+        operands, with the left one evaluated first when
+        ``_binop_operands_need_order(node)``.
+
+        Pine evaluates the left operand first. C++ leaves the order of the
+        operands of + - * / % and of an overloaded operator (std::string's
+        + and ==, std::fmod's arguments) unspecified; GCC on x86-64 evaluates
+        std::string's operator+ right operand first. Bind the left operand's
+        value (a bool as bool: a std::vector<bool> element reads through a
+        proxy), then evaluate the right operand. Shared by ``_visit_binop``
+        and the ``request.security`` expression builder."""
+        if not self._binop_operands_need_order(node):
+            return lower(left, right)
+        occupied = f"{left}\n{right}"
+        counter = getattr(self, "_binop_lhs_counter", 0)
+        while True:
+            token = f"__pf_binop_lhs_{counter}"
+            counter += 1
+            if token not in occupied:
+                break
+        self._binop_lhs_counter = counter
+        decl = "bool" if self._infer_type(node.left) == "bool" else "auto"
+        return f"[&]{{ {decl} {token} = ({left}); return {lower(token, right)}; }}()"
+
+    def _binop_operands_need_order(self, node: BinOp) -> bool:
+        """Whether the C++ of ``node`` must evaluate its left operand first:
+        one operand has an effect (``_expr_has_ordered_effect``) the other
+        one can observe (it is not ``_binop_operand_is_order_free``), and the
+        lowering does not already order them (``&&`` / ``||`` and the
+        relational wrappers do)."""
+        if node.op in ("and", "or"):
+            return False
+        if not (
+            (self._expr_has_ordered_effect(node.left)
+             and not self._binop_operand_is_order_free(node.right))
+            or (self._expr_has_ordered_effect(node.right)
+                and not self._binop_operand_is_order_free(node.left))
+        ):
+            return False
+        return self._relational_wrapper(node.op, node.left, node.right) is None
+
+    def _binop_operand_is_order_free(self, node) -> bool:
+        """Whether no effect of the other operand can change ``node``'s value:
+        a literal, a variable (a Pine function cannot assign a script
+        variable, and no collection is an operand of a binary operator), or a
+        ``str.*`` / ``math.*`` / ``color.*`` / ``ta.*`` call, ``nz`` / ``na``
+        / a cast, or a unary, binary or conditional operation over such
+        operands (a TA call's state is its call site's own)."""
+        pending = [node]
+        while pending:
+            current = pending.pop()
+            if isinstance(current, (*_ORDER_FREE_LITERALS, Identifier)):
+                continue
+            if isinstance(current, UnaryOp):
+                pending.append(current.operand)
+            elif isinstance(current, BinOp):
+                pending.extend((current.left, current.right))
+            elif isinstance(current, Ternary):
+                pending.extend(
+                    (current.condition, current.true_val, current.false_val)
+                )
+            elif isinstance(current, FuncCall) and self._call_is_order_free(current):
+                pending.extend(current.args)
+                pending.extend(current.kwargs.values())
+            else:
+                return False
+        return True
+
+    def _call_is_order_free(self, node: FuncCall) -> bool:
+        callee = node.callee
+        if isinstance(callee, Identifier):
+            return (callee.name in _ORDER_FREE_CALLS
+                    and callee.name not in self._func_info_map)
+        return (isinstance(callee, MemberAccess)
+                and isinstance(callee.object, Identifier)
+                and callee.object.name in _ORDER_FREE_CALL_NAMESPACES)
+
+    def _expr_has_ordered_effect(self, node) -> bool:
+        """Whether evaluating ``node`` changes what another operand of the same
+        expression can read, or does something whose order is observable: it
+        mutates an array, map or matrix (``COLLECTION_MUTATING_METHODS``),
+        creates, changes or deletes a drawing, places or cancels an order,
+        writes a log line or an alert, stops the script, or calls a user
+        function or method that does one of these or assigns a UDT field.
+
+        TA state and ``var`` state belong to their own call site and
+        ``math.random`` draws from its call site's own stream, so none of
+        them is such an effect. A method call is judged by its name alone
+        (every UDT method of that name counts), since the receiver's type is
+        not resolved here.
+
+        The walk is iterative (it adds no recursion depth to the visitor
+        that asks) and reuses the answer of every expression asked before:
+        an operator chain asks each of its operands once."""
+        memo = getattr(self, "_ordered_effect_memo", None)
+        if memo is None:
+            memo = self._ordered_effect_memo = {}
+        hit = memo.get(id(node))
+        if hit is not None and hit[0] is node:
+            return hit[1]
+        result = False
+        pending = [node]
+        while pending:
+            current = pending.pop()
+            hit = memo.get(id(current))
+            if hit is not None and hit[0] is current:
+                if hit[1]:
+                    result = True
+                    break
+                continue
+            if (isinstance(current, FuncCall)
+                    and self._call_has_ordered_effect(current)) or (
+                    isinstance(current, Assignment)
+                    and isinstance(current.target, MemberAccess)):
+                result = True
+                break
+            pending.extend(_ast_children(current))
+        memo[id(node)] = (node, result)
+        return result
+
+    def _call_has_ordered_effect(self, node: FuncCall) -> bool:
+        """The call itself (not its arguments) is an ordered effect."""
+        callee = node.callee
+        if isinstance(callee, Identifier):
+            if callee.name in self._func_info_map:
+                return self._callable_has_ordered_effect(callee.name)
+            return callee.name == "alert"
+        if not isinstance(callee, MemberAccess):
+            return False
+        member = callee.member
+        owner = callee.object
+        if member in COLLECTION_MUTATING_METHODS:
+            return True
+        if isinstance(owner, Identifier):
+            if (owner.name, member) in _ORDERED_EFFECT_CALLS:
+                return True
+            if (owner.name in _DRAWING_EFFECT_NAMESPACES
+                    and not member.startswith("get_")):
+                return True
+        if (isinstance(owner, MemberAccess) and owner.member == "risk"
+                and isinstance(owner.object, Identifier)
+                and owner.object.name == "strategy"):
+            return True
+        if (member.startswith(("set_", "cell_set_"))
+                or member in _DRAWING_EFFECT_METHODS):
+            return True
+        methods = getattr(self, "_udt_method_keys_by_name", None)
+        if methods is None:
+            methods = self._udt_method_keys_by_name = {}
+            for key, info in self._func_info_map.items():
+                if getattr(info, "is_udt_method", False):
+                    methods.setdefault(key.rsplit(".", 1)[-1], []).append(key)
+        return any(
+            self._callable_has_ordered_effect(key)
+            for key in methods.get(member, ())
+        )
+
+    def _callable_has_ordered_effect(self, key: str) -> bool:
+        """Whether a user function or method's body has an ordered effect."""
+        memo = getattr(self, "_callable_effect_memo", None)
+        if memo is None:
+            memo = self._callable_effect_memo = {}
+        if key not in memo:
+            memo[key] = False  # while its body is walked
+            func_node = getattr(self._func_info_map.get(key), "node", None)
+            memo[key] = func_node is not None and any(
+                self._expr_has_ordered_effect(stmt) for stmt in func_node.body
+            )
+        return memo[key]
+
+    def _lower_binop(self, node: BinOp, left: str, right: str, widened: bool = False) -> str:
+        """The C++ of ``node`` over its rendered operands; ``widened`` when
+        ``_visit_binop`` computes it in 64 bits already (``left`` cast)."""
         cpp_ops = {"and": "&&", "or": "||"}
         op = cpp_ops.get(node.op, node.op)
+        if node.op in ("and", "or"):
+            # Pine converts numeric operands to two-state booleans before
+            # applying short-circuit logic.  C++ treats NaN and INT_MIN as
+            # true, so both operands need the same na-aware truthiness rule.
+            left = self._coerce_bool_expr(left, node.left)
+            right = self._coerce_bool_expr(right, node.right)
+            if self._pine_v5_body:
+                # v5 evaluates both operands, left then right, whatever the
+                # left one decides (TradingView: a stateful right operand
+                # runs on every bar).
+                return (f"([&]() -> bool {{ const bool _pf_v5_l = ({left}); "
+                        f"const bool _pf_v5_r = ({right}); "
+                        f"return _pf_v5_l {op} _pf_v5_r; }}())")
         if node.op == "+":
             lt = self._infer_type(node.left)
             rt = self._infer_type(node.right)
@@ -1083,37 +1528,244 @@ class ExprVisitor:
         # Ref: https://www.tradingview.com/pine-script-docs/concepts/operators/
         if node.op == "/":
             return f"((double)({left}) / (double)({right}))"
+        if node.op in ("==", "!=") and self._pine_v5_body:
+            self._refuse_v5_bool_na_observer(
+                node, f"'{node.op}'", (node.left, node.right))
+        # Operands that render as C++ ``int`` literal arithmetic although
+        # the tree above did not fold (a name spelled otherwise than
+        # ``_inlined_int_constant`` reads it): a result beyond int32 is a
+        # 64-bit Pine int, never a C++ overflow.
+        folded_cpp = self._fold_int32_overflow_cpp(node.op, left, right)
+        if folded_cpp is not None:
+            return folded_cpp
+        if (node.op == "*" and not widened and id(node) in self._wide_int_products
+                and self._pure_int_literal_value(node) is None
+                and self._emits_int32(node.left) and self._emits_int32(node.right)):
+            # Pine's int is 64-bit. A product a ``%`` or ``/`` reads reaches a
+            # double whole, where the C++ ``int`` product wrapped: the
+            # Park-Miller step ``(s * 48271) % 2147483647``
+            # (``fixtures/tail_f_tv/int_product``). A product that can leave
+            # int32 by its operands' bounds is ``widened`` already, na-aware
+            # (``_visit_binop``, ``_wide_int_arith_cpp``), and keeps that
+            # spelling; this covers the rest a ``%`` or ``/`` reads (an
+            # ``array.get`` operand, which the bounds do not know).
+            return f"((int64_t)({left}) * ({right}))"
         return self._lower_relational(op, node.left, node.right, left, right)
 
+    def _emits_int32(self, node) -> bool:
+        """Whether ``node`` is emitted as a C++ ``int`` for certain: an int
+        literal, a name stored as ``int``, an element of an ``array<int>``
+        (read or iterated), or a sign, sum or difference of those."""
+        if isinstance(node, NumberLiteral):
+            return isinstance(node.value, int) and not isinstance(node.value, bool)
+        if isinstance(node, UnaryOp) and node.op in ("-", "+"):
+            return self._emits_int32(node.operand)
+        if isinstance(node, BinOp) and node.op in ("+", "-"):
+            return self._emits_int32(node.left) and self._emits_int32(node.right)
+        if isinstance(node, Identifier):
+            if node.name in getattr(self, "_current_loop_vars", set()):
+                # A ``for ... in`` element: an int only over an ``array<int>``.
+                spec = getattr(self, "_current_loop_var_specs", {}).get(node.name)
+                return (spec is not None and spec.kind == "primitive"
+                        and self._type_spec_to_cpp(spec) == "int")
+            return (not self._emitted_value_is_double(node)
+                    and self._slot_scalar_cpp_type(node.name) == "int"
+                    and self._infer_type(node) == "int")
+        if isinstance(node, FuncCall):
+            callee = node.callee
+            if not isinstance(callee, MemberAccess) or callee.member != "get":
+                return False
+            receiver = (callee.object if not (
+                isinstance(callee.object, Identifier) and callee.object.name == "array")
+                else (node.args[0] if node.args else None))
+            if not isinstance(receiver, Identifier):
+                return False
+            spec = self._collection_spec_for_name(receiver.name)
+            return (spec is not None and spec.kind == "array" and spec.element is not None
+                    and self._type_spec_to_cpp(spec.element) == "int")
+        return False
+
+    def _refuse_v5_bool_na_observer(self, node, what: str, operands) -> None:
+        """A v5 bool can be na (a comparison with na, an na literal, a bool's
+        history before the first bar); PineForge's bool cannot. It reads as
+        false wherever v5 casts it to a bool (TradingView's tape of
+        ``xc_v5_lib``), but ``na()``, ``nz()``, ``fixnan()``,
+        ``str.tostring``/``str.format`` and ``==``/``!=`` of a bool tell the
+        third state apart (a v5 probe's tape outside this repository:
+        ``na(b)`` true, ``b == false`` na)."""
+        if any(self._infer_type(o) == "bool" for o in operands if o is not None):
+            library = (getattr(node.loc, "file", None) or "a v5 library")
+            self._codegen_error(
+                node,
+                f"library '{library}' is //@version=5: {what} of a bool reads "
+                "v5's third bool state (na), which PineForge's two-state bool "
+                "does not keep",
+            )
+
     def _visit_unaryop(self, node: UnaryOp) -> str:
         operand = self._visit_expr(node.operand)
         if node.op == "not":
-            return f"!({operand})"
-        return f"({node.op}{operand})"
+            return f"!({self._coerce_bool_expr(operand, node.operand)})"
+        return unary_sign_cpp(node.op, operand)
+
+    def _visit_session_history(self, node: Subscript, series_idx: str) -> str:
+        """``session.<flag>[k]``: the value the flag had k bars ago at the top
+        level of the script, k calls ago in a function body.
+
+        TradingView's tapes (``tests/test_e2e_session_history.py``) read a
+        top-level offset by bars, in a block and on a lazy operand too, and a
+        function body's by the calls of its call site, whichever operand or
+        block holds the read. A top-level read indexes the flag's Series,
+        pushed on every chart bar (``_prescan_session_history``); a function
+        body's indexes its emitted call site's Series, pushed at the function's
+        entry (``_prepare_inline_history_members``). A request.security
+        expression that reaches the read through its own operators builds it
+        on the requested clock (security.py); one that reaches it through a
+        call's argument or a variable has no such history here and is refused
+        at the read. So is a read emitted in a function the analyzer lists in
+        ``session_history_unsafe`` (a method, or a function a method, a
+        request.security expression or a UDT field default reaches), and one
+        with no registered Series: never shared state. The refusal waits for
+        the C++ (``_settle_session_reads``): a read in an argument the codegen
+        renders and leaves out refuses nothing. A read in a function this
+        analysis did not clone (``session_uncloned``) asks for its clones
+        instead.
+        """
+        flag = node.object.member
+        where = next((n for n in (node, node.index, node.object)
+                      if getattr(n, "loc", None) is not None), node)
+        if self._security_payload_depth:
+            return self._refused_session_read(
+                node, where,
+                f"session.{flag}[...] cannot be read here: PineForge keeps a session "
+                "flag's history on the requested clock only for a read the "
+                "request.security expression reaches through its own operators, "
+                "not through a call's argument, a function or a variable.",
+            )
+        owner = self._session_call_owner.get(id(node))
+        if owner is not None:
+            why = (getattr(self.ctx, "session_history_unsafe", None) or {}).get(owner)
+            if why:
+                return self._refused_session_read(
+                    node, where,
+                    f"session.{flag}[...] cannot be read in {owner.split('.')[-1]}(), "
+                    f"{why}: PineForge keeps a session flag's history in a function by "
+                    "each of its call sites, and cannot tell this one apart.",
+                )
+            member = self._inline_history_member_by_key.get(
+                ("session_call", owner, flag, self._current_instance_name))
+            if member is not None:
+                return f"{member}[{series_idx}]"
+        elif flag in self._session_history_flags:
+            return f"{self._session_history_member(flag)}[{series_idx}]"
+        uncloned = getattr(self.ctx, "session_uncloned", None) or ()
+        return self._refused_session_read(
+            node, where,
+            f"session.{flag}[...] is not supported here: PineForge keeps a session "
+            "flag's history for the script's top level, a function body and a "
+            "request.security expression that reads it.",
+            owner if owner in uncloned else None,
+        )
+
+    def _refused_session_read(self, node: Subscript, where, message: str,
+                              uncloned: str | None = None) -> str:
+        """A stand-in for a ``session.<flag>[k]`` read PineForge keeps no
+        history for: a name only this read spells, the refusal raised (or, in
+        the uncloned function ``uncloned``, its clones asked for) if the
+        emitted code holds it (``_settle_session_reads``)."""
+        key = (id(node), message)
+        name = self._refused_session_read_names.get(key)
+        if name is None:
+            name = self._allocate_generated_cpp_name(
+                f"_refused_session_read_{len(self._refused_session_reads) + 1}",
+                self._session_names_used)
+            self._refused_session_read_names[key] = name
+            self._refused_session_reads[name] = (node, where, message, uncloned)
+        return name
+
+    def _call_site_var_name(self, node: Identifier, safe: str) -> str:
+        """``safe`` as this read names it under the active var remap.
+
+        In a callable body the clone remap lists every callable's history and
+        ``var`` members, for nested instances to compose, so it only renames a
+        local binding. A read the analyzer resolved to a script-scope binding
+        (also before a same-named local shadows it), a loop binder or a
+        parameter keeps its own name: renaming ``src`` to another callable's
+        ``src_cs1``, which nothing writes, read ``na``. Outside callables the
+        remap holds block-scoped renames only, which a top-level branch
+        binding resolved to the global scope still needs.
+        """
+        if not self._active_var_remap or safe not in self._active_var_remap:
+            return safe
+        if getattr(self, "_active_func_name", None) is not None and (
+            self.ctx.identifier_binding_scopes.get(id(node)) == "global"
+            or node.name in self._current_loop_vars
+            or node.name in self._current_func_param_types
+        ):
+            return safe
+        return self._active_var_remap[safe]
+
+    def _history_offset_cpp(self, idx: str, index_node) -> str:
+        """The ``int`` offset of a history read, safe right after a ``[``.
+
+        A double index narrows through the na-preserving lambda
+        ``[&](){ ... }()`` (``_coerce_int_slot``); spelled straight after a
+        subscript's ``[`` it reads ``[[``, which C++ parses as an attribute,
+        so a lambda offset is parenthesized. TradingView truncates a
+        fractional index toward zero (``x[5.5]`` reads ``x[5]``), as the
+        cast does.
+        """
+        idx_int = self._coerce_int_slot(idx, index_node, "int")
+        if (idx_int == idx
+                and not self._emitted_value_is_double(index_node)):
+            idx_int = pine_index_int_cast(idx)
+        if idx_int.startswith("["):
+            idx_int = f"({idx_int})"
+        return idx_int
 
     def _visit_subscript(self, node: Subscript) -> str:
         idx = self._visit_expr(node.index)
+        # Series::operator[] accepts C++ int. A Pine int can be backed by an
+        # int64_t timestamp slot; implicitly narrowing its na sentinel to int
+        # turns it into zero on arm64 and reads the current bar. Preserve the
+        # original value type before narrowing every dynamic series offset.
+        series_idx = (
+            idx if (isinstance(node.index, NumberLiteral)
+                    and isinstance(node.index.value, int))
+            else pine_index_int_cast(idx)
+        )
         if isinstance(node.object, Identifier):
             name = node.object.name
+            # A script variable read through history in a plain UDF body: the
+            # call site's own history of it.
+            if id(node) in self.ctx.func_global_history_nodes:
+                member = self._function_global_history_member(name)
+                if member is not None:
+                    return f"{member}[{series_idx}]"
             # Function parameters that are series — src[N] → src[N]
             if name in self._current_func_series_params:
-                return f"{self._safe_name(name)}[{idx}]"
+                return f"{self._safe_name(name)}[{series_idx}]"
             # Function parameters are scalars — src[0] → src, src[N>0] → src
             if name in self._current_func_param_types:
                 return self._safe_name(name)
             if name in BAR_FIELDS or name in BAR_SERIES_PUSH:
                 # Index matches Pine: [0] current bar, [k] k bars ago (runtime Series deque).
-                return f"_s_{name}[{idx}]"
-            safe = self._safe_name(name)
+                return f"_s_{name}[{series_idx}]"
             # Apply per-call-site / exact block-member remap before deciding
             # whether the current lexical binding is a Series.
-            if self._active_var_remap and safe in self._active_var_remap:
-                safe = self._active_var_remap[safe]
+            safe = self._call_site_var_name(node.object, self._safe_name(name))
             if self._binding_is_series(name, safe):
                 # Same Pine [k] semantics as Series in runtime/series.hpp
-                return f"{safe}[{idx}]"
+                return f"{safe}[{series_idx}]"
             spec = self._collection_spec_for_name(name)
             if spec is not None and spec.kind in ("array", "map"):
+                self._codegen_warning(
+                    node,
+                    f"{spec.kind} history indexing uses the current collection "
+                    "element in PineForge; the engine does not retain per-bar "
+                    "collection IDs, so this result can differ from TradingView "
+                    "and a missing index is not represented faithfully.",
+                )
                 return f"{self._collection_receiver_expr(name)}[{idx}]"
         # Handle strategy.* history access (e.g., strategy.position_size[1])
         if isinstance(node.object, MemberAccess):
@@ -1125,7 +1777,9 @@ class ExprVisitor:
                     series_name = f"_strat_{member}"
                     if series_name not in self._strategy_series_vars:
                         self._strategy_series_vars.add(series_name)
-                    return f"{series_name}[{idx}]"
+                    return f"{series_name}[{series_idx}]"
+        if self._is_session_flag(node.object):
+            return self._visit_session_history(node, series_idx)
         # History reference applied directly to an inline call result, e.g.
         # ``ta.highest(high, 10)[1]`` or ``f()[2]``. In Pine the call yields a
         # series, so ``[k]`` reads its value k bars ago — but the call lowers to
@@ -1144,7 +1798,8 @@ class ExprVisitor:
             # previous chart bar in every run mode (``_lazy_edge_ta_hoist_plan``).
             hoisted_member = self._hoisted_hist_reads.get(id(node))
             if hoisted_member is not None:
-                return f"{hoisted_member}[(int)({idx})]"
+                idx_int = self._history_offset_cpp(idx, node.index)
+                return f"{hoisted_member}[{idx_int}]"
             inner = self._visit_expr(node.object)
             cpp_t = self._infer_type(node.object)
             if cpp_t not in ("double", "int", "int64_t", "bool"):
@@ -1175,6 +1830,7 @@ class ExprVisitor:
                 # established call-local history fallback below.
                 ta_mem = self._ta_member_name(ta_site)
                 precalc = f"_precalc_{ta_mem}"
+                idx_int = self._history_offset_cpp(idx, node.index)
                 return (
                     f"([&]() -> {cpp_t} {{ "
                     f"if (_use_precalc) {{ "
@@ -1196,15 +1852,39 @@ class ExprVisitor:
                     f"{cpp_t} _hv = ({inner}); "
                     f"if (history_advances_new_bar()) {member}.push(_hv); "
                     f"else {member}.update(_hv); "
-                    f"return {member}[(int)({idx})]; }}())"
+                    f"return {member}[{idx_int}]; }}())"
                 )
+            idx_int = self._history_offset_cpp(idx, node.index)
             return (
                 f"([&]() -> {cpp_t} {{ "
                 f"{cpp_t} _hv = ({inner}); "
                 f"if (history_advances_new_bar()) {member}.push(_hv); "
                 f"else {member}.update(_hv); "
-                f"return {member}[(int)({idx})]; }}())"
+                f"return {member}[{idx_int}]; }}())"
+            )
+        # History on an operator expression (``(a > b)[1]``) reads the value
+        # the expression had k bars ago: its prepass-registered synthetic
+        # Series (``_is_compound_history_object``) is pushed once per
+        # evaluation, like the inline call results above.
+        compound_member = (
+            self._inline_history_member_by_key.get(
+                ("hist_call", id(node), self._current_instance_name)
             )
+            if isinstance(node.object, (BinOp, UnaryOp, Ternary))
+            else None
+        )
+        if compound_member is not None:
+            cpp_t = self._infer_type(node.object)
+            if cpp_t in ("double", "int", "int64_t", "bool"):
+                inner = self._visit_expr(node.object)
+                idx_int = self._history_offset_cpp(idx, node.index)
+                return (
+                    f"([&]() -> {cpp_t} {{ "
+                    f"{cpp_t} _hv = ({inner}); "
+                    f"if (history_advances_new_bar()) {compound_member}.push(_hv); "
+                    f"else {compound_member}.update(_hv); "
+                    f"return {compound_member}[{idx_int}]; }}())"
+                )
         obj = self._visit_expr(node.object)
         # If subscripting a non-series variable (e.g., function parameter),
         # src[0] → src (current value), src[N>0] → src (can't access history)
@@ -1214,4 +1894,5 @@ class ExprVisitor:
                     and name not in self.ctx.series_vars
                     and name not in self._var_names):
                 return obj
-        return f"{obj}[{idx}]"
+        idx_int = self._history_offset_cpp(idx, node.index)
+        return f"{obj}[{idx_int}]"