@pineforge/codegen-pyodide 0.8.0 → 0.8.1

package/pineforge_codegen/codegen/visit_call.py

@@ -141,10 +141,14 @@ from ..ast_nodes import (
 )
 from ..symbols import TypeSpec
 from .. import signatures as sigs
+from .drawing import ALL_DRAWING_METHODS
 from .tables import (
+    ARRAY_DRAWING_NEW_CTORS,
     ARRAY_METHODS,
     BAR_FIELDS,
     BAR_SERIES_PUSH,
+    DRAWING_NS,
+    DRAWING_TYPE_TO_CPP,
     MAP_METHODS,
     MATH_FUNC_MAP,
     MATRIX_METHODS,
@@ -226,6 +230,32 @@ class CallVisitor:
                     )
                     rest = [self._visit_expr(a) for a in rest_nodes]
                     return f"{fn_cpp}({', '.join([recv_e] + rest)})"
+
+        # Drawing method dispatch (spec §4.3 / L.1). A KNOWN drawing method on a
+        # receiver that resolves to a drawing udt — gated on the METHOD NAME
+        # FIRST so a user method (egoigor's ``ln.slope()``, already routed by the
+        # block above) is never captured here. This single check covers all
+        # receiver shapes (identifier ``ln.set_x2(v)``, obj.field
+        # ``d.fld.set_y2(v)``, and arbitrary-expr ``d.upln.get(0).delete()``), so
+        # it precedes the obj.field.method / identifier branches below AND the
+        # generic ``delete`` -> ``_delete_`` rewrites + _resolve_callee.
+        if isinstance(callee, MemberAccess) and callee.member in ALL_DRAWING_METHODS:
+            recv_spec = self._type_spec_from_expr(callee.object)
+            if (recv_spec is not None and recv_spec.kind == "udt"
+                    and recv_spec.name in DRAWING_TYPE_TO_CPP):
+                return self._emit_drawing_method(
+                    recv_spec.name, callee.member, callee.object,
+                    list(node.args), node,
+                )
+
+        # chart.point.now/new/from_index/from_time/copy — REAL data (a ChartPoint
+        # aggregate). Routed here BEFORE the obj.field.method receiver logic,
+        # which would otherwise mis-treat ``chart.point`` as a receiver object
+        # and raise on the ``chart.point`` member read (chart ∈ SKIP_NAMESPACES).
+        if self._is_chart_point_callee(callee):
+            cp_func, _cp_ns = self._resolve_callee(callee)
+            return self._emit_chart_point(cp_func, node)
+
         # obj.field.method(args) — must not lower to namespace::method (loses receiver chain).
         if isinstance(callee, MemberAccess):
             obj = callee.object
@@ -321,10 +351,22 @@ class CallVisitor:
             return f"is_na({args})"
 
         # nz(x) / nz(x, y)
+        #
+        # x's emitted C++ source is substituted into the surrounding
+        # expression, so it must be evaluated EXACTLY ONCE: when x is a
+        # stateful call (e.g. a ta.* site lowered to `.compute()`/
+        # `.recompute()`), naively embedding {x} twice — once for the
+        # is_na() check, once for the non-na branch — invokes that call
+        # twice per bar, silently corrupting the indicator's internal state
+        # (e.g. nz(ta.sma(v, 50), v) becomes an effective 25-bar SMA: every
+        # bar is pushed into the ring buffer twice). An immediately-invoked
+        # lambda hoists x into a local `auto` so it is computed once and
+        # both branches read the same value; `[&]` is safe here since the
+        # lambda is called synchronously and discarded, never escaping.
         if func_name == "nz" and namespace is None:
             x = self._visit_expr(node.args[0])
             y = self._visit_expr(node.args[1]) if len(node.args) > 1 else "0.0"
-            return f"(is_na({x}) ? {y} : {x})"
+            return f"([&]{{ auto _nz_v = ({x}); return is_na(_nz_v) ? ({y}) : _nz_v; }}())"
 
         # fixnan(x) -> persistent state
         if func_name == "fixnan" and namespace is None:
