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

package/pineforge_codegen/codegen/visit_stmt.py

@@ -73,6 +73,7 @@ classes from ``..ast_nodes``.
 
 from __future__ import annotations
 
+from ..errors import Phase
 from ..ast_nodes import (
     ASTNode,
     Assignment,
@@ -99,6 +100,7 @@ from ..ast_nodes import (
     WhileStmt,
 )
 from ..symbols import PineType, TypeSpec, method_receiver_type_name
+from ..external_requests import UNPINNED_ANNOTATION
 from .tables import (
     ARRAY_NEW_CTORS,
     DRAWING_TYPE_TO_CPP,
@@ -123,6 +125,10 @@ class StmtVisitor:
     # ------------------------------------------------------------------
 
     def _visit_stmt(self, node: ASTNode, lines: list[str], indent: int) -> None:
+        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)
         pad = "    " * indent
 
         if isinstance(node, StrategyDecl):
@@ -346,35 +352,44 @@ class StmtVisitor:
                         and node.expr.args):
                     risk_func = c.member
                     _RISK_MEMBER_MAP = {
-                        "max_intraday_filled_orders": ("max_intraday_filled_orders_", "int"),
-                        "max_drawdown": ("risk_max_drawdown_", "double"),
-                        "max_intraday_loss": ("risk_max_intraday_loss_", "double"),
-                        "max_position_size": ("risk_max_position_size_", "double"),
-                        "max_cons_loss_days": ("risk_max_cons_loss_days_", "int"),
+                        "max_intraday_filled_orders": (
+                            "set_pine_risk_max_intraday_filled_orders", "int"
+                        ),
+                        "max_drawdown": ("set_pine_risk_max_drawdown", "double"),
+                        "max_intraday_loss": ("set_pine_risk_max_intraday_loss", "double"),
+                        "max_position_size": ("set_pine_risk_max_position_size", "double"),
+                        "max_cons_loss_days": ("set_pine_risk_max_cons_loss_days", "int"),
                     }
                     if risk_func == "allow_entry_in":
                         val = self._visit_expr(node.expr.args[0])
                         if val == "1":
-                            lines.append(f"{pad}risk_direction_ = RiskDirection::LONG_ONLY;")
+                            direction = "1"
                         elif val == "-1":
-                            lines.append(f"{pad}risk_direction_ = RiskDirection::SHORT_ONLY;")
+                            direction = "-1"
                         else:
-                            lines.append(f"{pad}risk_direction_ = RiskDirection::BOTH;")
+                            direction = "0"
+                        lines.append(f"{pad}set_pine_risk_direction({direction});")
                         return
                     if risk_func in _RISK_MEMBER_MAP:
-                        member, cast_type = _RISK_MEMBER_MAP[risk_func]
+                        setter, cast_type = _RISK_MEMBER_MAP[risk_func]
                         val = self._visit_expr(node.expr.args[0])
-                        lines.append(f"{pad}{member} = ({cast_type})({val});")
-                        # Handle percent_of_equity flag for max_drawdown / max_intraday_loss
+                        # The percent flag travels with the matching setter so
+                        # every risk update atomically replaces both fields.
                         if risk_func in ("max_drawdown", "max_intraday_loss") and len(node.expr.args) >= 2:
                             arg2 = node.expr.args[1]
                             is_pct = (isinstance(arg2, MemberAccess)
                                       and isinstance(arg2.object, Identifier)
                                       and arg2.object.name == "strategy"
                                       and arg2.member == "percent_of_equity")
-                            if is_pct:
-                                pct_flag = "risk_max_drawdown_is_pct_" if risk_func == "max_drawdown" else "risk_max_intraday_loss_is_pct_"
-                                lines.append(f"{pad}{pct_flag} = true;")
+                        else:
+                            is_pct = False
+                        if risk_func in ("max_drawdown", "max_intraday_loss"):
+                            lines.append(
+                                f"{pad}{setter}(({cast_type})({val}), "
+                                f"{'true' if is_pct else 'false'});"
+                            )
+                        else:
+                            lines.append(f"{pad}{setter}(({cast_type})({val}));")
                         return
             if self._is_skip_expr(node.expr):
                 return
@@ -495,6 +510,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")
@@ -525,6 +545,37 @@ class StmtVisitor:
                         lines.append(f"{pad}    {flag_expr} = true;")
                         lines.append(f"{pad}}}")
                         return
+                    if isinstance(node.value, (IfStmt, SwitchStmt)):
+                        # Any other ``var`` whose initializer is an if/switch
+                        # expression: the selection, once, at first reach. It
+                        # rendered as ``/* unknown */``, which did not compile
+                        # (``var string dashPos = switch dashPosInput``). A
+                        # history-referenced one replaces its current slot.
+                        selection_cpp_type = (
+                            target_cpp_type or self._int_slot_cpp_type(member_name)
+                        )
+                        indent = len(pad) // 4 + 1
+                        lines.append(f"{pad}if (!{flag_expr}) {{")
+                        if info.get("is_series"):
+                            # The member's own element type (string, drawing
+                            # or number), from its current slot: the carry
+                            # has pushed the var's na there before its first
+                            # reach, which an arm no case selects keeps.
+                            selected = f"_pf_selection_{flag}"
+                            lines.append(f"{pad}    auto {selected} = {target_expr}[0];")
+                            self._visit_if_switch_expr(
+                                node.value, selected, lines, indent,
+                                target_cpp_type=selection_cpp_type,
+                            )
+                            lines.append(f"{pad}    {target_expr}.update({selected});")
+                        else:
+                            self._visit_if_switch_expr(
+                                node.value, target_expr, lines, indent,
+                                target_cpp_type=selection_cpp_type,
+                            )
+                        lines.append(f"{pad}    {flag_expr} = true;")
+                        lines.append(f"{pad}}}")
+                        return
                     if target_cpp_type is not None:
                         init_cpp = self._visit_rhs_value(
                             node.value,
@@ -535,10 +586,15 @@ 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"]
                     )
