@pineforge/codegen-pyodide 0.8.0 → 0.9.0

package/pineforge_codegen/codegen/visit_expr.py

@@ -111,6 +111,8 @@ from .tables import (
     COLOR_CONST_MAP,
     DAYOFWEEK_MAP,
     DISPLAY_MAP,
+    DRAWING_STYLE_NS,
+    DRAWING_TYPE_TO_CPP,
     ON_OFF_INHERIT_MAP,
     ORDER_DIRECTION_MAP,
     SKIP_NAMESPACES,
@@ -209,6 +211,44 @@ class ExprVisitor:
             return f"std::make_tuple({elems})"
         return "/* unknown */"
 
+    # ------------------------------------------------------------------
+    # 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)
+                or (isinstance(node, Identifier) and node.name == "na"))
+
+    def _drawing_na_default(self, target_name: str | None) -> str | None:
+        """If ``target_name`` is a drawing-handle variable (line/box/label/
+        linefill/chart.point), return its na default literal (e.g. ``Box{}`` —
+        a default-constructed handle whose id == -1 == na); otherwise None."""
+        if not target_name:
+            return None
+        udt = self._udt_var_types.get(target_name)
+        if udt in DRAWING_TYPE_TO_CPP:
+            return f"{DRAWING_TYPE_TO_CPP[udt]}{{}}"
+        return None
+
+    def _visit_rhs_value(self, value_node, target_name: str | None = None,
+                         target_cpp_type: str | None = None) -> str:
+        """Visit an assignment / declaration RHS.
+
+        A bare ``na`` lowers to a type-appropriate initializer for the target
+        instead of ``na<double>()``: drawing handles brace-init to their na
+        handle (``Box{}`` / ``Line{}`` / …); ``std::string``/``int``/``int64_t``/
+        ``bool`` use ``na<T>()``. Without this, ``Box b = na;`` and
+        ``string s = na;`` would both emit ``na<double>()`` and fail to compile
+        (no viable ``operator=`` / conversion). Every other RHS lowers unchanged.
+        """
+        if target_name and self._is_na_expr(value_node):
+            draw_default = self._drawing_na_default(target_name)
+            if draw_default is not None:
+                return draw_default
+            if target_cpp_type in ("std::string", "int", "int64_t", "bool"):
+                return f"na<{target_cpp_type}>()"
+        return self._visit_expr(value_node)
+
     def _visit_ident(self, node: Identifier) -> str:
         name = node.name
         # Bare 'na' identifier → na<double>()
@@ -235,6 +275,16 @@ class ExprVisitor:
                 return str(val)
             if isinstance(val, str):
                 return f'std::string("{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).
+        if (self._reset_input_getter_mode
+                and name in self._input_backed_vars
+                and name in self._input_var_to_call):
+            call_node = self._input_var_to_call[name]
+            func_name_i, namespace_i = self._resolve_callee(call_node.callee)
+            title = self._get_input_title(call_node, var_name=name)
+            return self._render_input_value(call_node, func_name_i, namespace_i, title)
         # Pine type name `color` used as a value (no variable) → int64 color constant.
         # Params handled above; symbol table does not retain function locals after analysis.
         if name == "color":
@@ -333,7 +383,12 @@ class ExprVisitor:
                 if node.member == "position_size":
                     return "signed_position_size()"
                 if node.member == "position_avg_price":
-                    return "position_entry_price_"
+                    # Pine returns `na` when the position is flat
+                    # (position_size == 0); the engine field is 0.0 when flat.
+                    # Guard so the common `na(strategy.position_avg_price)`
+                    # flat/in-position idiom is not silently defeated.
+                    return ("(signed_position_size() == 0.0 ? na<double>() "
+                            ": position_entry_price_)")
                 if node.member == "position_entry_name":
                     return "position_entry_name()"
                 # Trade counts
@@ -438,13 +493,34 @@ class ExprVisitor:
                     (node.member in TA_IMPLICIT_COMPUTE_FULL and node.member in TA_COMPUTE_ARGS and TA_COMPUTE_ARGS[node.member] == [])
                     or node.member == "vwap"
                 ):