@@ -414,7 +456,7 @@ class CallVisitor:
 
         # Array operations — emit proper C++ vector operations
         if namespace == "array":
-            if func_name in ("new", "new_float", "new_int", "new_bool", "new_string"):
+            if func_name in ("new", "new_float", "new_int", "new_bool", "new_string") or func_name in ARRAY_DRAWING_NEW_CTORS:
                 spec = self._type_spec_from_expr(node) or TypeSpec.array(TypeSpec.primitive("float"))
                 cpp_type = self._type_spec_to_cpp(spec)
                 init_default = self._default_for_spec(spec.element if spec.element is not None else TypeSpec.primitive("float"))
@@ -446,6 +488,16 @@ class CallVisitor:
         if namespace is None and func_name == "color" and func_name not in self._func_names:
             return "0"
 
+        # Drawing-objects-as-data namespace-functional form (spec §4.3 form 1):
+        # line.new(...) / line.get_y2(ln) / box.set_top(b, v) / linefill.new(...)
+        # MUST precede the SKIP_NAMESPACES early-return (these namespaces were
+        # removed from SKIP_NAMESPACES). chart.point.* resolves to namespace
+        # "chart", so it is matched by callee shape instead.
+        if namespace in DRAWING_NS:
+            return self._emit_drawing_namespace_call(namespace, func_name, node)
+        if self._is_chart_point_callee(callee):
+            return self._emit_chart_point(func_name, node)
+
         # Skip visual/unsupported namespace calls
         if namespace in SKIP_NAMESPACES or namespace in SKIP_VAR_TYPES:
             return "0"
@@ -468,19 +520,34 @@ class CallVisitor:
                             all_args.append(None)
                         all_args[i] = node.kwargs[pname]
                 
-                # Find matching security call ID
-                sec_id = None
-                tf_node = None
-                expr_node = None
-                for item in self._security_calls:
-                    sid, tfn, exprn = item["sec_id"], item["tf_node"], item["expr_node"]
-                    if item.get("is_lower_tf_array"):
-                        continue
-                    if exprn is all_args[2] if len(all_args) > 2 else False:
-                        sec_id = sid
-                        tf_node = tfn
-                        expr_node = exprn
-                        break
+                # Find matching security call ID. A request.security whose
+                # timeframe is a UDF parameter called from multiple sites with
+                # multiple distinct literal timeframes is registered as N
+                # CLONES (one SecurityCallInfo per call site, same source
+                # expr_node identity, distinct sec_id/callsite_idx — see
+                # Analyzer._check_mixed_callsite_security_tf). All clones
+                # match the identity check below identically, so when more
+                # than one matches, disambiguate by which call-site clone's
+                # function body is currently being emitted
+                # (self._active_call_site_idx, set by _emit_func_def while
+                # walking that exact clone's body).
+                candidates = [
+                    item for item in self._security_calls
+                    if not item.get("is_lower_tf_array")
+                    and (exprn := item["expr_node"]) is not None
+                    and (len(all_args) > 2 and exprn is all_args[2])
+                ]
+                chosen = None
+                if len(candidates) == 1:
+                    chosen = candidates[0]
+                elif len(candidates) > 1:
+                    chosen = next(
+                        (c for c in candidates
+                         if c.get("callsite_idx") == self._active_call_site_idx),
+                        candidates[0],
+                    )
+                sec_id = chosen["sec_id"] if chosen else None
+                expr_node = chosen["expr_node"] if chosen else None
 
                 if sec_id is not None and expr_node is not None:
                     if isinstance(expr_node, TupleLiteral):
@@ -522,9 +589,12 @@ class CallVisitor:
 
         # ticker.* calls
         if namespace == "ticker":
-            # ticker.inherit(symbol, ...) and ticker.standard(symbol) — passthrough:
-            # emit the symbol argument unchanged (same-symbol passthrough).
-            if func_name in ("inherit", "standard"):
+            # ticker.inherit(symbol, ...) / ticker.standard(symbol) — passthrough,
+            # and ticker.heikinashi(symbol) — same-symbol HA: emit the symbol
+            # argument unchanged. The runtime HA candle transform is applied by
+            # the engine via register_security_eval's heikinashi flag, so the
+            # ticker value itself just needs to be the (string) chart symbol.
+            if func_name in ("inherit", "standard", "heikinashi"):
                 if node.args:
                     return self._visit_expr(node.args[0])
                 if "symbol" in node.kwargs:
@@ -915,10 +985,19 @@ class CallVisitor:
                 elif f.default:
                     val = self._visit_expr(f.default)
                 if val is not None:
-                    # Fix narrowing: cast na<double>() to correct type for int fields
+                    # Fix narrowing: brace-init (``T{.field = v}``) disallows
+                    # narrowing. Pine ``int`` UDT fields are emitted as
+                    # ``int64_t`` (see base.py) but are initialised from
+                    # ``na<double>()`` / doubles in places, so cast to the
+                    # field's type. ``na<double>()`` for an int field → 0.
                     f_cpp_type = self._type_spec_to_cpp(field_specs.get(f.name) or self._type_spec_from_hint_name(f.type_name))
-                    if f_cpp_type == "int" and "na<double>" in val:
-                        val = val.replace("na<double>()", "0")
+                    if f_cpp_type == "int":
+                        f_cpp_type = "int64_t"
+                    if f_cpp_type == "int64_t":
+                        if "na<double>" in val:
+                            val = val.replace("na<double>()", "na<int64_t>()")
+                        else:
+                            val = f"(int64_t)({val})"
                     field_inits.append(f".{f.name} = {val}")
             # Mark the constructed object non-na (the struct's ``__pf_na`` is the
             # last declared field, so this designator stays in declaration order).
@@ -1012,6 +1091,17 @@ class CallVisitor:
                 all_args.extend(self._visit_expr(v) for v in node.kwargs.values())
         else:
             all_args = [_visit_arg_for_series(a, i) for i, a in enumerate(node.args)]
+        # Drawing-style/visual CONSTANT passed positionally into a user function's
+        # ``string`` parameter: ``label.style_*`` / ``size.*`` / other
+        # DRAWING_STYLE_NS members lower to the bare token ``"0"`` (they only ever
+        # feed dropped visual kwargs). Bound to a ``std::string`` parameter, that
+        # ``0`` constructs ``std::string((char const*)0)`` at the call site -> a
+        # null-pointer ``strlen`` crash at runtime. Coerce such args to
+        # ``std::string("")`` so the (inert, visual-only) value is a valid empty
+        # string. Only touches user functions with a known string param and an
+        # arg that is exactly such a drawing-style constant read.
+        if namespace is None and func_name in self._func_names:
+            self._coerce_drawing_style_string_args(func_name, node.args, all_args)
         # Default args (parser does not store defaults): isInSession(sess, res = timeframe.period)
         if namespace is None and func_name in self._func_names:
             fi = self._func_info_map.get(func_name)
@@ -1023,7 +1113,16 @@ class CallVisitor:
         emit_name = self._func_safe_name(func_name) if func_name in self._func_names else func_name
         # Per-call-site variant: if this function has TA/series calls, call the correct variant
         cs_info = self.ctx.func_call_cs_map.get(id(node))
-        if self._active_call_site_idx is not None and cs_info is not None:
+        dispatch_key = (self._current_instance_name, id(node))
+        if dispatch_key in self._instance_dispatch:
+            # Context-sensitive (call-path) dispatch: the instance pre-pass
+            # resolved this nested stateful-helper call to the clone bound to
+            # THIS enclosing path's members (see _build_func_instances). This
+            # is authoritative — it supersedes the textual-cs threading below,
+            # which conflates a callee's own call sites with the enclosing
+            # function's call sites for helpers reached through >1 path.
+            emit_name = self._instance_dispatch[dispatch_key]
+        elif self._active_call_site_idx is not None and cs_info is not None:
             # Inside a per-call-site variant: override the cs_map index with
             # the parent's active call-site index. This ensures sub-functions
             # called from ma_cs6() use their _cs6 variant, not _cs0.
