@pineforge/codegen-pyodide 0.8.0 → 0.9.0

package/pineforge_codegen/codegen/visit_call.py

@@ -136,15 +136,20 @@ from ..ast_nodes import (
     FuncCall,
     Identifier,
     MemberAccess,
+    NaLiteral,
     TupleLiteral,
     StringLiteral,
 )
 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,
@@ -156,6 +161,7 @@ from .tables import (
     SKIP_VAR_TYPES,
     STR_FUNC_MAP,
     TIME_FIELD_EXPRS,
+    _math_minmax_na_expr,
     _merge_kwargs,
     _merge_kwargs_with_defaults,
     tz_time_field_lambda,
@@ -170,9 +176,21 @@ def _parse_pine_datestring_ms(text: str) -> int | None:
     "MMM DD YYYY ..." forms. A dateString without a time zone is GMT+0 per
     the Pine reference. Returns None when the string cannot be parsed.
     """
-    from datetime import datetime, timezone
+    import re
+    from datetime import datetime, timezone, timedelta
 
     txt = text.strip()
+    # Pine dateStrings may carry a trailing timezone WORD ("2024-01-01 00:00 UTC",
+    # "1 Jan 2020 09:30 GMT+2") that neither fromisoformat nor the strptime forms
+    # below can read. Peel it off and fold it into an explicit offset (UTC/GMT
+    # with an optional ±H[:MM] suffix; the bare word is +00:00).
+    tzoff = None
+    m = re.search(r"\s+(?:UTC|GMT)([+-]\d{1,2})?(?::?(\d{2}))?$", txt, re.I)
+    if m:
+        txt = txt[: m.start()].strip()
+        h = int(m.group(1) or 0)
+        mm = int(m.group(2) or 0)
+        tzoff = timezone(timedelta(hours=h, minutes=(mm if h >= 0 else -mm)))
     dt = None
     try:
         dt = datetime.fromisoformat(txt)
@@ -182,6 +200,7 @@ def _parse_pine_datestring_ms(text: str) -> int | None:
             "%d %b %Y %H:%M:%S", "%d %b %Y %H:%M", "%d %b %Y",
             "%b %d %Y %H:%M:%S %z", "%b %d %Y %H:%M %z",
             "%b %d %Y %H:%M:%S", "%b %d %Y %H:%M", "%b %d %Y",
+            "%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M", "%Y-%m-%d",
         ):
             try:
                 dt = datetime.strptime(txt, fmt)
@@ -191,7 +210,7 @@ def _parse_pine_datestring_ms(text: str) -> int | None:
     if dt is None:
         return None
     if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
+        dt = dt.replace(tzinfo=(tzoff or timezone.utc))
     return int(dt.timestamp() * 1000)
 
 
@@ -205,6 +224,63 @@ class CallVisitor:
     # Function-call dispatch
     # ------------------------------------------------------------------
 
+    def _udt_method_call_emit_name(self, fi, node: FuncCall) -> str:
+        """Resolve a UDT method call through the ordinary UDF clone graph."""
+        base = self._emit_udt_method_cpp_name(fi)
+        dispatch = self._instance_dispatch.get(
+            (self._current_instance_name, id(node))
+        )
+        if dispatch is not None:
+            return dispatch
+
+        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:
+            return f"{base}_cs{self._active_call_site_idx}"
+        if cs_info is not None and cs_info[0] == fi.name:
+            return f"{base}_cs{cs_info[1]}"
+        if (self._active_call_site_idx is not None
+                and self.ctx.func_call_site_counts.get(fi.name, 0) > 1):
+            return f"{base}_cs{self._active_call_site_idx}"
+        return base
+
+    def _array_init_value_expr(self, elem_spec: TypeSpec | None, value_node) -> str:
+        if isinstance(value_node, NaLiteral):
+            if elem_spec is not None and elem_spec.kind == "udt":
+                return self._default_for_spec(elem_spec)
+            cpp_type = self._type_spec_to_cpp(elem_spec)
+            if cpp_type in ("double", "int", "int64_t", "bool", "std::string"):
+                return f"na<{cpp_type}>()"
+            return self._default_for_spec(elem_spec)
+        return self._visit_expr(value_node)
+
+    def _array_method_args(
+        self, method: str, arg_nodes: list, spec: TypeSpec | None,
+    ) -> list[str]:
+        elem_spec = (
+            spec.element
+            if spec is not None and spec.kind == "array" and spec.element is not None
+            else TypeSpec.primitive("float")
+        )
+        value_arg_indexes = {
+            "set": {1},
+            "push": {0},
+            "unshift": {0},
+            "insert": {1},
+            "fill": {0},
+            "includes": {0},
+            "indexof": {0},
+            "lastindexof": {0},
+            "binary_search": {0},
+            "binary_search_leftmost": {0},
+            "binary_search_rightmost": {0},
+        }.get(method, set())
+        return [
+            self._array_init_value_expr(elem_spec, arg)
+            if idx in value_arg_indexes
+            else self._visit_expr(arg)
+            for idx, arg in enumerate(arg_nodes)
+        ]
+
     def _visit_func_call(self, node: FuncCall) -> str:
         callee = node.callee
         if isinstance(callee, MemberAccess):
@@ -213,7 +289,7 @@ class CallVisitor:
                 mk = f"{recv_spec.name}.{callee.member}"
                 fi_u = self._func_info_map.get(mk)
                 if fi_u is not None and getattr(fi_u, "is_udt_method", False):
-                    fn_cpp = self._emit_udt_method_cpp_name(fi_u)
+                    fn_cpp = self._udt_method_call_emit_name(fi_u, node)
                     recv_e = self._visit_expr(callee.object)
                     param_names = list(fi_u.node.params[1:]) if fi_u.node else []
                     # Drop the leading ``self`` slot from param_defaults so the
@@ -226,6 +302,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
@@ -240,7 +342,9 @@ class CallVisitor:
                     meth = callee.member
                     raw_args = [self._visit_expr(a) for a in node.args]
                     if recv_spec is not None and recv_spec.kind == "array" and meth in ARRAY_METHODS:
-                        return self._array_method_expr(recv, meth, raw_args, recv_spec)
+                        return self._array_method_expr(
+                            recv, meth, self._array_method_args(meth, node.args, recv_spec), recv_spec
+                        )
                     if recv_spec is not None and recv_spec.kind == "map" and meth in MAP_METHODS:
                         return self._map_method_expr(recv, meth, raw_args, recv_spec)
                     args = ", ".join(raw_args)
@@ -264,7 +368,9 @@ class CallVisitor:
                         return self._map_method_expr(m, meth_raw, margs, self._map_spec_for_name(oname))
                     if oname in self._array_vars and meth_raw in ARRAY_METHODS:
                         arr = self._safe_name(oname)
-                        margs = [self._visit_expr(a) for a in node.args]
+                        margs = self._array_method_args(
+                            meth_raw, node.args, self._array_spec_for_name(oname)
+                        )
                         return self._array_method_expr(arr, meth_raw, margs, self._array_spec_for_name(oname))
                     if oname in self._matrix_specs and meth_raw in MATRIX_METHODS:
                         arr = self._safe_name(oname)
@@ -293,7 +399,7 @@ class CallVisitor:
                         mk = f"{udt_t}.{meth_raw}"
                         fi_u = self._func_info_map.get(mk)
                         if fi_u is not None and getattr(fi_u, "is_udt_method", False):
-                            fn_cpp = self._emit_udt_method_cpp_name(fi_u)
+                            fn_cpp = self._udt_method_call_emit_name(fi_u, node)
                             recv_e = self._visit_expr(obj)
                             param_names = list(fi_u.node.params[1:]) if fi_u.node else []
                             # Drop the leading ``self`` slot so param_defaults
@@ -321,10 +427,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:
@@ -345,11 +463,19 @@ class CallVisitor:
         if site is not None:
             compute_args = self._ta_compute_args_for_site(site)
             ta_mem = self._ta_member_name(site)
-            if getattr(self, "_precalc_loop_active", False) and getattr(site, "is_static", False):
+            uses_precalc = self._ta_site_uses_precalc(site)
+            if getattr(self, "_precalc_loop_active", False) and uses_precalc:
                 return f"_precalc_{ta_mem}[i]"
-            if getattr(site, "is_static", False):
-                return f"(_use_precalc ? _precalc_{ta_mem}[bar_index_] : (is_first_tick_ ? {ta_mem}.compute({compute_args}) : {ta_mem}.recompute({compute_args})))"
-            return f"(is_first_tick_ ? {ta_mem}.compute({compute_args}) : {ta_mem}.recompute({compute_args}))"
+            if uses_precalc:
+                return (
+                    f"(_use_precalc ? _precalc_{ta_mem}[bar_index_] : "
+                    f"(history_advances_new_bar() ? {ta_mem}.compute({compute_args}) "
+                    f": {ta_mem}.recompute({compute_args})))"
+                )
+            return (
+                f"(history_advances_new_bar() ? {ta_mem}.compute({compute_args}) "
+                f": {ta_mem}.recompute({compute_args}))"
+            )
 
         # math.* calls
         if namespace == "math":
@@ -409,18 +535,23 @@ class CallVisitor:
         # Array method syntax: arr.push(val) where namespace is the array variable name
         if namespace is not None and namespace in self._array_vars and func_name in ARRAY_METHODS:
             arr = self._safe_name(namespace)
-            args = [self._visit_expr(a) for a in node.args]
-            return self._array_method_expr(arr, func_name, args, self._array_spec_for_name(namespace))
+            spec = self._array_spec_for_name(namespace)
+            args = self._array_method_args(func_name, node.args, spec)
+            return self._array_method_expr(arr, func_name, args, spec)
 
         # 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"))
+                elem_spec = spec.element if spec.element is not None else TypeSpec.primitive("float")
+                init_default = self._default_for_spec(elem_spec)
                 if node.args:
                     size_arg = self._visit_expr(node.args[0])
-                    init_val = self._visit_expr(node.args[1]) if len(node.args) > 1 else init_default
+                    if len(node.args) > 1:
+                        init_val = self._array_init_value_expr(elem_spec, node.args[1])
+                    else:
+                        init_val = init_default
                     return f"{cpp_type}((size_t)({size_arg}), {init_val})"
                 return f"{cpp_type}()"
             if func_name == "from":
@@ -430,8 +561,8 @@ class CallVisitor:
             # Method calls: array.method(arr, args...)
             if func_name in ARRAY_METHODS and node.args:
                 arr = self._visit_expr(node.args[0])
-                rest = [self._visit_expr(a) for a in node.args[1:]]
                 spec = self._type_spec_from_expr(node.args[0])
+                rest = self._array_method_args(func_name, node.args[1:], spec)
                 return self._array_method_expr(arr, func_name, rest, spec)
             return "0"
 
@@ -446,6 +577,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 +609,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 +678,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:
@@ -595,11 +754,12 @@ class CallVisitor:
                 # mutex-guarded setenv+localtime_r block as the 2-arg
                 # form.
                 tz_arg = "syminfo_.timezone"
-            # 2-arg form — honor the tz argument. The shared
-            # ``tz_time_field_lambda`` (codegen/tables.py) also backs the
-            # bare variable forms (``hour`` etc. via BAR_BUILTINS), so the
-            # numbers agree across both forms.
-            return tz_time_field_lambda(field_expr, ts_arg, tz_arg)
+            # Route through the engine's cached pine_<field>() (session_time.hpp),
+            # same as the bare variable forms (BAR_BUILTINS) — value-identical but
+            # free of the per-call setenv+tzset churn (KI-35). field_expr is unused
+            # now (the engine applies the Pine offsets internally).
+            del field_expr
+            return f"pine_{func_name}((int64_t)({ts_arg}), {tz_arg})"
 
         # time(timeframe) or time(timeframe, session[, tz])
         if func_name == "time" and namespace is None and (node.args or node.kwargs):
@@ -629,6 +789,8 @@ class CallVisitor:
                     is_tz_first = True
                 elif isinstance(node.args[0], StringLiteral):
                     is_tz_first = True
+                elif self._infer_type(node.args[0]) == "std::string":
+                    is_tz_first = True
 
             if is_tz_first:
                 # A single string argument is the timestamp(dateString)
@@ -678,7 +840,7 @@ class CallVisitor:
                 sc = args[6] if len(args) > 6 else "0"
                 return (
                     f"[&]() -> int64_t {{ "
-                    f"std::string _tz = ({tz}); "
+                    f"std::string _tz = pineforge::normalize_timezone_for_posix(({tz})); "
                     f"int _yr = ({yr}); int _mo = ({mo}); int _dy = ({dy}); "
                     f"int _hr = ({hr}); int _min = ({mn}); int _sc = ({sc}); "
                     f"static thread_local std::string _last_tz; "
@@ -690,6 +852,7 @@ class CallVisitor:
                     f"struct tm t = {{}}; "
                     f"t.tm_year = _yr - 1900; t.tm_mon = _mo - 1; "
                     f"t.tm_mday = _dy; t.tm_hour = _hr; t.tm_min = _min; t.tm_sec = _sc; "
+                    f"t.tm_isdst = -1; "
                     f"int64_t _res; "
                     f"if (_tz.empty() || _tz == \"UTC\" || _tz == \"Etc/UTC\") {{ "
                     f"_res = (int64_t)timegm(&t) * 1000; "
@@ -770,7 +933,15 @@ class CallVisitor:
         if func_name == "float" and namespace is None and node.args:
             return f"(double)({self._visit_expr(node.args[0])})"
         if func_name == "bool" and namespace is None and node.args:
-            return f"(bool)({self._visit_expr(node.args[0])})"
+            # Pine v6 bools are two-state. Explicit bool(int/float) treats na
+            # like false, while a raw C++ cast would make NaN truthy.
+            x = self._visit_expr(node.args[0])
+            return (
+                f"[&](){{ auto _pf_v = ({x}); "
+                f"using _pf_t = std::decay_t<decltype(_pf_v)>; "
+                f"if constexpr (std::is_same_v<_pf_t, bool>) {{ return _pf_v; }} "
+                f"else {{ return is_na(_pf_v) ? false : (bool)_pf_v; }} }}()"
+            )
         if func_name == "string" and namespace is None and node.args:
             # Pine string(x) cast — same emission as str.tostring(x), with
             # string passthrough and TV-style "true"/"false" for bools
@@ -915,10 +1086,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).
@@ -981,17 +1161,32 @@ class CallVisitor:
 
         def _visit_arg_for_series(arg_node, arg_idx):
             """Visit a function argument, returning Series ref for series params."""
-            if arg_idx in _func_series_param_indices and isinstance(arg_node, Identifier):
-                aname = arg_node.name
-                # Bar field: pass _s_close instead of current_bar_.close
-                if aname in BAR_FIELDS or aname in BAR_SERIES_PUSH:
-                    return f"_s_{aname}"
-                # Series var: pass the Series object directly
-                if aname in self.ctx.series_vars:
-                    safe = self._safe_name(aname)
-                    if self._active_var_remap and safe in self._active_var_remap:
-                        safe = self._active_var_remap[safe]
-                    return safe
+            if arg_idx in _func_series_param_indices:
+                if isinstance(arg_node, Identifier):
+                    aname = arg_node.name
+                    # Bar field: pass _s_close instead of current_bar_.close
+                    if aname in BAR_FIELDS or aname in BAR_SERIES_PUSH:
+                        return f"_s_{aname}"
+                    # Series var: pass the Series object directly
+                    if aname in self.ctx.series_vars:
+                        safe = self._safe_name(aname)
+                        if self._active_var_remap and safe in self._active_var_remap:
+                            safe = self._active_var_remap[safe]
+                        return safe
+                expr_cpp = self._visit_expr(arg_node)
+                cpp_t = self._infer_type(arg_node)
+                if cpp_t not in ("double", "int", "bool"):
+                    cpp_t = "double"
+                member = self._inline_history_member(
+                    "series_arg", node, arg_idx=arg_idx
+                )
+                return (
+                    f"([&]() -> const Series<{cpp_t}>& {{ "
+                    f"{cpp_t} _sv = ({expr_cpp}); "
+                    f"if (history_advances_new_bar()) {member}.push(_sv); "
+                    f"else {member}.update(_sv); "
+                    f"return {member}; }}())"
+                )
             return self._visit_expr(arg_node)
 
         if node.kwargs:
@@ -1012,6 +1207,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 +1229,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,10 +1255,62 @@ 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
-        member = f"_prev_fixnan_{self._fixnan_counter}"
+        # Variant-aware lookup keyed off the analyzer-tracked site:
+        #   * function-owned site -> dispatch through the active per-call-site
+        #     remap so each emitted variant (cs0/cs1/__ni{N}) references its
+        #     OWN previous-value member.
+        #   * top-level site (owner_func is None) -> use ``site.member_name``
+        #     directly. The declarations come from ``ctx.fixnan_sites`` keyed
+        #     by these member names, so referencing anything else (e.g. the
+        #     legacy monotonic counter) would either dangle a declaration or
+        #     silently alias another site's state. In particular, when a
+        #     function-owned fixnan is analyzed BEFORE a top-level one, the
+        #     counter would restart at 1 and collide with the function's
+        #     ``_prev_fixnan_1`` -- corrupting both. Using the site's own
+        #     member name keeps declaration and reference in lockstep.
+        #   * unmapped site (node not in the site map, e.g. a fixnan reached
+        #     only through a path the analyzer didn't register) -> fall back
+        #     to the legacy monotonic counter so emission still produces a
+        #     referenceable member.
+        site = self._fixnan_site_map.get(id(node))
+        if site is not None:
+            if site.member_name in self._func_fixnan_members:
+                member = self._active_fixnan_remap.get(
+                    site.member_name, site.member_name
+                )
+            else:
+                member = site.member_name
+        else:
+            self._fixnan_counter += 1
+            member = f"_prev_fixnan_{self._fixnan_counter}"
         x = self._visit_expr(node.args[0])
         return f"(is_na({x}) ? {member} : ({member} = {x}))"
 
@@ -1127,17 +1394,17 @@ class CallVisitor:
                 qty_val = self._visit_expr(qty_n) if qty_n else "na<double>()"
                 comment = self._visit_expr(comment_n) if comment_n is not None else '""'
                 oca_val = self._visit_expr(oca_name_n) if oca_name_n is not None else '""'
+                profit_ticks = "na<double>()"
+                loss_ticks = "na<double>()"
 
                 if profit_n and not limit_n:
-                    ticks = self._visit_expr(profit_n)
-                    limit_val = f"(position_entry_price_ + (signed_position_size() > 0 ? 1.0 : -1.0) * ({ticks}) * syminfo_mintick_)"
+                    profit_ticks = self._visit_expr(profit_n)
                 if loss_n and not stop_n:
-                    ticks = self._visit_expr(loss_n)
-                    stop_val = f"(position_entry_price_ - (signed_position_size() > 0 ? 1.0 : -1.0) * ({ticks}) * syminfo_mintick_)"
+                    loss_ticks = self._visit_expr(loss_n)
 
                 return (f"strategy_exit({exit_id}, {from_id}, {limit_val}, {stop_val}, "
                         f"{trail_pts}, {trail_off}, {trail_pr}, {qty_pct}, {comment}, "
-                        f"{qty_val}, {oca_val})")
+                        f"{qty_val}, {oca_val}, {profit_ticks}, {loss_ticks})")
             close_comment = self._visit_expr(comment_n) if comment_n is not None else '""'
             return f"strategy_close({exit_id}, {close_comment})"
 
@@ -1358,23 +1625,12 @@ class CallVisitor:
         if func_name == "avg" and len(args) > 2:
             sum_expr = " + ".join(f"(double)({a})" for a in args)
             return f"(({sum_expr}) / {len(args)}.0)"
-        if func_name == "max" and len(args) > 2:
-            result = f"std::max((double)({args[0]}), (double)({args[1]}))"
-            for a in args[2:]:
-                result = f"std::max({result}, (double)({a}))"
-            return result
-        if func_name == "min" and len(args) > 2:
-            result = f"std::min((double)({args[0]}), (double)({args[1]}))"
-            for a in args[2:]:
-                result = f"std::min({result}, (double)({a}))"
-            return result
+        if func_name in ("min", "max"):
+            return _math_minmax_na_expr(func_name, args)
         if func_name in MATH_FUNC_MAP:
             mapped = MATH_FUNC_MAP[func_name]
             if "{0}" in mapped:
                 return mapped.format(*args)
-            # std::min/std::max require same types — cast to double
-            if func_name in ("min", "max") and len(args) == 2:
-                return f"{mapped}((double)({args[0]}), (double)({args[1]}))"
             return f"{mapped}({', '.join(args)})"
         # Unknown math.* — safe fallback
         return f"0.0 /* unsupported: math.{func_name} */"