+                    init_cpp = self._coerce_int_slot(
+                        init_cpp, node.value,
+                        self._int_slot_cpp_type(member_name),
+                    )
                 lines.append(f"{pad}if (!{flag_expr}) {{")
                 # A history-referenced persistent primitive is a Series<T> too,
                 # not just a drawing handle.  The per-bar carry has already
@@ -618,13 +674,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)
@@ -648,10 +710,17 @@ class StmtVisitor:
                 )
                 elem_spec = spec.element or elem_spec
                 cpp_type = self._type_spec_to_cpp(spec)
+                if len(node.value.args) > 2:
+                    self._warn_narrow_int_element(
+                        node.value, spec, node.value.args[2])
                 if len(node.value.args) >= 2:
                     r = self._visit_expr(node.value.args[0])
                     c = self._visit_expr(node.value.args[1])
-                    v = self._visit_expr(node.value.args[2]) if len(node.value.args) > 2 else self._default_for_spec(elem_spec)
+                    v = (
+                        self._array_init_value_expr(elem_spec, node.value.args[2])
+                        if len(node.value.args) > 2
+                        else self._default_for_spec(elem_spec)
+                    )
                     init = f"{cpp_type}::new_({r}, {c}, {v})"
                 else:
                     init = f"{cpp_type}::new_(0, 0, {self._default_for_spec(elem_spec)})"
@@ -726,12 +795,24 @@ class StmtVisitor:
         site = self._get_ta_site(node.value)
         if site is not None:
             compute_args = self._ta_compute_args_for_site(site)
-            ret_type = "bool" if self._ta_name_from_site(site) in TA_RETURNS_BOOL else "double"
+            ret_type = (
+                self._type_for_decl(node)
+                if node.type_hint and not is_global_member
+                else "bool" if self._ta_name_from_site(site) in TA_RETURNS_BOOL
+                else "double"
+            )
             ta_name = self._ta_member_name(site)
             ta_expr = (
                 f"(history_advances_new_bar() ? {ta_name}.compute({compute_args}) "
                 f": {ta_name}.recompute({compute_args}))"
             )
+            ta_expr = self._coerce_int_slot(
+                ta_expr,
+                node.value,
+                self._int_slot_cpp_type(
+                    node.name, None if is_global_member else ret_type
+                ),
+            )
             if declaration_is_series:
                 self._emit_history_series_write(lines, pad, safe, ta_expr)
             elif is_global_member:
@@ -752,6 +833,10 @@ class StmtVisitor:
                     else None
                 ),
             )
+            cpp_val = self._coerce_int_slot(
+                cpp_val, node.value,
+                self._int_slot_cpp_type(None, self._series_type_for(node.name)),
+            )
             self._emit_history_series_write(lines, pad, safe, cpp_val)
             return
 
@@ -779,17 +864,25 @@ class StmtVisitor:
                     node.name,
                     cpp_type,
                 )
+            if selection_cpp_type is None:
+                selection_cpp_type = self._int_slot_cpp_type(
+                    node.name, cpp_type,
+                )
             if not is_global_member:
                 default = self._default_for_type(cpp_type)
                 lines.append(f"{pad}{cpp_type} {safe} = {default};")
                 remember_local_type(cpp_type)
             indent = len(pad) // 4
-            self._visit_if_switch_expr(
+            self._visit_selection_value(
                 node.value,
                 safe,
                 lines,
                 indent,
                 target_cpp_type=selection_cpp_type,
+                slot_cpp_type=(
+                    cpp_type if cpp_type is not None
+                    else self._infer_type(Identifier(name=node.name))
+                ),
             )
             return
 
@@ -839,6 +932,12 @@ class StmtVisitor:
             node.name,
             target_cpp_type=target_cpp_type,
         )
+        # ``cpp_type`` is None for a hoisted global; the slot resolver then
+        # reads the member declaration instead.
+        cpp_val = self._coerce_int_slot(
+            cpp_val, node.value,
+            self._int_slot_cpp_type(node.name, cpp_type),
+        )
         if is_global_member:
             lines.append(f"{pad}{safe} = {cpp_val};")
         else:
@@ -971,13 +1070,16 @@ class StmtVisitor:
                     target_name,
                     None,
                 )
+            if selection_cpp_type is None:
+                selection_cpp_type = self._int_slot_cpp_type(target_name)
             indent = len(pad) // 4
-            self._visit_if_switch_expr(
+            self._visit_selection_value(
                 node.value,
                 safe,
                 lines,
                 indent,
                 target_cpp_type=selection_cpp_type,
+                slot_cpp_type=self._infer_type(node.target),
             )
             return
 
@@ -1010,13 +1112,28 @@ class StmtVisitor:
             val_cpp = self._visit_rhs_value(
                 node.value, target_cpp_type=target_cpp_type
             )
-            if node.op == ":=":
+            field_int = self._udt_field_int_cpp_type(node.target)
+            array_field = self._udt_array_field_target(node.target)
+            if node.op == ":=" and array_field is not None:
+                # The field rebinds to the array: an alias of a stable
+                # script var array, else the value moved or copied in.
+                lines.append(
+                    f"{pad}{target_cpp} = "
+                    f"{self._udt_array_field_value(array_field, node.value, val_cpp)};")
+            elif node.op == ":=":
+                val_cpp = self._coerce_int_slot(val_cpp, node.value, field_int)
                 lines.append(f"{pad}{target_cpp} = {val_cpp};")
             else:
                 rhs = self._compound_assign_rhs(target_cpp, node.op, val_cpp)
                 if rhs is not None:
+                    rhs = self._coerce_int_slot(
+                        rhs, node.value, field_int, value_is_double=True,
+                    )
                     lines.append(f"{pad}{target_cpp} = {rhs};")
                 else:
+                    val_cpp = self._coerce_int_slot(
+                        val_cpp, node.value, field_int,
+                    )
                     lines.append(f"{pad}{target_cpp} {node.op} {val_cpp};")
             return
 
@@ -1034,17 +1151,27 @@ class StmtVisitor:
                     None,
                 ),
             )
