@pineforge/codegen-pyodide 0.7.6 → 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"))
@@ -439,6 +481,23 @@ class CallVisitor:
         if namespace == "color":
             return self._visit_color_call(func_name, node)
 
+        # Bare color(...) cast (cosmetic). The engine has no color-cast helper
+        # and colors have no backtest-logic effect, so emit a benign default
+        # color (0 = na color, matching the color.new / from_gradient
+        # fallbacks). The support checker warns on this construct.
+        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"
@@ -461,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):
@@ -515,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:
@@ -908,11 +985,25 @@ 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).
+            # A bare default-constructed UDT keeps ``__pf_na = true`` (na); only a
+            # real ``.new(...)`` flips it false so ``na(obj)`` reports correctly.
+            field_inits.append(".__pf_na = false")
             return f"{namespace}{{{', '.join(field_inits)}}}"
 
         # UDT copy: TypeName.copy(obj)
@@ -1000,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)
@@ -1011,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.
@@ -1028,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,
@@ -180,7 +182,7 @@ class ExprVisitor:
         if isinstance(node, NumberLiteral):
             return str(node.value)
         if isinstance(node, StringLiteral):
-            return f'std::string("{node.value}")'
+            return f'std::string("{self._cpp_string_escape(node.value)}")'
         if isinstance(node, BoolLiteral):
             return "true" if node.value else "false"
         if isinstance(node, NaLiteral):
@@ -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>()
@@ -475,8 +515,17 @@ class ExprVisitor:
                 if node.member in ("is_heikinashi", "is_kagi", "is_linebreak",
                                    "is_pnf", "is_range", "is_renko"):
                     return "false"
-                # Defensive: support_checker.UNSUPPORTED_MEMBERS should already have
-                # rejected any unhandled chart.* member. Reaching here is a bug.
+                # Cosmetic / chart-only reads with no batch-mode value (theme
+                # colors, viewport bar times). The support checker warns on
+                # these (COSMETIC_MEMBERS); emit a benign default (0 = na color /
+                # epoch 0). They have no backtest-logic effect.
+                if node.member in ("fg_color", "bg_color",
+                                   "left_visible_bar_time",
+                                   "right_visible_bar_time"):
+                    return "0"
+                # Defensive: support_checker (COSMETIC_MEMBERS / UNSUPPORTED_MEMBERS)
+                # should already have warned/rejected any unhandled chart.* member.
+                # Reaching here is a bug.
                 raise ValueError(
                     f"codegen: unhandled chart.{node.member} — analyzer should have rejected. "
                     f"Add a handler above or extend UNSUPPORTED_MEMBERS."
@@ -580,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":
@@ -651,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
@@ -717,6 +780,31 @@ class ExprVisitor:
                     if series_name not in self._strategy_series_vars:
                         self._strategy_series_vars.add(series_name)
                     return f"{series_name}[{idx}]"
+        # History reference applied directly to an inline call result, e.g.
+        # ``ta.highest(high, 10)[1]`` or ``f()[2]``. In Pine the call yields a
+        # series, so ``[k]`` reads its value k bars ago — but the call lowers to
+        # a freshly-computed C++ scalar, and ``scalar[k]`` is not subscriptable.
+        # Materialize the result into a self-contained history buffer: a static
+        # ``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.
+        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"
+            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})]; }}())"
+            )
         obj = self._visit_expr(node.object)
         # If subscripting a non-series variable (e.g., function parameter),
         # src[0] → src (current value), src[N>0] → src (can't access history)