-                    # Find the matching call site
-                    for site in self.ctx.ta_call_sites:
+                    # Find the matching call site. Skip sites pruned as dead
+                    # code (their owner function is never called): a dead site's
+                    # member declaration is never emitted (see base.py
+                    # ``_dead_ta_indices`` / emit_top.py member-decl guard), so
+                    # binding a LIVE bare property read to one references an
+                    # undeclared member. Regression: nightowlxtrader-azt — a live
+                    # ``ta.vwap`` (top-level + inside request.security) resolved
+                    # to dead ``f5``'s first-in-order ``_ta_vwap_10`` and emitted
+                    # ``use of undeclared identifier '_ta_vwap_10'``. A live read
+                    # must bind to a live site.
+                    for _i, site in enumerate(self.ctx.ta_call_sites):
+                        if _i in self._dead_ta_indices:
+                            continue
                         ta_short = site.class_name.split("::")[-1].lower()
                         if site.member_name.startswith(f"_ta_{node.member}_"):
                             if node.member == "vwap":
-                                return f"(is_first_tick_ ? {site.member_name}.compute(current_bar_.close, current_bar_.volume, current_bar_.timestamp) : {site.member_name}.recompute(current_bar_.close, current_bar_.volume, current_bar_.timestamp))"
-                            return f"(is_first_tick_ ? {site.member_name}.compute({TA_IMPLICIT_COMPUTE_FULL[node.member]}) : {site.member_name}.recompute({TA_IMPLICIT_COMPUTE_FULL[node.member]}))"
+                                return (
+                                    f"(history_advances_new_bar() ? {site.member_name}.compute("
+                                    "current_bar_.close, current_bar_.volume, current_bar_.timestamp) "
+                                    f": {site.member_name}.recompute(current_bar_.close, "
+                                    "current_bar_.volume, current_bar_.timestamp))"
+                                )
+                            return (
+                                f"(history_advances_new_bar() ? {site.member_name}.compute("
+                                f"{TA_IMPLICIT_COMPUTE_FULL[node.member]}) : "
+                                f"{site.member_name}.recompute("
+                                f"{TA_IMPLICIT_COMPUTE_FULL[node.member]}))"
+                            )
                     # No registered call site for this TA property read —
                     # the old fallback emitted std::string("<name>"), a
                     # silent type mismatch. Reject loudly instead.
@@ -589,6 +665,14 @@ class ExprVisitor:
                 if node.member in COLOR_CONST_MAP:
                     return COLOR_CONST_MAP[node.member]
                 return "0"
+            # Drawing style/visual CONSTANT member reads (line.style_solid,
+            # box.style_dashed, label.style_label_left, ...). These namespaces
+            # left SKIP_NAMESPACES (their FuncCall forms now route to the arena),
+            # but their constant members only ever feed dropped visual kwargs, so
+            # they still lower to "0". The function names arrive as FuncCalls
+            # (visit_call), never here. See spec §4.4.
+            if ns in DRAWING_STYLE_NS:
+                return "0"
             if ns in SKIP_NAMESPACES:
                 return "0"
             if ns == "currency":
@@ -660,10 +744,16 @@ class ExprVisitor:
                 or name in self._var_names
                 or name in self._current_loop_vars
                 or name in self._current_func_param_types
+                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]
+                # Pointer-aliased UDT local (BUG C, rebinding case): field access
+                # goes through ``->`` since the local holds ``UDT*``.
+                if name in self._udt_ptr_alias_locals:
+                    return f"{safe}->{node.member}"
                 return f"{safe}.{node.member}"
             if name not in self.ctx.series_vars:
                 # Unknown identifier — likely an enum value
@@ -675,6 +765,18 @@ class ExprVisitor:
         right = self._visit_expr(node.right)
         cpp_ops = {"and": "&&", "or": "||"}
         op = cpp_ops.get(node.op, node.op)