+            elem_int = self._int_slot_cpp_type(
+                None, self._series_type_for(target_name),
+            )
             if node.op == ":=":
+                val_cpp = self._coerce_int_slot(val_cpp, node.value, elem_int)
                 lines.append(f"{pad}{safe}.update({val_cpp});")
             else:
                 rhs = self._compound_assign_rhs(f"{safe}[0]", node.op, val_cpp)
                 if rhs is not None:
                     # x /= y → x.update((double)x[0] / (double)y); x %= y → fmod
+                    rhs = self._coerce_int_slot(
+                        rhs, node.value, elem_int, value_is_double=True,
+                    )
                     lines.append(f"{pad}{safe}.update({rhs});")
                 else:
                     # Compound assignment: x += y → x.update(x[0] + y)
                     op_char = node.op[0]  # e.g., "+" from "+="
-                    lines.append(f"{pad}{safe}.update({safe}[0] {op_char} {val_cpp});")
+                    combined = self._coerce_int_slot(
+                        f"{safe}[0] {op_char} {val_cpp}", node.value, elem_int,
+                    )
+                    lines.append(f"{pad}{safe}.update({combined});")
         elif target_name in self._var_names:
             # A bare-``na`` reassignment must adopt the target's declared scalar
             # type (``x := na`` -> ``na<int>()`` not ``na<double>()``); otherwise
@@ -1057,14 +1184,30 @@ class StmtVisitor:
             if tct is None and self._is_na_expr(node.value):
                 tct = self._na_reassign_cpp_type(target_name)
             val_cpp = self._visit_rhs_value(node.value, target_name, target_cpp_type=tct)
+            int_slot = self._int_slot_cpp_type(target_name)
             if node.op == ":=":
+                val_cpp = self._coerce_int_slot(val_cpp, node.value, int_slot)
                 lines.append(f"{pad}{safe} = {val_cpp};")
             else:
                 rhs = self._compound_assign_rhs(safe, node.op, val_cpp)
                 if rhs is not None:
+                    # ``/=`` and ``%=`` lower to an always-double form, so an
+                    # int target narrows whatever the operands were.
+                    rhs = self._coerce_int_slot(
+                        rhs, node.value, int_slot, value_is_double=True,
+                    )
                     lines.append(f"{pad}{safe} = {rhs};")
                 else:
-                    lines.append(f"{pad}{safe} {node.op} {val_cpp};")
+                    # Narrow the WHOLE compound expression, not the operand:
+                    # ``x -= 0.5`` on an int slot truncated (x - 0.5), and
+                    # truncating the operand first would round differently.
+                    combined = self._coerce_int_slot(
+                        f"{safe} {node.op[0]} {val_cpp}", node.value, int_slot,
+                    )
+                    if combined != f"{safe} {node.op[0]} {val_cpp}":
+                        lines.append(f"{pad}{safe} = {combined};")
+                    else:
+                        lines.append(f"{pad}{safe} {node.op} {val_cpp};")
         else:
             tct = self._nullable_collection_target_cpp_type(name=target_name)
             if tct is None:
@@ -1072,14 +1215,30 @@ class StmtVisitor:
             if tct is None and self._is_na_expr(node.value):
                 tct = self._na_reassign_cpp_type(target_name)
             val_cpp = self._visit_rhs_value(node.value, target_name, target_cpp_type=tct)
+            int_slot = self._int_slot_cpp_type(target_name)
             if node.op == ":=":
+                val_cpp = self._coerce_int_slot(val_cpp, node.value, int_slot)
                 lines.append(f"{pad}{safe} = {val_cpp};")
             else:
                 rhs = self._compound_assign_rhs(safe, node.op, val_cpp)
                 if rhs is not None:
+                    # ``/=`` and ``%=`` lower to an always-double form, so an
+                    # int target narrows whatever the operands were.
+                    rhs = self._coerce_int_slot(
+                        rhs, node.value, int_slot, value_is_double=True,
+                    )
                     lines.append(f"{pad}{safe} = {rhs};")
                 else:
-                    lines.append(f"{pad}{safe} {node.op} {val_cpp};")
+                    # Narrow the WHOLE compound expression, not the operand:
+                    # ``x -= 0.5`` on an int slot truncated (x - 0.5), and
+                    # truncating the operand first would round differently.
+                    combined = self._coerce_int_slot(
+                        f"{safe} {node.op[0]} {val_cpp}", node.value, int_slot,
+                    )
+                    if combined != f"{safe} {node.op[0]} {val_cpp}":
+                        lines.append(f"{pad}{safe} = {combined};")
+                    else:
+                        lines.append(f"{pad}{safe} {node.op} {val_cpp};")
 
     def _visit_tuple_assign(self, node: TupleAssign, lines: list[str], pad: str) -> None:
         is_top_level = any(id(node) == id(stmt) for stmt in self.ctx.ast.body)
@@ -1140,6 +1299,14 @@ class StmtVisitor:
                         and len(tuple_types) == tuple_size
                         and all(item == PineType.BOOL for item in tuple_types)
                     )