@@ -1040,6 +1139,32 @@ class CallVisitor:
             emit_name = f"{self._func_safe_name(func_name)}_cs{self._active_call_site_idx}"
         return f"{prefix}{emit_name}({', '.join(all_args)})"
 
+    def _coerce_drawing_style_string_args(self, func_name, arg_nodes, all_args) -> None:
+        """In-place coerce positional args bound to a ``std::string`` user-function
+        parameter that lowered to the bare token ``"0"`` from a drawing-style /
+        visual constant (``label.style_*`` etc.). Such a literal ``0`` binds as
+        ``std::string((char const*)0)`` and segfaults on first use. Replace with
+        ``std::string("")`` (the value is visual-only and inert in a backtest)."""
+        from .tables import DRAWING_STYLE_NS
+        fi = self._func_info_map.get(func_name)
+        if not fi or not getattr(fi, "node", None) or not fi.node.params:
+            return
+        specs = getattr(fi, "param_type_specs", []) or []
+        for i, arg in enumerate(arg_nodes):
+            if i >= len(all_args) or all_args[i] != "0":
+                continue
+            # Only when the destination parameter is a string.
+            spec = specs[i] if i < len(specs) else None
+            is_string_param = spec is not None and getattr(spec, "kind", None) == "primitive" \
+                and getattr(spec, "name", None) == "string"
+            if not is_string_param:
+                continue
+            # Only when the source really is a drawing-style/visual constant read
+            # (so we never silently turn a numeric ``0`` into an empty string).
+            if (isinstance(arg, MemberAccess) and isinstance(arg.object, Identifier)
+                    and arg.object.name in DRAWING_STYLE_NS):
+                all_args[i] = 'std::string("")'
+
     def _visit_fixnan(self, node: FuncCall) -> str:
         """Emit fixnan with persistent state member."""
         self._fixnan_counter += 1

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>()
@@ -589,6 +629,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 +708,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

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.
@@ -291,7 +296,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)
@@ -401,12 +406,57 @@ 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
+
         # 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)
             lines.append(f"{pad}{cpp_type} {safe} = {cpp_val};")
 
     @staticmethod
@@ -476,6 +526,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 +565,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 +575,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:
@@ -600,7 +656,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,20 +716,73 @@ 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}) {{")
+        if node.step is not None:
+            # Explicit `by` step: unchanged from before — ascending compare
+            # (matches every existing corpus use, all positive literal steps).
+            step = self._visit_expr(node.step)
+            lines.append(f"{pad}for (int {var} = {start}; {var} <= {end}; {var} += {step}) {{")
+        else:
+            # No `by` clause: Pine v6 auto-infers the loop direction from
+            # start/end — descending (step -1) when start > end, else
+            # ascending (step +1); see the Pine v6 `for` reference. start/end
+            # are arbitrary runtime expressions (``for i = array.size(arr)-1
+            # to 0`` — a common "iterate backward to safely remove an element
+            # while iterating" idiom), so the direction can't always be
+            # resolved at codegen time. Compute start/end into locals ONCE
+            # (avoids re-evaluating a side-effecting expression, same class
+            # of bug as nz()'s double-eval) and pick the comparison direction
+            # at runtime from their relative order — this previously always
+            # emitted an ascending `<=` loop, which never executes when
+            # start > end (silently dropping the whole loop body).
+            fid = self._for_counter
+            self._for_counter += 1
+            s_var, e_var = f"_for_start_{fid}", f"_for_end_{fid}"
+            lines.append(f"{pad}int {s_var} = ({start}), {e_var} = ({end});")
+            lines.append(
+                f"{pad}for (int {var} = {s_var}; "
+                f"({s_var} <= {e_var}) ? ({var} <= {e_var}) : ({var} >= {e_var}); "
+                f"{var} += ({s_var} <= {e_var}) ? 1 : -1) {{"
+            )
         # 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)
+        _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)
@@ -664,12 +796,17 @@ class StmtVisitor:
                     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
 
@@ -677,8 +814,12 @@ class StmtVisitor:
         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 +868,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};")