+        if node.op == "+":
+            lt = self._infer_type(node.left)
+            rt = self._infer_type(node.right)
+            if lt == "std::string" or rt == "std::string":
+                def _as_string(rendered, inferred):
+                    if inferred == "std::string":
+                        return rendered
+                    if inferred == "bool":
+                        return f'(({rendered}) ? std::string("true") : std::string("false"))'
+                    return f"std::to_string({rendered})"
+
+                return f"({_as_string(left, lt)} + {_as_string(right, rt)})"
         # PineScript % works on floats — use std::fmod in C++
         if node.op == "%":
             return f"std::fmod((double)({left}), (double)({right}))"
@@ -730,26 +832,26 @@ class ExprVisitor:
         # ``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
         # a freshly-computed C++ scalar, and ``scalar[k]`` is not subscriptable.
-        # Materialize the result into a self-contained history buffer: a static
+        # Materialize the result into a checkpoint-owned class-member
         # ``Series<T>`` that pushes (new bar) / updates (intrabar) the value
         # exactly once per evaluation — same semantics as every other series in
         # the strategy — and read ``[k]`` off it. The inner call is emitted once
-        # so its own stateful indicator is not double-stepped, and the buffer
-        # clears itself on run-start (``is_first_tick_ && bar_index_ == 0``) so a
-        # reused strategy handle (parameter sweep) does not leak prior-run history.
+        # so its own stateful indicator is not double-stepped.  The deterministic
+        # member identity includes the emitted UDF variant; separate Pine call
+        # sites never share history, and on_bar clears every synthetic member at
+        # run-start even when this particular expression is conditional.
         if isinstance(node.object, FuncCall):
             inner = self._visit_expr(node.object)
             cpp_t = self._infer_type(node.object)
             if cpp_t not in ("double", "int", "bool"):
                 cpp_t = "double"
+            member = self._inline_history_member("hist_call", node)
             return (
                 f"([&]() -> {cpp_t} {{ "
-                f"static thread_local Series<{cpp_t}> _hist_call; "
-                f"if (is_first_tick_ && bar_index_ == 0) _hist_call.clear(); "
                 f"{cpp_t} _hv = ({inner}); "
-                f"if (is_first_tick_) _hist_call.push(_hv); "
-                f"else _hist_call.update(_hv); "
-                f"return _hist_call[(int)({idx})]; }}())"
+                f"if (history_advances_new_bar()) {member}.push(_hv); "
+                f"else {member}.update(_hv); "
+                f"return {member}[(int)({idx})]; }}())"
             )
         obj = self._visit_expr(node.object)
         # If subscripting a non-series variable (e.g., function parameter),

package/pineforge_codegen/codegen/visit_stmt.py

@@ -100,11 +100,16 @@ from ..ast_nodes import (
 )
 from ..symbols import TypeSpec
 from .tables import (
+    ARRAY_NEW_CTORS,
     TA_RETURNS_BOOL,
     TA_TUPLE_FIELDS,
     MATRIX_RETURNING_METHODS,
 )
 