+                    # A helper tuple mixing bool, string and numeric
+                    # elements (the analyzer admits nothing else).
+                    mixed_helper_tuple = (
+                        not isinstance(expr_node, TupleLiteral)
+                        and info.get("returns_tuple", False)
+                        and tuple_size >= 2
+                        and len(tuple_types) == tuple_size
+                    )
                     exact_direct_tuple = (
                         isinstance(expr_node, TupleLiteral)
                         and tuple_size >= 2
@@ -1165,6 +1332,7 @@ class StmtVisitor:
                     if (
                         numeric_tuple
                         or bool_tuple
+                        or mixed_helper_tuple
                         or exact_direct_tuple
                         or known_ta_tuple
                     ):
@@ -1181,6 +1349,10 @@ class StmtVisitor:
             the tuple once whenever either case applies; ordinary lexical scalar
             elements remain locals, Series elements advance their remapped
             members, and top-level scalars assign their class storage.
+            Pine's ``_`` binds nothing, but a structured binding declares
+            every name: C++17 has no placeholder, and GCC rejects a second
+            ``_`` in one scope (``[a, _, _] = f()``, or two tuples of one
+            block) as a redeclaration. Each ``_`` gets a name of its own.
             """
             series_names = {
                 name
@@ -1189,7 +1361,11 @@ class StmtVisitor:
                 and self._decl_binding_is_series(id(node), name)
             }
             if not series_names and not global_targets.intersection(node.names):
-                binding_names = ", ".join(node.names)
+                binding_names = ", ".join(
+                    self._tuple_placeholder_name() if name == "_"
+                    else self._safe_name(name)
+                    for name in node.names
+                )
                 lines.append(f"{pad}auto [{binding_names}] = {call_expr};")
                 return
 
@@ -1258,14 +1434,38 @@ class StmtVisitor:
                             f"{pad}{self._safe_name(name)} = {field_expr};"
                         )
                     else:
-                        lines.append(f"{pad}double {name} = {field_expr};")
+                        lines.append(
+                            f"{pad}double {self._safe_name(name)} = {field_expr};"
+                        )
+            return
+
+        # ``[a, b] = switch x ...`` / ``= if c ...``: every arm yields a tuple
+        # (the analyzer's ``_selection_tuple_shape``). Materialize the selected
+        # tuple, na in every position when no arm runs, then destructure it.
+        if isinstance(node.value, (IfStmt, SwitchStmt)):
+            types = self._infer_selection_tuple_types(
+                node.value, len(node.names)
+            )
+            tuple_t = f"std::tuple<{', '.join(types)}>"
+            temp = f"_tuple_result_{self._tuple_assign_counter}"
+            self._tuple_assign_counter += 1
+            lines.append(f"{pad}{tuple_t} {temp} = {self._tuple_default_expr(types)};")
+            self._visit_if_switch_expr(
+                node.value, temp, lines, len(pad) // 4, target_cpp_type=tuple_t
+            )
+            emit_call_tuple(temp)
             return
 
         # User-defined function returning a tuple: use C++17 structured bindings
         if isinstance(node.value, FuncCall):
             func_name, namespace = self._resolve_callee(node.value.callee)
             if namespace == "request" and func_name == "security":
-                call_expr = self._visit_func_call(node.value)
+                # A request whose names are reassigned is read where it is
+                # evaluated (external_requests): its data-missing stop.
+                if UNPINNED_ANNOTATION in (node.value.annotations or {}):
+                    call_expr = self._unpinned_read(node.value)
+                else:
+                    call_expr = self._visit_func_call(node.value)
                 emit_call_tuple(call_expr)
                 return
             if func_name and namespace is None and func_name in self._func_names:
@@ -1299,6 +1499,13 @@ class StmtVisitor:
 
         lines.append(f"{pad}/* unsupported tuple assignment */")
 
+    def _tuple_placeholder_name(self) -> str:
+        """A fresh C++ name for one ``_`` of a tuple declaration's structured
+        binding, which must name every element."""
+        index = getattr(self, "_tuple_placeholder_counter", 0)
+        self._tuple_placeholder_counter = index + 1
+        return f"_tuple_unused_{index}"
+
     def _tuple_binding_cpp_types(self, node: TupleAssign) -> list[str]:
         """Exact supported tuple element types for later lexical operations."""
         count = len(node.names)
@@ -1465,7 +1672,9 @@ class StmtVisitor:
     def _visit_if_body(self, node: IfStmt, lines: list[str], indent: int) -> None:
         pad = "    " * indent
 
-        cond = self._visit_expr(node.condition)
+        cond = self._coerce_bool_expr(
+            self._visit_expr(node.condition), node.condition
+        )
         lines.append(f"{pad}if ({cond}) {{")
         self._visit_block_statements(node.body, lines, indent + 1)
         lines.append(f"{pad}}}")
@@ -1480,7 +1689,8 @@ class StmtVisitor:
                 )
                 lines.append(f"{pad}}}")
 
-    def _visit_for(self, node: ForStmt, lines: list[str], indent: int) -> None:
+    def _visit_for(self, node: ForStmt, lines: list[str], indent: int,
+                   value_target: tuple[str, str | None] | None = None) -> None:
         pad = "    " * indent
         start = self._visit_expr(node.start)
         end = self._visit_expr(node.end)
@@ -1506,35 +1716,69 @@ class StmtVisitor:
             )
         )
         end_eval = f"_for_end_eval_{fid}" if end_mentions_binder else None
+        # ``from``/``to``/``by`` land in ``int`` slots. A double-valued bound
+        # (an array size, an na-able expression, ...) narrows there, which is
+        # undefined for na — so spell the conversion out. A bound that IS na
+        # then reads as na<int>() (INT_MIN), and the loop must run zero times
+        # rather than descend two billion steps toward it, so the guarded form
+        # also tests the bounds. Loops whose bounds were already integral emit
+        # exactly as before.
+        start_cpp = self._coerce_int_slot(f"({start})", node.start, "int")
+        end_cpp = self._coerce_int_slot(f"({end})", node.end, "int")
+        step_cpp = self._coerce_int_slot(f"({step})", node.step, "int")
+        na_capable = (
+            start_cpp != f"({start})"
+            or end_cpp != f"({end})"
+            or step_cpp != f"({step})"
+        )
         if end_eval is not None:
             # The ``to`` expression is authored outside the loop-binder scope,
             # but its refresh executes inside the generated C++ ``for`` where
             # the binder would shadow a same-named outer member/parameter. A
             # pre-binder lambda preserves the authored lexical binding while
             # still reevaluating the expression after every iteration.
-            lines.append(f"{pad}auto {end_eval} = [&]() {{ return ({end}); }};")
-        lines.append(f"{pad}int {s_var} = ({start});")
-        end_expr = f"{end_eval}()" if end_eval is not None else f"({end})"
+            lines.append(f"{pad}auto {end_eval} = [&]() {{ return {end_cpp}; }};")
+        lines.append(f"{pad}int {s_var} = {start_cpp};")
+        end_expr = f"{end_eval}()" if end_eval is not None else end_cpp
         lines.append(f"{pad}int {e_var} = {end_expr};")
-        lines.append(f"{pad}int {step_var} = ({step});")
-        lines.append(f"{pad}if ({step_var} < 0) {step_var} = -{step_var};")
+        lines.append(f"{pad}int {step_var} = {step_cpp};")
+        if na_capable:
+            # ``-na<int>()`` would overflow; leave an na step alone and let the
+            # loop condition reject it.
+            lines.append(
+                f"{pad}if (!is_na({step_var}) && {step_var} < 0)"
+                f" {step_var} = -{step_var};"
+            )
+        else:
+            lines.append(f"{pad}if ({step_var} < 0) {step_var} = -{step_var};")
         lines.append(f"{pad}if ({step_var} == 0) {step_var} = 1;")
         lines.append(f"{pad}const bool {down_var} = ({s_var} > {e_var});")
+        na_guard = (
+            f"!is_na({s_var}) && !is_na({e_var}) && !is_na({step_var}) && "
+            if na_capable else ""
+        )
+        # Pine v6 evaluates ``to`` before every iteration; v5 (a v5 library's
+        # body) fixes it before the first one.
+        refresh = "" if self._pine_v5_body else f", {e_var} = {end_expr}"
         lines.append(
             f"{pad}for (int {var} = {s_var}; "
+            f"{na_guard}"
             f"({down_var} ? ({var} >= {e_var}) : ({var} <= {e_var})); "
-            f"{var} += ({down_var} ? -{step_var} : {step_var}), "
-            f"{e_var} = {end_expr}) {{"
+            f"{var} += ({down_var} ? -{step_var} : {step_var})"
+            f"{refresh}) {{"
         )
         # Register the loop counter so reads of it inside the body resolve (the
         # unknown-identifier guard in _visit_ident would otherwise flag it).
         saved_loop = self._current_loop_vars
         saved_loop_specs = self._current_loop_var_specs
+        saved_counted = self._current_counted_loop_vars
         self._current_loop_vars = set(self._current_loop_vars)
         self._current_loop_var_specs = dict(self._current_loop_var_specs)
+        self._current_counted_loop_vars = set(self._current_counted_loop_vars)
         if node.var:
             self._current_loop_vars.add(node.var)
             self._current_loop_var_specs[node.var] = TypeSpec.primitive("int")
+            self._current_counted_loop_vars.add(node.var)
         _blk_saved = self._push_block_var_remap(node)
         if node.var:
             # The loop counter is a fresh primitive lexical binding.  Keep it
@@ -1544,21 +1788,26 @@ class StmtVisitor:
             self._lexical_series_bindings[node.var] = False
             self._lexical_known_var_tombstones.add(node.var)
         try:
-            for s in node.body:
-                self._visit_stmt(s, lines, indent + 1)
+            self._emit_loop_body(node.body, lines, indent + 1, value_target)
         finally:
             self._pop_block_var_remap(_blk_saved)
         self._current_loop_vars = saved_loop
         self._current_loop_var_specs = saved_loop_specs
+        self._current_counted_loop_vars = saved_counted
         lines.append(f"{pad}}}")
 
-    def _visit_for_in(self, node, lines: list[str], indent: int) -> None:
+    def _visit_for_in(self, node, lines: list[str], indent: int,
+                      value_target: tuple[str, str | None] | None = None) -> None:
         pad = "    " * indent
         iterable = self._visit_expr(node.iterable)
         saved_loop = self._current_loop_vars
         saved_loop_specs = self._current_loop_var_specs
+        saved_counted = self._current_counted_loop_vars
         self._current_loop_vars = set(self._current_loop_vars)
         self._current_loop_var_specs = dict(self._current_loop_var_specs)
+        # Its binders shadow a counted loop's of the same spelling.
+        self._current_counted_loop_vars = (
+            self._current_counted_loop_vars - {node.var, *(node.vars or ())})
         iterable_spec = self._type_spec_from_expr(node.iterable)
         elem_spec = (
             iterable_spec.element
@@ -1569,16 +1818,23 @@ class StmtVisitor:
             self._current_loop_vars.add(node.var)
             if elem_spec is not None:
                 self._current_loop_var_specs[node.var] = elem_spec
+            else:
+                # An outer binder's spec of the same spelling is not this one's.
+                self._current_loop_var_specs.pop(node.var, None)
         if node.vars:
             tuple_specs: list[TypeSpec | None] = []
             if iterable_spec is not None and iterable_spec.kind == "map":
                 tuple_specs = [iterable_spec.key, iterable_spec.value]
+            elif elem_spec is not None:
+                tuple_specs = [TypeSpec.primitive("int"), elem_spec]
             for idx, v in enumerate(node.vars):
                 if v != "_":
                     self._current_loop_vars.add(v)
                     if (idx < len(tuple_specs)
                             and tuple_specs[idx] is not None):
                         self._current_loop_var_specs[v] = tuple_specs[idx]
+                    else:
+                        self._current_loop_var_specs.pop(v, None)
         map_pair_loop = (
             iterable_spec is not None
             and iterable_spec.kind == "map"
@@ -1644,8 +1900,46 @@ class StmtVisitor:
                 lines.append(
                     f"{pad}    auto {value_cpp} = {map_token}.get({key_cpp});"
                 )
+        elif node.vars and elem_spec is not None and len(node.vars) == 2:
+            # ``for [i, v] in arr``: the index and the element. A vector has
+            # no pairs to decompose (``auto [i, v] : arr`` did not compile);
+            # bind the array once, then index it, reading its size on every
+            # iteration as the single-name loop's element order does.
+            index_name, value_name = node.vars
+            authored_names = (
+                set(self._all_bound_names)
+                | set(self._func_names)
+                | set(self._udt_defs)
+                | set(self._current_func_param_types)
+            )
+            occupied_names = authored_names | {
+                self._safe_name(name) for name in authored_names
+            }
+            while True:
+                fid = self._for_counter
+                self._for_counter += 1
+                array_token = f"__pf_array_iter_{fid}"
+                index_token = f"__pf_array_index_{fid}"
+                if not ({array_token, index_token} & occupied_names):
+                    break
+            lines.append(f"{pad}auto&& {array_token} = {iterable};")
+            lines.append(
+                f"{pad}for (int {index_token} = 0; "
+                f"{index_token} < (int){array_token}.size(); ++{index_token}) {{")
+            if index_name != "_":
+                lines.append(f"{pad}    int {self._safe_name(index_name)} = {index_token};")
+            if value_name != "_":
+                # The element's value, not a reference: a ``std::vector<bool>``
+                # element read through ``auto`` is a proxy that a later
+                # ``arr.set(i, ...)`` in the body would change.
+                lines.append(
+                    f"{pad}    typename std::decay_t<decltype({array_token})>"
+                    f"::value_type {self._safe_name(value_name)} = "
+                    f"{array_token}[(size_t){index_token}];")
         elif node.vars:
-            bindings = ", ".join(node.vars)
+            bindings = ", ".join(
+                self._safe_name(name) for name in node.vars
+            )
             lines.append(f"{pad}for (auto [{bindings}] : {iterable}) {{")
         _blk_saved = self._push_block_var_remap(node)
         loop_binding_names = (
@@ -1688,26 +1982,248 @@ class StmtVisitor:
                 self._lexical_series_bindings[name] = False
                 self._lexical_known_var_tombstones.add(name)
         try:
-            for s in node.body:
-                self._visit_stmt(s, lines, indent + 1)
+            self._emit_loop_body(node.body, lines, indent + 1, value_target)
         finally:
             self._pop_block_var_remap(_blk_saved)
         lines.append(f"{pad}}}")
         self._current_loop_vars = saved_loop
         self._current_loop_var_specs = saved_loop_specs
+        self._current_counted_loop_vars = saved_counted
 
-    def _visit_while(self, node: WhileStmt, lines: list[str], indent: int) -> None:
+    def _visit_while(self, node: WhileStmt, lines: list[str], indent: int,
+                     value_target: tuple[str, str | None] | None = None) -> None:
         pad = "    " * indent
-        cond = self._visit_expr(node.condition)
+        cond = self._coerce_bool_expr(
+            self._visit_expr(node.condition), node.condition
+        )
         lines.append(f"{pad}while ({cond}) {{")
         _blk_saved = self._push_block_var_remap(node)
         try:
-            for s in node.body:
-                self._visit_stmt(s, lines, indent + 1)
+            self._emit_loop_body(node.body, lines, indent + 1, value_target)
         finally:
             self._pop_block_var_remap(_blk_saved)
         lines.append(f"{pad}}}")
 
+    def _emit_loop_body(self, body: list, lines: list[str], indent: int,
+                        value_target: tuple[str, str | None] | None) -> None:
+        """A loop body; a loop used as a value assigns its last statement's
+        value to ``value_target`` (``(target, target_cpp_type)``)."""
+        if value_target is None:
+            for s in body:
+                self._visit_stmt(s, lines, indent)
+            return
+        target, target_cpp_type = value_target
+        value_cpp = self._block_value_cpp_type(body, target_cpp_type)
+        saved = getattr(self, "_unmatched_value_na", None)
+        # TradingView: an if without else (a switch without default) is na
+        # when no arm runs, so a loop whose body ends in one is na after an
+        # iteration that ran none (lab tv probe pf-w2-f04_if_tails).
+        self._unmatched_value_na = (
+            (target, self._na_value_for_type(value_cpp))
+            if value_cpp is not None else None
+        )
+        try:
+            self._emit_body_with_assign(
+                body, target, lines, indent, target_cpp_type=target_cpp_type,
+            )
+        finally:
+            self._unmatched_value_na = saved
+
+    def _emit_loop_with_assign(
+        self,
+        node,
+        target: str,
+        lines: list[str],
+        indent: int,
+        target_cpp_type: str | None = None,
+        reset: bool = True,
+    ) -> None:
+        """A loop that is a function's or an if/switch arm's last statement.
+
+        TradingView makes it the value its body's last statement produced on
+        the last iteration that reached that statement -- a ``break`` or
+        ``continue`` before it keeps the previous value -- and ``na`` when
+        none did (lab tv probes pf-w2-f04_loop_tail / f04_loop_edges).
+        """
+        visit = {
+            ForStmt: self._visit_for,
+            ForInStmt: self._visit_for_in,
+            WhileStmt: self._visit_while,
+        }[type(node)]
+        value_cpp = self._loop_value_cpp_type(node, target_cpp_type)
+        if value_cpp is None:
+            # No scalar or string value to leave (a drawing call, a void
+            # call, a handle): the loop is the plain statement it always was.
+            visit(node, lines, indent)
+            return
+        if reset:
+            pad = "    " * indent
+            lines.append(f"{pad}{target} = {self._na_value_for_type(value_cpp)};")
+        visit(node, lines, indent, value_target=(target, target_cpp_type))
+
+    def _unmatched_arm_na(self, target: str) -> str | None:
+        """The na a value ``target`` takes when an if/switch assigning it runs
+        no arm (a loop's value, ``_visit_selection_value``), or None outside
+        such a value position."""
+        active = getattr(self, "_unmatched_value_na", None)
+        if active is not None and active[0] == target:
+            return active[1]
+        return None
+
+    _UNMATCHED_NA_SLOTS = ("double", "int", "int64_t", "std::string", "bool")
+
+    def _visit_selection_value(
+        self,
+        node,
+        target: str,
+        lines: list[str],
+        indent: int,
+        target_cpp_type: str | None = None,
+        slot_cpp_type: str | None = None,
+    ) -> None:
+        """An if/switch whose value a declaration, a reassignment or a
+        function's last statement takes.
+
+        TradingView: an if without else, an else-if chain without a final
+        else or a switch without default is na when no arm runs -- a numeric
+        or string na, false for a bool -- as a function's last statement,
+        nested in a taken arm, and as the value a global, reassigned or local
+        variable takes, which does not keep its previous bar's value (lab tv
+        probe pf-oi-if-tail-na). ``slot_cpp_type`` is the target's C++ type;
+        a handle or collection slot keeps its existing lowering. An ``int``
+        an epoch reaches is stored ``int64_t`` (``target_cpp_type``, the
+        slot's integer width), and its na is the 64-bit sentinel: ``na<int>()``
+        widened there is a value, not na (quirk 9).
+        """
+        saved = getattr(self, "_unmatched_value_na", None)
+        if slot_cpp_type == "int" and target_cpp_type == "int64_t":
+            slot_cpp_type = "int64_t"
+        if slot_cpp_type in self._UNMATCHED_NA_SLOTS:
+            self._unmatched_value_na = (
+                target, self._na_value_for_type(slot_cpp_type))
+        try:
+            self._visit_if_switch_expr(
+                node, target, lines, indent, target_cpp_type=target_cpp_type,
+            )
+        finally:
+            self._unmatched_value_na = saved
+
+    def _na_value_for_type(self, cpp_type: str | None) -> str:
+        """``na`` of a value slot: a numeric or string na, else its default."""
+        if cpp_type is None:
+            return "na<double>()"
+        if cpp_type in ("double", "int", "int64_t", "std::string"):
+            return f"na<{cpp_type}>()"
+        return self._default_for_type(cpp_type)
+
+    _TAIL_SCALAR_CPP = ("double", "int", "int64_t", "bool")
+
+    def _tail_value_cpp_type(self, stmt) -> str | None:
+        """C++ type of the value a value-producing last statement leaves, or
+        None when it is a drawing, UDT or collection handle (or unknown).
+
+        Judged from the statement itself -- a declaration's type hint and
+        right-hand side, an assignment's target and right-hand side -- so the
+        answer does not depend on whether its local has been emitted yet.
+        """
+        if isinstance(stmt, ExprStmt):
+            parts, typed = [stmt.expr], stmt.expr
+        elif isinstance(stmt, VarDecl) and stmt.name:
+            parts, typed = [stmt.value], stmt.value
+            if stmt.type_hint:
+                spec = self._type_spec_from_hint_name(stmt.type_hint)
+                if spec is None or spec.kind != "primitive":
+                    return None
+                return self._type_spec_to_cpp(spec)
+        elif (isinstance(stmt, Assignment)
+                and isinstance(stmt.target, (Identifier, MemberAccess))):
+            parts, typed = [stmt.target, stmt.value], stmt.target
+        else:
+            return None
+        for part in parts:
+            if part is None:
+                return None
+            spec = self._type_spec_from_expr(part)
+            if spec is not None and spec.kind != "primitive":
+                return None
+        value_cpp = self._infer_type(typed)
+        if value_cpp in self._TAIL_SCALAR_CPP or value_cpp == "std::string":
+            return value_cpp
+        return None
+
+    def _tail_value_fits(self, stmt, slot_cpp_type: str | None) -> bool:
+        """Whether the value a last statement leaves fits the slot it feeds.
+
+        Only a scalar (numeric or bool) or a string is returned; a drawing,
+        UDT or collection handle keeps the statement-then-default lowering,
+        which is what every such tail compiled to before the value was
+        returned. ``slot_cpp_type`` None is a double or string slot.
+        """
+        value_cpp = self._tail_value_cpp_type(stmt)
+        if value_cpp is None:
+            return False
+        if slot_cpp_type is None:
+            return True
+        if slot_cpp_type in self._TAIL_SCALAR_CPP:
+            return value_cpp in self._TAIL_SCALAR_CPP
+        return slot_cpp_type == "std::string" == value_cpp
+
+    def _loop_value_cpp_type(self, node, slot_cpp_type: str | None) -> str | None:
+        """C++ type of the value a loop leaves, when its body's last statement
+        yields one that fits ``slot_cpp_type``; None otherwise."""
+        return self._block_value_cpp_type(
+            getattr(node, "body", None) or [], slot_cpp_type
+        )
+
+    def _block_value_cpp_type(self, body: list, slot_cpp_type: str | None) -> str | None:
+        """C++ type of the value a block's last statement yields into
+        ``slot_cpp_type`` (through nested loops and if/switch arms), or None
+        when it yields none that fits."""
+        if not body:
+            return None
+        last = body[-1]
+        if isinstance(last, (ForStmt, ForInStmt, WhileStmt)):
+            return self._block_value_cpp_type(last.body, slot_cpp_type)
+        if isinstance(last, IfStmt):
+            arms = [last.body] + ([last.else_body] if last.else_body else [])
+        elif isinstance(last, SwitchStmt):
+            arms = [body_ for _, body_ in last.cases] + (
+                [last.default_body] if last.default_body else [])
+        else:
+            arms = None
+        if arms is not None:
+            # Every arm must yield a fitting value of one type; a missing
+            # else/default arm is na on its path.
+            found = {self._block_value_cpp_type(arm, slot_cpp_type) for arm in arms}
+            return found.pop() if len(found) == 1 and None not in found else None
+        if self._statement_value_node(last) is None and not isinstance(last, ExprStmt):
+            return None
+        if isinstance(last, ExprStmt) and (
+                self._call_is_void(last.expr) or self._is_skip_expr(last.expr)):
+            return None
+        if not self._tail_value_fits(last, slot_cpp_type):
+            return None
+        return slot_cpp_type or self._tail_value_cpp_type(last)
+
+    @staticmethod
+    def _statement_value_node(stmt):
+        """The node whose value a value-producing statement leaves, or None.
+
+        TradingView makes the last statement of a function or an if/switch
+        arm its value: ``x := e`` and ``x += e`` (every compound operator)
+        yield the target's new value, ``obj.f := e`` the field's, and a
+        declaration ``[var] [T] x = e`` the declared variable's (lab tv probes
+        pf-w2-f04_tails / f04_decl_tail / f04_var_decl_tail).
+        """
+        if isinstance(stmt, Assignment) and isinstance(
+                stmt.target, (Identifier, MemberAccess)):
+            return stmt.target
+        if isinstance(stmt, VarDecl) and stmt.name:
+            node = Identifier(name=stmt.name)
+            node.loc = stmt.loc
+            return node
+        return None
+
     def _visit_switch(self, node: SwitchStmt, lines: list[str], indent: int) -> None:
         pad = "    " * indent
         if node.expr:
@@ -1723,7 +2239,9 @@ class StmtVisitor:
         else:
             for i, (case_expr, case_body) in enumerate(node.cases):
                 prefix = "if" if i == 0 else "else if"
-                cond = self._visit_expr(case_expr)
+                cond = self._coerce_bool_expr(
+                    self._visit_expr(case_expr), case_expr
+                )
                 lines.append(f"{pad}{prefix} ({cond}) {{")
                 self._visit_block_statements(case_body, lines, indent + 1)
                 lines.append(f"{pad}}}")
@@ -1765,9 +2283,13 @@ class StmtVisitor:
                     if self._call_is_void(stmt.expr):
                         self._visit_stmt(stmt, lines, indent)
                         return
-                    cpp = self._visit_rhs_value(
+                    cpp = self._coerce_int_slot(
+                        self._visit_rhs_value(
+                            stmt.expr,
+                            target_cpp_type=target_cpp_type,
+                        ),
                         stmt.expr,
-                        target_cpp_type=target_cpp_type,
+                        self._int_slot_cpp_type(None, target_cpp_type),
                     )
                     pad = "    " * indent
                     lines.append(f"{pad}{target} = {cpp};")
@@ -1788,6 +2310,26 @@ class StmtVisitor:
                         indent,
                         target_cpp_type=target_cpp_type,
                     )
+                elif (self._statement_value_node(stmt) is not None
+                        and self._tail_value_fits(stmt, target_cpp_type)):
+                    # ``y := v * 5`` / ``y += v`` / ``float y = v`` as the
+                    # value: run the statement, then read what it left.
+                    self._visit_stmt(stmt, lines, indent)
+                    value = self._statement_value_node(stmt)
+                    cpp = self._coerce_int_slot(
+                        self._visit_rhs_value(
+                            value, target_cpp_type=target_cpp_type,
+                        ),
+                        value,
+                        self._int_slot_cpp_type(None, target_cpp_type),
+                    )
+                    pad = "    " * indent
+                    lines.append(f"{pad}{target} = {cpp};")
+                elif isinstance(stmt, (ForStmt, ForInStmt, WhileStmt)):
+                    self._emit_loop_with_assign(
+                        stmt, target, lines, indent,
+                        target_cpp_type=target_cpp_type,
+                    )
                 else:
                     self._visit_stmt(stmt, lines, indent)
             else:
@@ -1816,7 +2358,9 @@ class StmtVisitor:
             lines.append(f"{pad}}}")
 
         if isinstance(node, IfStmt):
-            cond = self._visit_expr(node.condition)
+            cond = self._coerce_bool_expr(
+                self._visit_expr(node.condition), node.condition
+            )
             lines.append(f"{pad}if ({cond}) {{")
             self._emit_block_with_assign(
                 node.body,
@@ -1852,6 +2396,10 @@ class StmtVisitor:
                 # non-var globals and reassignments: retaining the prior bar's
                 # map/matrix ID would turn the expression into implicit state.
                 emit_implicit_na_fallback()
+            elif self._unmatched_arm_na(target) is not None:
+                lines.append(f"{pad}else {{")
+                lines.append(f"{pad}    {target} = {self._unmatched_arm_na(target)};")
+                lines.append(f"{pad}}}")
         elif isinstance(node, SwitchStmt):
             if node.expr:
                 expr_var = f"__switch_val_{self._switch_counter}"
@@ -1872,7 +2420,9 @@ class StmtVisitor:
             else:
                 for i, (case_expr, case_body) in enumerate(node.cases):
                     prefix = "if" if i == 0 else "else if"
-                    cond = self._visit_expr(case_expr)
+                    cond = self._coerce_bool_expr(
+                        self._visit_expr(case_expr), case_expr
+                    )
                     lines.append(f"{pad}{prefix} ({cond}) {{")
                     self._emit_block_with_assign(
                         case_body,
@@ -1908,3 +2458,11 @@ class StmtVisitor:
                     lines.append(
                         f"{pad}{target} = {target_cpp_type}{{}};"
                     )
+            elif self._unmatched_arm_na(target) is not None:
+                na_value = self._unmatched_arm_na(target)
+                if node.cases:
+                    lines.append(f"{pad}else {{")
+                    lines.append(f"{pad}    {target} = {na_value};")
+                    lines.append(f"{pad}}}")
+                else:
+                    lines.append(f"{pad}{target} = {na_value};")