+# Sentinel for "no block-scoped var remap was activated" so an empty dict
+# saved-remap is still distinguishable from the no-op case.
+_NO_BLOCK_REMAP = object()
+
 
 class StmtVisitor:
     """Statement-level visitor methods shared across the codegen.
@@ -253,6 +258,10 @@ class StmtVisitor:
         # Global-scope non-var vars are class members — emit assignment, not declaration
         is_global_member = node.name in self._global_member_vars
 
+        def remember_local_type(cpp_type: str | None) -> None:
+            if cpp_type and not is_global_member:
+                self._current_func_local_types[node.name] = cpp_type
+
         # Check if it is a static (non-series) global member variable already evaluated inside _inputs_initialized_ block
         is_static_global_input = False
         if is_global_member and isinstance(node.value, FuncCall) and self._is_input_call(node.value):
@@ -279,7 +288,7 @@ class StmtVisitor:
             title = self._get_input_title(node.value, var_name=node.name)
             cpp_val = self._render_input_value(node.value, func_name_i, namespace_i, title)
             if node.name in self.ctx.series_vars:
-                lines.append(f"{pad}{safe}.push({cpp_val});")
+                self._emit_history_series_write(lines, pad, safe, cpp_val)
             elif is_global_member:
                 lines.append(f"{pad}{safe} = {cpp_val};")
             else:
@@ -291,7 +300,7 @@ class StmtVisitor:
         # array.new_float() etc., plus array-returning copy/slice.
         if isinstance(node.value, FuncCall):
             func_name, namespace = self._resolve_callee(node.value.callee)
-            if namespace == "array" and func_name in ("new", "new_float", "new_int", "new_bool", "new_string", "from", "copy", "slice"):
+            if namespace == "array" and func_name in ARRAY_NEW_CTORS | {"new", "from", "copy", "slice"}:
                 self._array_vars.add(node.name)
                 spec = self._type_spec_from_expr(node.value) or self._array_spec_for_name(node.name)
                 self._collection_types.setdefault(node.name, spec)
@@ -376,9 +385,12 @@ class StmtVisitor:
             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"
             ta_name = self._ta_member_name(site)
-            ta_expr = f"(is_first_tick_ ? {ta_name}.compute({compute_args}) : {ta_name}.recompute({compute_args}))"
+            ta_expr = (
+                f"(history_advances_new_bar() ? {ta_name}.compute({compute_args}) "
+                f": {ta_name}.recompute({compute_args}))"
+            )
             if node.name in self.ctx.series_vars:
-                lines.append(f"{pad}{safe}.push({ta_expr});")
+                self._emit_history_series_write(lines, pad, safe, ta_expr)
             elif is_global_member:
                 lines.append(f"{pad}{safe} = {ta_expr};")
             else:
@@ -388,7 +400,7 @@ class StmtVisitor:
         # Non-var series variable — push instead of declare
         if node.name in self.ctx.series_vars:
             cpp_val = self._visit_expr(node.value)
-            lines.append(f"{pad}{safe}.push({cpp_val});")
+            self._emit_history_series_write(lines, pad, safe, cpp_val)
             return
 
         # If/switch expression: x = if cond ... else ...
@@ -401,12 +413,74 @@ class StmtVisitor:
             self._visit_if_switch_expr(node.value, safe, lines, indent)
             return
 
+        # UDT lvalue alias (BUG C): a local initialised from a user-defined-UDT
+        # var/global lvalue (or a ternary/switch of such lvalues) and then
+        # mutated through must ALIAS the global, not value-copy — Pine UDTs are
+        # reference types. Emit a C++ reference (non-rebinding) or pointer
+        # (rebinding) alias instead of the default copy.
+        if not is_global_member:
+            alias = self._udt_local_alias_kind(node)
+            if alias is not None:
+                kind, udt_t = alias
+                if kind == "ref":
+                    cpp_val = self._visit_rhs_value(node.value, node.name, target_cpp_type=udt_t)
+                    lines.append(f"{pad}{udt_t}& {safe} = {cpp_val};")
+                    return
+                # Pointer alias: take address of each selected lvalue; subsequent
+                # field access lowers to ``->`` and rebinds to ``&(other)``.
+                self._udt_ptr_alias_locals.add(node.name)
+                cpp_val = self._addr_of_udt_selection(node.value, node.name)
+                lines.append(f"{pad}{udt_t}* {safe} = {cpp_val};")
+                return
+
+        # Collection lvalue alias (BUG 2): a local bound to an existing array /
+        # map / matrix lvalue (or a ternary/switch selecting same-typed ones)
+        # and later MUTATED through must ALIAS the member, not value-copy — Pine
+        # collections are reference types. Proven: jevondijefferson-big-breakout
+        # does ``array<orderBlock> orderBlocks = internal ? internalOrderBlocks
+        # : swingOrderBlocks`` then ``orderBlocks.unshift(ob)`` in three helpers;
+        # the value-copy left the member arrays empty. Emit a non-rebinding C++
+        # reference instead.
+        if not is_global_member:
+            coll_spec = self._collection_lvalue_selection_spec(node.value)
+            if coll_spec is not None and self._collection_local_must_alias(node):
+                # Register the local's collection kind so subsequent
+                # ``.size()/.get()/.unshift()`` dispatch resolves correctly.
+                self._collection_types[node.name] = coll_spec
+                if coll_spec.kind == "array":
+                    self._array_vars.add(node.name)
+                elif coll_spec.kind == "map":
+                    self._map_vars.add(node.name)
+                elif coll_spec.kind == "matrix":
+                    self._matrix_specs[node.name] = coll_spec
+                cpp_type = self._type_spec_to_cpp(coll_spec)
+                cpp_val = self._visit_rhs_value(node.value, node.name, target_cpp_type=cpp_type)
+                lines.append(f"{pad}{cpp_type}& {safe} = {cpp_val};")
+                return
+
+        # Global-scope UDT array-element alias (BUG: Pine array elements of a
+        # user-defined type are references). A global loop-local bound from
+        # ``arr.get(i)`` and later field-mutated must ALIAS the element so the
+        # mutation writes back into the array. Emit a fresh per-iteration
+        # ``UDT& z = arr[i];`` reference (any hoisted class member was
+        # suppressed) — identical to the non-hoisted function-local alias path.
+        # Gated by _register_udt_array_get_ref_locals (which only records global-
+        # scope names); the ``_current_func_body is None`` guard confines this to
+        # global scope, so a function-local sharing the name keeps its own path.
+        if (node.name in self._udt_array_get_ref_locals
+                and getattr(self, "_current_func_body", None) is None):
+            udt_t = self._udt_var_types.get(node.name)
+            cpp_val = self._visit_rhs_value(node.value, node.name, target_cpp_type=udt_t)
+            lines.append(f"{pad}{udt_t}& {safe} = {cpp_val};")
+            return
+
         # General declaration
-        cpp_val = self._visit_expr(node.value)
+        cpp_type = self._type_for_decl(node) if not is_global_member else None
+        cpp_val = self._visit_rhs_value(node.value, node.name, target_cpp_type=cpp_type)
         if is_global_member:
             lines.append(f"{pad}{safe} = {cpp_val};")
         else:
-            cpp_type = self._type_for_decl(node)
+            remember_local_type(cpp_type)
             lines.append(f"{pad}{cpp_type} {safe} = {cpp_val};")
 
     @staticmethod
@@ -476,6 +550,12 @@ class StmtVisitor:
         if self._active_var_remap and safe in self._active_var_remap:
             safe = self._active_var_remap[safe]
 
+        # Pointer-aliased UDT local (BUG C, rebinding case): ``p := other``
+        # rebinds the pointer to the address of the newly selected UDT lvalue.
+        if target_name in self._udt_ptr_alias_locals and node.op == ":=":
+            lines.append(f"{pad}{safe} = {self._addr_of_udt_selection(node.value, target_name)};")
+            return
+
         if target_name in self.ctx.series_vars:
             val_cpp = self._visit_expr(node.value)
             if node.op == ":=":
@@ -509,7 +589,7 @@ class StmtVisitor:
                             f"expected {self._type_spec_to_cpp(lhs_spec)}, "
                             f"got {self._type_spec_to_cpp(rhs_spec)}",
                         )
-            val_cpp = self._visit_expr(node.value)
+            val_cpp = self._visit_rhs_value(node.value, target_name)
             if node.op == ":=":
                 lines.append(f"{pad}{safe} = {val_cpp};")
             else:
@@ -519,7 +599,7 @@ class StmtVisitor:
                 else:
                     lines.append(f"{pad}{safe} {node.op} {val_cpp};")
         else:
-            val_cpp = self._visit_expr(node.value)
+            val_cpp = self._visit_rhs_value(node.value, target_name)
             if node.op == ":=":
                 lines.append(f"{pad}{safe} = {val_cpp};")
             else:
@@ -535,7 +615,11 @@ class StmtVisitor:
             compute_args = self._ta_compute_args_for_site(site)
             ta_mem = self._ta_member_name(site)
             result_var = f"_result_{ta_mem}"
-            lines.append(f"{pad}auto {result_var} = (is_first_tick_ ? {ta_mem}.compute({compute_args}) : {ta_mem}.recompute({compute_args}));")
+            lines.append(
+                f"{pad}auto {result_var} = (history_advances_new_bar() ? "
+                f"{ta_mem}.compute({compute_args}) : "
+                f"{ta_mem}.recompute({compute_args}));"
+            )
 
             ta_name = self._ta_name_from_site(site)
             fields = TA_TUPLE_FIELDS.get(ta_name, [f"field{i}" for i in range(len(node.names))])
@@ -555,7 +639,9 @@ class StmtVisitor:
                     # destructured names keep the plain scalar declaration.
                     if name in self.ctx.series_vars:
                         safe = self._safe_name(name)
-                        lines.append(f"{pad}{safe}.push({field_expr});")
+                        self._emit_history_series_write(
+                            lines, pad, safe, field_expr
+                        )
                     else:
                         lines.append(f"{pad}double {name} = {field_expr};")
             return
@@ -600,7 +686,30 @@ class StmtVisitor:
 
         lines.append(f"{pad}/* unsupported tuple assignment */")
 
+    def _push_block_var_remap(self, node):
+        """Activate block-scoped var renames for ``node`` (BUG 1). Returns the
+        previous ``_active_var_remap`` to restore (or ``_NO_BLOCK_REMAP`` if this
+        block owns no renames). Renames are MERGED over the inherited remap so
+        nested blocks keep any enclosing func-clone / outer-block mapping."""
+        renames = self._block_var_renames.get(id(node))
+        if not renames:
+            return _NO_BLOCK_REMAP
+        saved = self._active_var_remap
+        self._active_var_remap = {**saved, **renames}
+        return saved
+
+    def _pop_block_var_remap(self, saved) -> None:
+        if saved is not _NO_BLOCK_REMAP:
+            self._active_var_remap = saved
+
     def _visit_if(self, node: IfStmt, lines: list[str], indent: int) -> None:
+        _blk_saved = self._push_block_var_remap(node)
+        try:
+            self._visit_if_body(node, lines, indent)
+        finally:
+            self._pop_block_var_remap(_blk_saved)
+
+    def _visit_if_body(self, node: IfStmt, lines: list[str], indent: int) -> None:
         pad = "    " * indent
 
         # TA hoisting: inside per-call-site function variants, execute ALL
@@ -637,48 +746,118 @@ class StmtVisitor:
         pad = "    " * indent
         start = self._visit_expr(node.start)
         end = self._visit_expr(node.end)
-        step = self._visit_expr(node.step) if node.step else "1"
-        var = node.var  # new AST uses .var instead of .var_name
-        lines.append(f"{pad}for (int {var} = {start}; {var} <= {end}; {var} += {step}) {{")
+        step = self._visit_expr(node.step) if node.step is not None else "1"
+        var = self._safe_name(node.var)  # new AST uses .var instead of .var_name
+
+        # Pine infers loop direction from the initial ``from``/``to`` values for
+        # both implicit and explicit ``by`` loops. The ``by`` value is a positive
+        # magnitude; descending loops subtract it. ``to`` can change during the
+        # loop, so refresh the cached end expression after each iteration while
+        # keeping the initial direction and step fixed.
+        fid = self._for_counter
+        self._for_counter += 1
+        s_var = f"_for_start_{fid}"
+        e_var = f"_for_end_{fid}"
+        step_var = f"_for_step_{fid}"
+        down_var = f"_for_down_{fid}"
+        lines.append(f"{pad}int {s_var} = ({start});")
+        lines.append(f"{pad}int {e_var} = ({end});")
+        lines.append(f"{pad}int {step_var} = ({step});")
+        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});")
+        lines.append(
+            f"{pad}for (int {var} = {s_var}; "
+            f"({down_var} ? ({var} >= {e_var}) : ({var} <= {e_var})); "
+            f"{var} += ({down_var} ? -{step_var} : {step_var}), {e_var} = ({end})) {{"
+        )
         # 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
         self._current_loop_vars = set(self._current_loop_vars)
-        if var:
-            self._current_loop_vars.add(var)
-        for s in node.body:
-            self._visit_stmt(s, lines, indent + 1)
+        if node.var:
+            self._current_loop_vars.add(node.var)
+        _blk_saved = self._push_block_var_remap(node)
+        try:
+            for s in node.body:
+                self._visit_stmt(s, lines, indent + 1)
+        finally:
+            self._pop_block_var_remap(_blk_saved)
         self._current_loop_vars = saved_loop
         lines.append(f"{pad}}}")
 
+    def _loop_elem_is_writeback_udt(self, iterable) -> bool:
+        """Whether a ``for x in coll`` loop variable must bind by reference.
+
+        In Pine a ``for x in arr`` loop variable over an array of *user-defined
+        objects* is a reference to the element — field writes (``x.f := v``)
+        mutate the array in place — whereas over a primitive array it is a
+        copy. So emit C++ ``auto&`` only for arrays whose element is a
+        user-defined UDT struct. Primitive elements keep ``auto`` (Pine copy
+        semantics: writing the loop var must NOT write back). Drawing handles
+        (line/box/label/linefill/...) also keep ``auto``: their element type
+        name is a builtin, not in ``_udt_defs``, and a handle copy already
+        mutates the shared engine object. (Reassigning the loop var itself —
+        ``x := ...`` — is not modelled by either form, but Pine forbids it for
+        objects in practice and it does not occur in the corpus.)
+        """
+        spec = self._type_spec_from_expr(iterable)
+        return (
+            spec is not None
+            and spec.kind == "array"
+            and spec.element is not None
+            and spec.element.kind == "udt"
+            and spec.element.name in self._udt_defs
+        )
+
     def _visit_for_in(self, node, lines: list[str], indent: int) -> None:
         pad = "    " * indent
         iterable = self._visit_expr(node.iterable)
         saved_loop = self._current_loop_vars
+        saved_loop_specs = self._current_loop_var_specs
         self._current_loop_vars = set(self._current_loop_vars)
+        self._current_loop_var_specs = dict(self._current_loop_var_specs)
+        iterable_spec = self._type_spec_from_expr(node.iterable)
+        elem_spec = (
+            iterable_spec.element
+            if iterable_spec is not None and iterable_spec.kind == "array"
+            else None
+        )
         if node.var:
             self._current_loop_vars.add(node.var)
+            if elem_spec is not None:
+                self._current_loop_var_specs[node.var] = elem_spec
         if node.vars:
             for v in node.vars:
                 if v != "_":
                     self._current_loop_vars.add(v)
         if node.var:
             v_cpp = self._safe_name(node.var)
-            lines.append(f"{pad}for (auto {v_cpp} : {iterable}) {{")
+            ref = "&" if self._loop_elem_is_writeback_udt(node.iterable) else ""
+            lines.append(f"{pad}for (auto{ref} {v_cpp} : {iterable}) {{")
         elif node.vars:
             bindings = ", ".join(node.vars)
             lines.append(f"{pad}for (auto [{bindings}] : {iterable}) {{")
-        for s in node.body:
-            self._visit_stmt(s, lines, indent + 1)
+        _blk_saved = self._push_block_var_remap(node)
+        try:
+            for s in node.body:
+                self._visit_stmt(s, lines, indent + 1)
+        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
 
     def _visit_while(self, node: WhileStmt, lines: list[str], indent: int) -> None:
         pad = "    " * indent
         cond = self._visit_expr(node.condition)
         lines.append(f"{pad}while ({cond}) {{")
-        for s in node.body:
-            self._visit_stmt(s, lines, indent + 1)
+        _blk_saved = self._push_block_var_remap(node)
+        try:
+            for s in node.body:
+                self._visit_stmt(s, lines, indent + 1)
+        finally:
+            self._pop_block_var_remap(_blk_saved)
         lines.append(f"{pad}}}")
 
     def _visit_switch(self, node: SwitchStmt, lines: list[str], indent: int) -> None:
@@ -727,6 +906,12 @@ class StmtVisitor:
                     # Check if it's a skip expr
                     if self._is_skip_expr(stmt.expr):
                         return
+                    # A void drawing setter / delete / visual-noop cannot be the
+                    # branch's value (it lowers to a void C++ call) — emit it as
+                    # a statement and leave ``target`` at its default.
+                    if self._call_is_void(stmt.expr):
+                        self._visit_stmt(stmt, lines, indent)
+                        return
                     cpp = self._visit_expr(stmt.expr)
                     pad = "    " * indent
                     lines.append(f"{pad}{target} = {cpp};")