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

package/pineforge_codegen/codegen/visit_call.py

@@ -134,22 +134,36 @@ from __future__ import annotations
 
 from ..ast_nodes import (
     ASTNode,
+    Assignment,
+    BoolLiteral,
+    ColorLiteral,
+    ExprStmt,
     FuncCall,
     Identifier,
     MemberAccess,
     NaLiteral,
+    NumberLiteral,
+    Ternary,
     TupleLiteral,
     StringLiteral,
     VarDecl,
 )
+from ..external_requests import RECORDED_KEY_ANNOTATION
+from ..limits import iter_ast_nodes
+from ..security_contexts import ticker_symbol_arg
 from ..symbols import TypeSpec, method_receiver_type_name
 from ..method_binding import (
     MethodBindError,
+    bind_function_defaults,
     bind_method_call,
     signature_from_callable,
 )
 from .. import signatures as sigs
 from .drawing import ALL_DRAWING_METHODS
+from .helpers import (
+    color_alpha_cast, cpp_is_plain_read, evaluate_args_once,
+    na_preserving_int_cast, pine_truth_cast,
+)
 from .tables import (
     ARRAY_DRAWING_NEW_CTORS,
     ARRAY_METHODS,
@@ -164,15 +178,15 @@ from .tables import (
     MATRIX_METHODS,
     MATRIX_METHOD_KWARGS,
     MATRIX_NUMERIC_ONLY,
-    MATRIX_SORT_ALLOWED_GENERIC_ELEMS,
     SKIP_FUNC_NAMES,
     SKIP_NAMESPACES,
     SKIP_VAR_TYPES,
+    STR_ARGS_READ_REPEATEDLY,
     STR_FUNC_MAP,
     TIME_FIELD_EXPRS,
     _math_minmax_na_expr,
+    _math_round_digits_expr,
     _merge_kwargs,
-    tz_time_field_lambda,
 )
 
 
@@ -271,6 +285,14 @@ def _timestamp_calendar_lambda(tz: str, yr: str, mo: str, dy: str,
     )
 
 
+def _whole_transparency(node) -> bool:
+    """A color's transparency written as an integer literal from 0 to 100,
+    which the historic ``(int)`` conversion leaves as it is
+    (``color_alpha_cast``'s ``whole``)."""
+    return (isinstance(node, NumberLiteral) and isinstance(node.value, int)
+            and 0 <= node.value <= 100)
+
+
 class CallVisitor:
     """Function-call dispatch visitor methods shared across the codegen.
 
@@ -303,6 +325,8 @@ class CallVisitor:
     def _typed_user_method_info(self, receiver, member: str):
         """Resolve an exact typed user method before any builtin method."""
         receiver_spec = self._type_spec_from_expr(receiver)
+        if receiver_spec is None and isinstance(receiver, Identifier):
+            receiver_spec = self._scalar_receiver_spec(receiver.name, member)
         receiver_name = method_receiver_type_name(receiver_spec)
         if receiver_name is None:
             return receiver_spec, None
@@ -314,6 +338,138 @@ class CallVisitor:
             return receiver_spec, None
         return receiver_spec, method_info
 
+    _SCALAR_RECEIVER_TYPES = {
+        "double": ("float",), "int": ("int",), "bool": ("bool",),
+        "std::string": ("string",), "int64_t": ("int", "color"),
+    }
+
+    def _scalar_receiver_spec(self, name: str, member: str):
+        """The primitive spec of a scalar a typed method is called on, where
+        ``_type_spec_from_expr`` has only its tombstone: a global scalar is
+        recorded as bound to no user type, which hid its own primitive type
+        (``s5 = ta.ema(close, 5)``; ``s5.m()`` was emitted raw, as a member
+        call on a double). A local or parameter reads its C++ type, a global
+        its symbol; an ``int64_t`` is whichever of ``int`` and ``color`` has
+        the method."""
+        cpp = (getattr(self, "_current_func_local_types", {}).get(name)
+               or getattr(self, "_current_func_param_types", {}).get(name))
+        if cpp is not None:
+            candidates = self._SCALAR_RECEIVER_TYPES.get(cpp, ())
+        else:
+            if getattr(self, "_global_udt_types", {}).get(name, "absent") is not None:
+                return None
+            sym = self._variable_symbol(name)
+            candidates = (sym.pine_type.value,) if sym is not None else ()
+        found = [kind for kind in candidates
+                 if kind in ("float", "int", "bool", "string", "color")
+                 and f"{kind}.{member}" in self._func_info_map]
+        return TypeSpec.primitive(found[0]) if len(found) == 1 else None
+
+    _TIME_PARAMS = ("timeframe", "session", "timezone", "bars_back", "timeframe_bars_back")
+
+    def _bind_time_call(self, node: FuncCall) -> dict:
+        """``time()`` / ``time_close()`` bound to Pine v6's overloads:
+        ``(timeframe, bars_back, timeframe_bars_back)``, ``(timeframe,
+        session, bars_back, timeframe_bars_back)`` and ``(timeframe,
+        session, timezone, bars_back, timeframe_bars_back)``. An offset sits
+        where the longer form has a string, so a numeric second or third
+        argument names the shorter form (``time("", "", -1)`` is the next
+        bar's open, ``time("60", -1)`` the hour of the next bar)."""
+        def numeric(arg) -> bool:
+            return self._infer_type(arg) in ("int", "int64_t", "double")
+
+        bound = dict.fromkeys(self._TIME_PARAMS)
+        positional = list(node.args)
+        if positional:
+            bound["timeframe"] = positional[0]
+        rest = positional[1:]
+        if rest and numeric(rest[0]):
+            order = ("bars_back", "timeframe_bars_back")
+        elif len(rest) >= 2 and numeric(rest[1]):
+            order = ("session", "bars_back", "timeframe_bars_back")
+        else:
+            order = ("session", "timezone", "bars_back", "timeframe_bars_back")
+        for name, arg in zip(order, rest):
+            bound[name] = arg
+        for name, arg in node.kwargs.items():
+            if name in bound:
+                bound[name] = arg
+        return bound
+
+    def _time_offset_call(self, func_name: str, node: FuncCall) -> str | None:
+        """Lower ``time()`` / ``time_close()`` reading another bar.
+
+        A ``bars_back`` / ``timeframe_bars_back`` that is not a literal 0 reads
+        another bar's time: the host's ``pine_time_offset`` steps the chart's
+        bars and the requested timeframe's (a future bar included, as
+        TradingView reads it: lab tv tapes te_time_bb_chart / te_time_bb_tf,
+        tests/fixtures/time_bars_back). None when the call reads the current
+        bar -- no offset, or literal-0 offsets -- for the plain lowering."""
+        bound = self._bind_time_call(node)
+        offsets = [bound[name] for name in ("bars_back", "timeframe_bars_back")
+                   if bound[name] is not None]
+        if all(isinstance(o, NumberLiteral) and o.value == 0 for o in offsets):
+            return None
+        if self._security_payload_depth:
+            self._codegen_error(
+                node,
+                f"{func_name}() with bars_back / timeframe_bars_back inside "
+                "request.security is not supported",
+                hint=f"Read {func_name}() with its offset outside request.security().",
+            )
+
+        def text(name: str, default: str) -> str:
+            arg = bound[name]
+            return self._visit_expr(arg) if arg is not None else default
+
+        def offset(name: str) -> str:
+            arg = bound[name]
+            if arg is None:
+                return "0"
+            return self._coerce_int_slot(f"({self._visit_expr(arg)})", arg, "int")
+
+        close = "true" if func_name == "time_close" else "false"
+        empty = 'std::string("")'
+        return (
+            f"pine_time_offset(current_bar_.timestamp, {offset('bars_back')}, "
+            f"{text('timeframe', 'script_tf_')}, {text('session', empty)}, "
+            f"{text('timezone', empty)}, {offset('timeframe_bars_back')}, {close})"
+        )
+
+    def _check_time_bars_back(self, func_name: str, node: FuncCall) -> FuncCall:
+        """``time()`` / ``time_close()`` reading the current bar, spelled for
+        the plain lowering: its timeframe, session and timezone in order,
+        literal-0 offsets dropped (``time_close("", 0)`` read the 0 as its
+        session)."""
+        bound = self._bind_time_call(node)
+        if all(bound[name] is None for name in ("bars_back", "timeframe_bars_back")):
+            return node
+        positional = []
+        kwargs = {}
+        for name in ("timeframe", "session", "timezone"):
+            if bound[name] is None:
+                continue
+            if len(positional) == ("timeframe", "session", "timezone").index(name):
+                positional.append(bound[name])
+            else:
+                kwargs[name] = bound[name]
+        return FuncCall(callee=node.callee, args=positional, kwargs=kwargs,
+                        loc=node.loc, annotations=node.annotations)
+
+    def _user_call_args_with_defaults(self, func_name: str, node: FuncCall):
+        """A plain user-function call's arguments with omitted parameters
+        filled from their declared defaults (``bind_function_defaults``);
+        ``None`` when the established binding applies."""
+        fi = self._func_info_map.get(func_name)
+        if (fi is None or fi.node is None or not fi.node.params
+                or getattr(fi, "is_udt_method", False)):
+            return None
+        return bind_function_defaults(
+            fi.node.params,
+            (fi.node.annotations or {}).get("param_defaults", ()),
+            node,
+        )
+
     def _bind_typed_method_args(self, method_info, node: FuncCall):
         """Bind typed method arguments through the analyzer-shared rules."""
 
@@ -387,6 +543,12 @@ class CallVisitor:
             )
             for index, arg in enumerate(rest_nodes)
         ]
+        method_cs = self._callable_target_callsite_idx(method_info, node)
+        for index, arg in enumerate(rest_nodes, start=1):
+            if self._func_param_is_bool(method_info, index, method_cs):
+                rest_cpp[index - 1] = self._coerce_bool_expr(
+                    rest_cpp[index - 1], arg
+                )
 
         receiver_root = receiver_node
         while isinstance(receiver_root, MemberAccess):
@@ -398,6 +560,11 @@ class CallVisitor:
                 and receiver_spec.name not in self._udt_defs
             )
         )
+        # A temporary receiver is evaluated before the arguments in Pine. C++
+        # leaves the order of call arguments unspecified (GCC evaluates them
+        # right to left), so stage the call whenever an argument could observe
+        # the receiver's evaluation.
+        receiver_is_temporary = not isinstance(receiver_root, Identifier)
         return self._ordered_user_call_expr(
             fn_cpp,
             [receiver_node, *rest_nodes],
@@ -406,10 +573,17 @@ class CallVisitor:
                 receiver_node,
                 *binding.evaluation_order,
             ],
-            force_stage=(
+            force_stage=(receiver_is_temporary and (
                 receiver_passes_by_reference
-                and not isinstance(receiver_root, Identifier)
-            ),
+                or any(
+                    not isinstance(arg, (
+                        NumberLiteral, StringLiteral, BoolLiteral, NaLiteral,
+                        ColorLiteral,
+                    ))
+                    for arg in rest_nodes
+                )
+            )) or self._binds_fresh_array_to_reference(
+                method_info, rest_nodes, first_param=1),
         )
 
     def _callable_target_callsite_idx(self, fi, node: FuncCall) -> int | None:
@@ -443,7 +617,8 @@ class CallVisitor:
             + ">(_pf_series_raw); }())"
         )
 
-    def _array_init_value_expr(self, elem_spec: TypeSpec | None, value_node) -> str:
+    def _array_init_value_expr(self, elem_spec: TypeSpec | None, value_node,
+                               store: bool = True) -> str:
         if isinstance(value_node, NaLiteral):
             if elem_spec is not None and elem_spec.kind == "udt":
                 return self._default_for_spec(elem_spec)
@@ -451,7 +626,28 @@ class CallVisitor:
             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)
+        rendered = self._visit_expr(value_node)
+        if (elem_spec is not None and elem_spec.kind == "primitive"
+                and elem_spec.name == "bool"):
+            return self._coerce_bool_expr(rendered, value_node)
+        if (store and elem_spec is not None and elem_spec.kind == "primitive"
+                and elem_spec.name == "int"
+                and (self._holds_wide_int_constant(value_node)
+                     or self._expr_returns_wide_int(value_node, None, set(), None))):
+            # A 64-bit value stored in a 32-bit element (an int array only an
+            # epoch widens, ``_wide_int_array_names``; a matrix<int>): the
+            # crossing keeps na (quirk 9), and a braced initializer does not
+            # narrow implicitly.
+            return na_preserving_int_cast(rendered, "int")
+        if (store and elem_spec is not None and elem_spec.kind == "primitive"
+                and elem_spec.name == "int64"
+                and self._holds_na_aware_wide_double(value_node)
+                and self._emitted_value_is_double(value_node)):
+            # A 64-bit product over an operand that can be na is a double
+            # (``_wide_int_arith_cpp``): an epoch array's element narrows it
+            # na-preserving too.
+            return na_preserving_int_cast(rendered, "int64_t")
+        return rendered
 
     def _array_method_args(
         self, method: str, arg_nodes: list, spec: TypeSpec | None,
@@ -474,8 +670,14 @@ class CallVisitor:
             "binary_search_leftmost": {0},
             "binary_search_rightmost": {0},
         }.get(method, set())
+        stores = method in ("set", "push", "unshift", "insert", "fill")
+        if stores:
+            for idx in value_arg_indexes:
+                if idx < len(arg_nodes):
+                    self._warn_narrow_int_element(arg_nodes[idx], spec,
+                                                  arg_nodes[idx])
         return [
-            self._array_init_value_expr(elem_spec, arg)
+            self._array_init_value_expr(elem_spec, arg, stores)
             if idx in value_arg_indexes
             else self._visit_expr(arg)
             for idx, arg in enumerate(arg_nodes)
@@ -488,6 +690,39 @@ class CallVisitor:
             return list(node.args)
         return _merge_kwargs(node.args, node.kwargs, param_names, lambda arg: arg)
 
+    def _matrix_bool_value_args(
+        self, method: str, args: list[str], arg_nodes: list,
+        spec: TypeSpec | None,
+    ) -> list[str]:
+        """Apply Pine truthiness to values stored in ``matrix<bool>``."""
+        value_at = {"set": 2, "fill": 0}.get(method)
+        if value_at is not None and value_at < len(arg_nodes):
+            self._warn_narrow_int_element(arg_nodes[value_at], spec,
+                                          arg_nodes[value_at])
+            if (spec is not None and spec.kind == "matrix"
+                    and spec.element is not None
+                    and spec.element.kind == "primitive"
+                    and spec.element.name == "int"
+                    and value_at < len(args)
+                    and (self._holds_wide_int_constant(arg_nodes[value_at])
+                         or self._expr_returns_wide_int(
+                             arg_nodes[value_at], None, set(), None))):
+                # A 64-bit value (a double where an operand can be na,
+                # ``_wide_int_arith_cpp``) narrows na-preserving into the int
+                # element (quirk 9), as an int array's element does.
+                args[value_at] = na_preserving_int_cast(args[value_at], "int")
+        if (spec is None or spec.kind != "matrix"
+                or spec.element is None
+                or spec.element.kind != "primitive"
+                or spec.element.name != "bool"):
+            return args
+        value_index = {"set": 2, "fill": 0}.get(method)
+        if value_index is not None and value_index < len(args):
+            args[value_index] = self._coerce_bool_expr(
+                args[value_index], arg_nodes[value_index]
+            )
+        return args
+
     def _array_function_arg_nodes(self, method: str, node: FuncCall) -> list:
         """Merge ``array.method(id=..., ...)`` arguments in signature order."""
         if method == "copy":
@@ -672,8 +907,53 @@ class CallVisitor:
                 hint=f"Use the established positional form: {signature}.",
             )
 
+        if method == "put":
+            receiver = (bound[0] if functional
+                        else getattr(node.callee, "object", None))
+            self._warn_narrow_int_element(
+                node, self._type_spec_from_expr(receiver) if receiver is not None
+                else None, bound[-1])
         return bound
 
+    def _warn_narrow_int_element(self, node, spec, value_node) -> None:
+        """Warn once where a ``map<..., int>`` value, a ``matrix<int>``
+        element or an ``array<int>`` element (of an array no epoch widens,
+        ``_wide_int_array_names``) receives a value that can leave int32 (a
+        constant past it, ``_holds_wide_int_constant``, or a 64-bit value,
+        ``_expr_returns_wide_int``): the handle stores a C++ ``int``, where
+        TradingView's ``int`` is 64-bit. The element type also types the
+        handle's parameters and its ``values()`` / ``keys()`` / ``row()`` /
+        ``col()`` arrays (an array's, the declared ``array<int>`` parameters
+        and fields it is passed to), so it keeps the width it compiles
+        with."""
+        if spec is None or value_node is None:
+            return
+        element = (spec.value if spec.kind == "map"
+                   else spec.element if spec.kind in ("matrix", "array")
+                   else None)
+        if (element is None or element.kind != "primitive"
+                or element.name != "int"):
+            return
+        if not (self._holds_wide_int_constant(value_node)
+                or self._expr_returns_wide_int(value_node, None, set(), None)):
+            return
+        warned = getattr(self, "_narrow_int_element_warned", None)
+        if warned is None:
+            warned = self._narrow_int_element_warned = set()
+        if id(node) in warned:
+            return
+        warned.add(id(node))
+        kind = {"map": "map<..., int> value", "matrix": "matrix<int> element",
+                "array": "array<int> element"}[spec.kind]
+        self._codegen_warning(
+            node,
+            f"{'An' if spec.kind == 'array' else 'A'} {kind} is stored as a "
+            "32-bit int in PineForge; this value can "
+            "exceed int32, where TradingView's int is 64-bit, and is truncated "
+            "(or read as na) there.",
+            hint="Declare the values float to keep every digit.",
+        )
+
     def _map_param_method_expr(
         self, map_expr: str, method: str, arg_nodes: list, spec: TypeSpec,
     ) -> str:
@@ -686,6 +966,15 @@ class CallVisitor:
         extending temporary receiver lifetime through the operation.
         """
         args = [self._visit_expr(arg) for arg in arg_nodes]
+        if (method == "put" and arg_nodes and spec is not None
+                and spec.kind == "map" and spec.value is not None
+                and spec.value.kind == "primitive" and spec.value.name == "int"
+                and (self._holds_wide_int_constant(arg_nodes[-1])
+                     or self._expr_returns_wide_int(arg_nodes[-1], None, set(), None))):
+            # A 64-bit value (a double where an operand can be na,
+            # ``_wide_int_arith_cpp``) narrows na-preserving into the int
+            # value (quirk 9), as an int array's element does.
+            args[-1] = na_preserving_int_cast(args[-1], "int")
         occupied = "\n".join((map_expr, *args))
         counter = getattr(self, "_map_param_arg_counter", 0)
         bindings: list[tuple[str, str]] = []
@@ -901,6 +1190,122 @@ class CallVisitor:
         result.update(self._func_collection_types.get(func_info.name, {}))
         return result
 
+    # Builtins that return an array no variable holds: ``matrix.row(m, i)``
+    # is a copy of the row, ``array.copy(a)`` of the array.
+    _FRESH_ARRAY_CALLS = frozenset({
+        ("array", "from"), ("array", "copy"), ("array", "sort_indices"),
+        ("array", "abs"), ("array", "standardize"), ("matrix", "row"),
+        ("matrix", "col"), ("matrix", "eigenvalues"), ("str", "split"),
+        ("map", "keys"), ("map", "values"),
+    })
+    _FRESH_ARRAY_METHODS = {
+        "array": frozenset({"copy", "sort_indices", "abs", "standardize"}),
+        "matrix": frozenset({"row", "col", "eigenvalues"}),
+        "map": frozenset({"keys", "values"}),
+    }
+
+    def _array_arg_kind(self, node, depth: int = 0) -> str:
+        """``"fresh"`` for an argument that is an array no variable holds (a
+        new or copied array, a matrix row, a user function's new array),
+        ``"alias"`` for a user function's array that a variable may hold (it
+        returns its argument or a global) or a selection of a held and a
+        fresh array, and ``"keep"`` for every other argument, which keeps the
+        lowering it had: a variable, a field, ``na``, any other built-in."""
+        if isinstance(node, Ternary):
+            kinds = {self._array_arg_kind(node.true_val, depth),
+                     self._array_arg_kind(node.false_val, depth)}
+            if "alias" in kinds or len(kinds) > 1:
+                # A C++ conditional of a held and a fresh array copies the
+                # held one; TradingView passes that array itself.
+                return "alias"
+            return kinds.pop()
+        if not isinstance(node, FuncCall) or depth > 8:
+            return "keep"
+        callee = node.callee
+        if isinstance(callee, MemberAccess) and isinstance(callee.object, Identifier):
+            key = (callee.object.name, callee.member)
+            if key in self._FRESH_ARRAY_CALLS or (
+                    key[0] == "array" and key[1].startswith("new")):
+                return "fresh"
+        info = None
+        if isinstance(callee, Identifier):
+            info = self._func_info_map.get(callee.name)
+        elif isinstance(callee, MemberAccess):
+            spec = self._type_spec_from_expr(callee.object)
+            fresh = self._FRESH_ARRAY_METHODS.get(spec.kind if spec is not None else "")
+            if fresh is not None:
+                return "fresh" if callee.member in fresh else "keep"
+            receiver = method_receiver_type_name(spec) if spec is not None else None
+            info = self._func_info_map.get(f"{receiver}.{callee.member}") if receiver else None
+        if info is None:
+            return "keep"
+        return self._returned_array_kind(info, depth + 1)
+
+    def _returned_array_kind(self, func_info, depth: int) -> str:
+        """``"fresh"`` when a user function returns an array it creates: its
+        value is a fresh array, or a local declared as one and never
+        reassigned; ``"alias"`` otherwise (a user function's array reaches
+        its caller as a C++ temporary, which no ``T&`` took)."""
+        fdef = getattr(func_info, "node", None)
+        body = list(getattr(fdef, "body", None) or ())
+        if not body:
+            return "alias"
+        last = body[-1]
+        value = (last.expr if isinstance(last, ExprStmt)
+                 else last.value if isinstance(last, VarDecl) else None)
+        if isinstance(value, Identifier):
+            decls = [s for s in body if isinstance(s, VarDecl) and s.name == value.name]
+            reassigned = any(
+                isinstance(n, Assignment) and isinstance(n.target, Identifier)
+                and n.target.name == value.name
+                for stmt in body for n, _depth in iter_ast_nodes(stmt))
+            if (len(decls) != 1 or reassigned
+                    or value.name in (getattr(fdef, "params", None) or ())):
+                return "alias"
+            value = decls[0].value
+        if not isinstance(value, (FuncCall, Ternary)):
+            return "alias"
+        return "fresh" if self._array_arg_kind(value, depth) == "fresh" else "alias"
+
+    def _binds_fresh_array_to_reference(self, func_info, arg_nodes: list,
+                                        first_param: int = 0) -> bool:
+        """Whether a call passes a fresh array to a parameter its callee takes
+        as ``std::vector<T>&``. Pine arrays are references: a callee's
+        changes to a variable's array reach the caller, so the parameter stays
+        a reference. A fresh array is a C++ temporary, which binds to no
+        ``T&``; staging the call (``_ordered_user_call_expr``) binds it to a
+        named forwarding reference, and the callee's changes vanish with it,
+        as TradingView's do. An array a variable may hold that reaches the
+        call as a temporary (a function returning the array it was given) is
+        refused: PineForge would pass a copy of it, and it never compiled."""
+        if func_info is None:
+            return False
+        specs = list(getattr(func_info, "param_type_specs", ()) or ())
+        params = (list(func_info.node.params)
+                  if getattr(func_info, "node", None) is not None else [])
+        series = self.ctx.func_series_vars.get(func_info.name, set())
+        stage = False
+        for offset, arg in enumerate(arg_nodes):
+            index = first_param + offset
+            spec = specs[index] if index < len(specs) else None
+            if (arg is None or spec is None or spec.kind != "array"
+                    or (index < len(params) and params[index] in series)):
+                continue
+            kind = self._array_arg_kind(arg)
+            if kind == "alias":
+                param = params[index] if index < len(params) else f"#{index + 1}"
+                self._codegen_error(
+                    arg,
+                    f"an array a call returns is passed to parameter '{param}' of "
+                    f"'{func_info.name}', which takes the array itself: PineForge "
+                    "would pass a copy of it",
+                    hint="TradingView passes the array a function returns as itself, so "
+                         "the callee's changes to it reach every variable holding it; "
+                         "pass a variable holding the array instead.",
+                )
+            stage = stage or kind == "fresh"
+        return stage
+
     def _ordered_user_call_expr(
         self,
         call_head: str,
@@ -987,7 +1392,17 @@ class CallVisitor:
             )
         method_series = self.ctx.func_series_vars.get(func_info.name, set())
         if param_name not in method_series:
-            return self._visit_expr(arg_node)
+            cpp = self._visit_expr(arg_node)
+            int_cpp = self._func_param_int_cpp_type(
+                func_info, param_index,
+                self._callable_target_callsite_idx(func_info, call_node))
+            if (int_cpp is not None
+                    and self._holds_na_aware_wide_double(arg_node)
+                    and self._emitted_value_is_double(arg_node)):
+                # A double-valued 64-bit product (``_wide_int_arith_cpp``)
+                # narrows na-preserving into an integer parameter (quirk 9).
+                cpp = na_preserving_int_cast(cpp, int_cpp)
+            return cpp
         expected_cpp_type = self._series_param_element_cpp_type(
             func_info,
             param_index,
@@ -1010,8 +1425,7 @@ class CallVisitor:
                     == expected_cpp_type
             ):
                 return safe
-            if self._active_var_remap and safe in self._active_var_remap:
-                safe = self._active_var_remap[safe]
+            safe = self._call_site_var_name(arg_node, safe)
             if (
                 not is_current_series_param
                 and self._binding_is_series(arg_name, safe)
@@ -1133,7 +1547,9 @@ class CallVisitor:
                         # function-return receiver is a C++ rvalue; bind it to a
                         # named forwarding-reference lambda parameter first so
                         # the method sees a valid lvalue for the full call.
-                        force_stage=stage_receiver,
+                        force_stage=stage_receiver
+                        or self._binds_fresh_array_to_reference(
+                            fi_u, rest_nodes, first_param=1),
                     )
 
         # Drawing method dispatch (spec §4.3 / L.1). A KNOWN drawing method on a
@@ -1166,7 +1582,7 @@ class CallVisitor:
                 recv = self._visit_expr(callee.object)
                 arg_nodes = self._array_method_arg_nodes(callee.member, node)
                 args = self._array_method_args(callee.member, arg_nodes, recv_spec)
-                return self._array_method_expr(recv, callee.member, args, recv_spec)
+                return self._array_method_expr(recv, callee.member, args, recv_spec, node)
 
         # chart.point.now/new/from_index/from_time/copy — REAL data (a ChartPoint
         # aggregate). Routed here BEFORE the obj.field.method receiver logic,
@@ -1222,7 +1638,7 @@ class CallVisitor:
                             recv,
                             meth,
                             self._array_method_args(meth, arg_nodes, recv_spec),
-                            recv_spec,
+                            recv_spec, node,
                         )
                     args = ", ".join(raw_args)
                     if meth == "delete":
@@ -1270,7 +1686,7 @@ class CallVisitor:
                             meth_raw, arg_nodes, param_spec
                         )
                         return self._array_method_expr(
-                            arr, meth_raw, margs, param_spec
+                            arr, meth_raw, margs, param_spec, node
                         )
                     if (
                         param_spec is not None
@@ -1318,7 +1734,7 @@ class CallVisitor:
                         margs = self._array_method_args(
                             meth_raw, arg_nodes, recv_spec
                         )
-                        return self._array_method_expr(arr, meth_raw, margs, recv_spec)
+                        return self._array_method_expr(arr, meth_raw, margs, recv_spec, node)
                     if (
                         recv_spec is not None
                         and recv_spec.kind == "matrix"
@@ -1327,12 +1743,16 @@ class CallVisitor:
                         arr = self._collection_receiver_expr(oname)
                         self._check_matrix_method_allowed(meth_raw, recv_spec, node)
                         param_names = MATRIX_METHOD_KWARGS.get(meth_raw)
-                        if param_names and node.kwargs:
-                            margs = _merge_kwargs(
-                                node.args, node.kwargs, param_names, self._visit_expr
-                            )
-                        else:
-                            margs = [self._visit_expr(a) for a in node.args]
+                        raw_args = (
+                            _merge_kwargs(node.args, node.kwargs, param_names, lambda a: a)
+                            if param_names and node.kwargs else list(node.args)
+                        )
+                        margs = self._matrix_bool_value_args(
+                            meth_raw,
+                            [self._visit_expr(a) for a in raw_args],
+                            raw_args,
+                            recv_spec,
+                        )
                         fn = MATRIX_METHODS[meth_raw]
                         try:
                             return fn(arr, margs)
@@ -1370,6 +1790,8 @@ class CallVisitor:
                                     obj,
                                     *binding.evaluation_order,
                                 ],
+                                force_stage=self._binds_fresh_array_to_reference(
+                                    fi_u, rest_nodes, first_param=1),
                             )
                     args = ", ".join(self._visit_expr(a) for a in node.args)
                     recv = self._visit_expr(obj)
@@ -1380,8 +1802,27 @@ class CallVisitor:
 
         func_name, namespace = self._resolve_callee(callee)
 
-        # na(x) -> is_na(x)
+        if (func_name in ("na", "nz", "fixnan") and namespace is None
+                and self._pine_v5_body and node.args):
+            self._refuse_v5_bool_na_observer(node, f"{func_name}()", node.args[:1])
+
+        # na(x) -> is_na(x); a drawing asks its arena (codegen/drawing.py).
         if func_name == "na" and namespace is None:
+            if (len(node.args) == 1 and not node.kwargs
+                    and self._infer_type(node.args[0]) == "std::string"):
+                # A string na is stored as the empty string (the engine's
+                # ``na<std::string>()``), which has no ``is_na`` overload.
+                self._codegen_warning(
+                    node,
+                    "na() of a string reads the empty string as na: PineForge "
+                    "stores a string na as \"\", so an authored empty string "
+                    "is na here, while TradingView tells the two apart.",
+                )
+                return f"({self._visit_expr(node.args[0])}).empty()"
+            if len(node.args) == 1:
+                drawing = self._drawing_na_expr(node.args[0])
+                if drawing is not None:
+                    return drawing
             args = ", ".join(self._visit_expr(a) for a in node.args)
             return f"is_na({args})"
 
@@ -1398,10 +1839,17 @@ class CallVisitor:
         # 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.
+        # Pine evaluates the replacement y on every call too, na source or
+        # not, so a y that is more than a plain read is bound as well: in the
+        # ternary it ran only on the bars whose x was na, and a stateful call
+        # in it skipped every other bar.
         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"([&]{{ auto _nz_v = ({x}); return is_na(_nz_v) ? ({y}) : _nz_v; }}())"
+            if cpp_is_plain_read(y):
+                return f"([&]{{ auto _nz_v = ({x}); return is_na(_nz_v) ? ({y}) : _nz_v; }}())"
+            return (f"([&]{{ auto _nz_v = ({x}); auto _nz_y = ({y}); "
+                    f"return is_na(_nz_v) ? _nz_y : _nz_v; }}())")
 
         # fixnan(x) -> persistent state
         if func_name == "fixnan" and namespace is None:
@@ -1525,10 +1973,16 @@ class CallVisitor:
             arr = self._collection_receiver_expr(namespace)
             self._check_matrix_method_allowed(func_name, namespace_spec, node)
             param_names = MATRIX_METHOD_KWARGS.get(func_name)
-            if param_names and node.kwargs:
-                args = _merge_kwargs(node.args, node.kwargs, param_names, self._visit_expr)
-            else:
-                args = [self._visit_expr(a) for a in node.args]
+            raw_args = (
+                _merge_kwargs(node.args, node.kwargs, param_names, lambda a: a)
+                if param_names and node.kwargs else list(node.args)
+            )
+            args = self._matrix_bool_value_args(
+                func_name,
+                [self._visit_expr(a) for a in raw_args],
+                raw_args,
+                namespace_spec,
+            )
             fn = MATRIX_METHODS[func_name]
             try:
                 return fn(arr, args)
@@ -1549,18 +2003,26 @@ class CallVisitor:
             spec = namespace_spec
             arg_nodes = self._array_method_arg_nodes(func_name, node)
             args = self._array_method_args(func_name, arg_nodes, spec)
-            return self._array_method_expr(arr, func_name, args, spec)
+            return self._array_method_expr(arr, func_name, args, spec, node)
 
         # Array operations — emit proper C++ vector operations
         if namespace == "array":
             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"))
+                # The constructor of a wide int array (``_wide_int_array_names``)
+                # must spell the declared ``std::vector<int64_t>``: the
+                # declaration site names its target here.
+                target = getattr(self, "_array_ctor_target_name", None)
+                if target is not None:
+                    spec = self._widen_array_spec_for_name(target, spec)
                 cpp_type = self._type_spec_to_cpp(spec)
                 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])
                     if len(node.args) > 1:
+                        self._warn_narrow_int_element(node.args[1], spec,
+                                                      node.args[1])
                         init_val = self._array_init_value_expr(elem_spec, node.args[1])
                     else:
                         init_val = init_default
@@ -1568,7 +2030,28 @@ class CallVisitor:
                 return f"{cpp_type}()"
             if func_name == "from":
                 spec = self._type_spec_from_expr(node) or TypeSpec.array(TypeSpec.primitive("float"))
-                elems = ", ".join(self._visit_expr(a) for a in node.args)
+                target = getattr(self, "_array_ctor_target_name", None)
+                if target is not None:
+                    # The declaration's own element type wins over the
+                    # argument inference, which cannot see every scalar's
+                    # family (a ``color`` variable reads as float there):
+                    # ``color[] cs = array.from(c1, c2)`` declares
+                    # ``std::vector<int64_t>`` and must construct one.
+                    declared = self._collection_spec_for_name(target)
+                    if (declared is not None and declared.kind == "array"
+                            and declared.element is not None
+                            and declared.element.kind == "primitive"
+                            and spec.kind == "array"
+                            and declared.element != spec.element):
+                        spec = declared
+                    spec = self._widen_array_spec_for_name(target, spec)
+                elem_spec = spec.element
+                for a in node.args:
+                    self._warn_narrow_int_element(a, spec, a)
+                elems = ", ".join(
+                    self._array_init_value_expr(elem_spec, a)
+                    for a in node.args
+                )
                 return f"{self._type_spec_to_cpp(spec)}{{{elems}}}"
             # Method calls: array.method(arr, args...)
             if func_name in ARRAY_METHODS and (
@@ -1580,7 +2063,7 @@ class CallVisitor:
                 arr = self._visit_expr(all_nodes[0])
                 spec = self._type_spec_from_expr(all_nodes[0])
                 rest = self._array_method_args(func_name, all_nodes[1:], spec)
-                return self._array_method_expr(arr, func_name, rest, spec)
+                return self._array_method_expr(arr, func_name, rest, spec, node)
             return "0"
 
         # color.* calls
@@ -1690,21 +2173,26 @@ class CallVisitor:
                     if item["expr_node"] is ltf_expr_node:
                         return f"_req_sec_lower_tf_{item['sec_id']}"
                 return "std::vector<double>{}"
+            # request.earnings / dividends / splits / financial reading the
+            # series recorded under their key (external_requests).
+            if RECORDED_KEY_ANNOTATION in (node.annotations or {}):
+                return (f"_pf_recorded({self._recorded_key_expr(node)}, "
+                        f"_pf_rec_missing_{self._recorded_site(node)})")
             # All other request.* functions
             return "na<double>()"
 
         # ticker.* calls
         if namespace == "ticker":
-            # ticker.inherit(symbol, ...) / ticker.standard(symbol) — passthrough,
-            # and ticker.heikinashi(symbol) — same-symbol HA: emit the symbol
+            # ticker.inherit(from_tickerid, symbol) / ticker.standard(symbol) —
+            # passthrough of the symbol (inherit names it second), 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:
-                    return self._visit_expr(node.kwargs["symbol"])
+                symbol = ticker_symbol_arg(node)
+                if symbol is not None:
+                    return self._visit_expr(symbol)
             # All other ticker.* calls are hard-rejected by support_checker;
             # emit empty string as safe fallback if they somehow reach codegen.
             return 'std::string("")'
@@ -1757,8 +2245,11 @@ class CallVisitor:
             and (node.args or node.kwargs)
         ):
             params = sigs.get_param_names(None, func_name)
-            args = _merge_kwargs(node.args, node.kwargs, params, self._visit_expr)
+            arg_nodes = _merge_kwargs(node.args, node.kwargs, params, lambda a: a)
+            args = [self._visit_expr(a) for a in arg_nodes]
+            ts_node = arg_nodes[0] if arg_nodes else None
             ts_arg = args[0] if args else "current_bar_.timestamp"
+            ts_arg = self._coerce_int_slot(ts_arg, ts_node, "int64_t")
             tz_arg = args[1] if len(args) > 1 else None
             field_expr = TIME_FIELD_EXPRS[func_name]
             if tz_arg is None:
@@ -1776,7 +2267,22 @@ class CallVisitor:
             # 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})"
+            if func_name == "weekofyear":
+                # A covered TradingView tape reports week 1 for an na
+                # timestamp in both UTC and America/New_York; the engine's
+                # epoch-zero week helper returns 0 / 52 respectively.
+                return (
+                    f"([&](){{ int64_t _pf_calendar_ts = ({ts_arg}); "
+                    f"auto _pf_calendar_tz = ({tz_arg}); "
+                    f"if (is_na(_pf_calendar_ts)) return 1; "
+                    f"return pine_weekofyear(_pf_calendar_ts, "
+                    f"_pf_calendar_tz); }}())"
+                )
+            return (
+                f"([&](){{ int64_t _pf_calendar_ts = ({ts_arg}); "
+                f"return pine_{func_name}(is_na(_pf_calendar_ts) ? "
+                f"int64_t(0) : _pf_calendar_ts, {tz_arg}); }}())"
+            )
 
         # time(timeframe) or time(timeframe, session[, tz])
         #
@@ -1805,6 +2311,12 @@ class CallVisitor:
         # to nothing against the base engine (legacy 5-arg call), so the same
         # generated.cpp builds in every lab-experiment cell.
         #
+        if (func_name in ("time", "time_close") and namespace is None
+                and (node.args or node.kwargs)):
+            lowered = self._time_offset_call(func_name, node)
+            if lowered is not None:
+                return lowered
+            node = self._check_time_bars_back(func_name, node)
         if func_name == "time" and namespace is None and (node.args or node.kwargs):
             args = _merge_kwargs(node.args, node.kwargs, sigs.get_param_names(None, "time"), self._visit_expr)
             tf_e = args[0] if len(args) > 0 else 'script_tf_'
@@ -1877,13 +2389,18 @@ class CallVisitor:
                              "month, day[, hour, minute, second]).",
                     )
                 args = [self._visit_expr(a) for a in node.args]
+                # Every calendar field lands in an ``int`` inside the lambda.
+                fields = [
+                    self._coerce_int_slot(a, node.args[i], "int")
+                    for i, a in enumerate(args)
+                ]
                 tz = args[0]
-                yr = args[1] if len(args) > 1 else "1970"
-                mo = args[2] if len(args) > 2 else "1"
-                dy = args[3] if len(args) > 3 else "1"
-                hr = args[4] if len(args) > 4 else "0"
-                mn = args[5] if len(args) > 5 else "0"
-                sc = args[6] if len(args) > 6 else "0"
+                yr = fields[1] if len(fields) > 1 else "1970"
+                mo = fields[2] if len(fields) > 2 else "1"
+                dy = fields[3] if len(fields) > 3 else "1"
+                hr = fields[4] if len(fields) > 4 else "0"
+                mn = fields[5] if len(fields) > 5 else "0"
+                sc = fields[6] if len(fields) > 6 else "0"
                 return _timestamp_calendar_lambda(tz, yr, mo, dy, hr, mn, sc)
             else:
                 # Numeric form requires year, month, and day (hour/minute/
@@ -1902,7 +2419,10 @@ class CallVisitor:
                              "[, hour, minute, second]); the dateString "
                              "overload is not supported in PineForge.",
                     )
-                args = [self._visit_expr(a) for a in merged]
+                args = [
+                    self._coerce_int_slot(self._visit_expr(a), a, "int")
+                    for a in merged
+                ]
                 yr = args[0]
                 mo = args[1] if len(args) > 1 else "1"
                 dy = args[2] if len(args) > 2 else "1"
@@ -1932,37 +2452,55 @@ class CallVisitor:
         # Type cast functions: int(x), float(x), bool(x), string(x)
         if func_name == "int" and namespace is None and node.args:
             # Pine int(na) → na (int form). Evaluate once, propagate na via
-            # the engine's int sentinel instead of collapsing NaN to 0.
+            # the engine's int sentinel instead of collapsing NaN to 0. Pine
+            # int is 64-bit: int(time) keeps the epoch, so a wide argument
+            # (``_wide_int_provenance``) casts to int64_t.
             x = self._visit_expr(node.args[0])
-            return (f"[&](){{ double _pf_v = (double)({x}); "
-                    f"return is_na(_pf_v) ? na<int>() : (int)_pf_v; }}()")
+            owner = self._func_info_map.get(
+                getattr(self, "_active_func_name", "") or "")
+            if self._expr_returns_wide_int(
+                    node.args[0], owner, set(),
+                    getattr(self, "_active_call_site_idx", None)):
+                return na_preserving_int_cast(x, "int64_t")
+            return na_preserving_int_cast(x)
         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:
             # 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; }} }}()"
-            )
+            return pine_truth_cast(x)
         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
             # (std::to_string would reject strings / render bools as 0/1).
             arg = node.args[0]
+            if self._is_na_expr(arg):
+                # ``string(na)`` types an ``na`` as a string (``[string(na),
+                # string(na)]`` arms of a tuple): the string na, not
+                # ``str.tostring(na)`` ("NaN"), whose formatter a script
+                # without str.tostring does not declare.
+                return "na<std::string>()"
             inferred = self._infer_type(arg)
             if inferred == "std::string":
                 return self._visit_expr(arg)
             if inferred == "bool":
+                if self._pine_v5_body:
+                    self._refuse_v5_bool_na_observer(node, "string()", [arg])
                 visited = self._visit_expr(arg)
                 return f'(({visited}) ? std::string("true") : std::string("false"))'
             return self._visit_str_call("tostring", node)
 
         # ta.pivot_point_levels — free function, not a stateful indicator
         if namespace == "ta" and func_name == "pivot_point_levels":
+            routed_site = self._get_ta_site(node)
+            if routed_site is not None:
+                compute_args = self._ta_compute_args_for_site(routed_site)
+                ta_mem = self._ta_member_name(routed_site)
+                return (
+                    f"(history_advances_new_bar() ? {ta_mem}.compute({compute_args}) "
+                    f": {ta_mem}.recompute({compute_args}))"
+                )
             if node.kwargs:
                 args = _merge_kwargs(
                     node.args,
@@ -2015,7 +2553,13 @@ class CallVisitor:
                     init = args_e[2] if len(args_e) > 2 else "0.0"
                     return f"PineMatrix::new_({rows}, {cols}, {init})"
                 cpp_t = self._type_spec_to_cpp(elem_spec)
-                init = args_e[2] if len(args_e) > 2 else self._default_for_spec(elem_spec)
+                if len(node.args) > 2:
+                    self._warn_narrow_int_element(
+                        node, TypeSpec.matrix(elem_spec), node.args[2])
+                init = (
+                    self._array_init_value_expr(elem_spec, node.args[2])
+                    if len(args_e) > 2 else self._default_for_spec(elem_spec)
+                )
                 return f"PineGenericMatrix<{cpp_t}>::new_({rows}, {cols}, {init})"
             if func_name in MATRIX_METHODS and node.args:
                 from ..ast_nodes import Identifier as _Ident
@@ -2035,10 +2579,16 @@ class CallVisitor:
                             self._check_matrix_method_allowed(func_name, recv_spec, node)
                 obj = self._visit_expr(node.args[0])
                 param_names = MATRIX_METHOD_KWARGS.get(func_name)
-                if param_names:
-                    rest = _merge_kwargs(node.args[1:], node.kwargs, param_names, self._visit_expr)
-                else:
-                    rest = [self._visit_expr(a) for a in node.args[1:]]
+                raw_rest = (
+                    _merge_kwargs(node.args[1:], node.kwargs, param_names, lambda a: a)
+                    if param_names else list(node.args[1:])
+                )
+                rest = self._matrix_bool_value_args(
+                    func_name,
+                    [self._visit_expr(a) for a in raw_rest],
+                    raw_rest,
+                    self._type_spec_from_expr(node.args[0]),
+                )
                 fn = MATRIX_METHODS[func_name]
                 try:
                     return fn(obj, rest)
@@ -2050,13 +2600,21 @@ class CallVisitor:
                     )
             return "0.0"
 
-        # log.* calls (log.error, log.warning, log.info)
+        # log.* calls (log.error, log.warning, log.info). TradingView: "The
+        # second overloads of all log.*() functions have the same parameter
+        # signature and formatting behaviors as str.format()": log.info(fmt,
+        # arg0, ...) logs str.format(fmt, arg0, ...). The one-argument
+        # log.info(message) logs its message as is.
         if namespace == "log":
             log_funcs = {"info": "pine_log_info", "warning": "pine_log_warning", "error": "pine_log_error"}
             if func_name in log_funcs:
-                log_args = [self._visit_expr(a) for a in node.args]
-                msg_arg = log_args[0] if log_args else '""'
-                return f'{log_funcs[func_name]}({msg_arg})'
+                message = (node.args[0] if node.args
+                           else node.kwargs.get("message", node.kwargs.get("formatString")))
+                if message is None:
+                    return f'{log_funcs[func_name]}("")'
+                if len(node.args) > 1:
+                    return f'{log_funcs[func_name]}({self._str_format_expr(message, node.args[1:])})'
+                return f'{log_funcs[func_name]}({self._visit_expr(message)})'
             return '"" /* unsupported log */'
 
         # timeframe.* calls (e.g., timeframe.change) — not supported in single-TF backtest
@@ -2121,14 +2679,23 @@ class CallVisitor:
                         ),
                     )
                     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})"
+                        val = self._coerce_int_slot(val, value_node, "int64_t")
+                        if val == "na<double>()":
+                            val = "na<int64_t>()"
+                    elif f_cpp_type == "bool":
+                        val = self._coerce_bool_expr(val, value_node)
                     elif (self._is_nullable_collection_cpp_type(f_cpp_type)
                           and val == "na<double>()"):
                         val = f"{f_cpp_type}{{}}"
-                    field_inits.append(f".{f.name} = {val}")
+                    array_field = self._udt_array_field_cpp(
+                        field_specs.get(f.name)
+                        or self._type_spec_from_hint_name(f.type_name),
+                        namespace)
+                    if array_field is not None:
+                        val = (f"{array_field}()" if val == "na<double>()"
+                               else self._udt_array_field_value(
+                                   array_field, value_node, val))
+                    field_inits.append(f".{self._safe_name(f.name)} = {val}")
             return self._emit_udt_new_expr(namespace, field_inits)
 
         # UDT copy: TypeName.copy(obj)
@@ -2227,8 +2794,7 @@ class CallVisitor:
                             == expected_cpp_type
                     ):
                         return safe
-                    if self._active_var_remap and safe in self._active_var_remap:
-                        safe = self._active_var_remap[safe]
+                    safe = self._call_site_var_name(arg_node, safe)
                     if (
                         not is_current_series_param
                         and self._binding_is_series(aname, safe)
@@ -2284,7 +2850,20 @@ class CallVisitor:
             return self._visit_expr(arg_node)
 
         ordered_arg_nodes: list = []
-        if node.kwargs:
+        defaulted_arg_nodes = (
+            self._user_call_args_with_defaults(func_name, node)
+            if namespace is None and func_name in self._func_names
+            else None
+        )
+        if defaulted_arg_nodes is not None:
+            # Omitted parameters take their declared defaults, and keywords
+            # land on their own parameters past any omitted one.
+            ordered_arg_nodes = list(defaulted_arg_nodes)
+            all_args = [
+                _visit_arg_for_series(a, i)
+                for i, a in enumerate(defaulted_arg_nodes)
+            ]
+        elif node.kwargs:
             # Try to resolve kwargs using FuncInfo params for user-defined functions
             fi = self._func_info_map.get(func_name)
             if fi and fi.node and fi.node.params:
@@ -2325,6 +2904,16 @@ class CallVisitor:
         # 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)
+            # A double-valued argument bound to an integer parameter narrows at
+            # the call boundary, which is undefined for na.
+            self._coerce_int_param_args(
+                func_name, ordered_arg_nodes, all_args,
+                self.ctx.func_call_cs_map.get(id(node), (None, None))[1],
+            )
+            self._coerce_bool_param_args(
+                func_name, ordered_arg_nodes, all_args,
+                self.ctx.func_call_cs_map.get(id(node), (None, None))[1],
+            )
         # 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)
@@ -2368,9 +2957,41 @@ class CallVisitor:
                 ordered_arg_nodes,
                 all_args,
                 source_order_nodes=[*node.args, *node.kwargs.values()],
+                force_stage=self._binds_fresh_array_to_reference(
+                    self._func_info_map.get(func_name), ordered_arg_nodes),
             )
         return f"{call_head}({', '.join(all_args)})"
 
+    def _coerce_int_param_args(self, func_name, arg_nodes, all_args,
+                               call_site_idx) -> None:
+        """In-place narrow every argument bound to an integer parameter.
+
+        Pine ``color`` parameters are integers in the emitted signature too, so
+        a ``na`` colour argument (``na<double>()``) is a NaN crossing into an
+        ``int`` — undefined, and it defeats ``is_na`` on the other side."""
+        fi = self._func_info_map.get(func_name)
+        if not fi or not getattr(fi, "node", None) or not fi.node.params:
+            return
+        for i, arg in enumerate(arg_nodes):
+            if i >= len(all_args):
+                break
+            int_cpp = self._func_param_int_cpp_type(fi, i, call_site_idx)
+            if int_cpp is None:
+                continue
+            all_args[i] = self._coerce_int_slot(all_args[i], arg, int_cpp)
+
+    def _coerce_bool_param_args(self, func_name, arg_nodes, all_args,
+                                call_site_idx) -> None:
+        """Apply Pine's false-for-``na`` rule at bool UDF parameters."""
+        fi = self._func_info_map.get(func_name)
+        if not fi or not getattr(fi, "node", None) or not fi.node.params:
+            return
+        for i, arg in enumerate(arg_nodes):
+            if i >= len(all_args) or arg is None:
+                continue
+            if self._func_param_is_bool(fi, i, call_site_idx):
+                all_args[i] = self._coerce_bool_expr(all_args[i], arg)
+
     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 /
@@ -2427,8 +3048,15 @@ class CallVisitor:
         else:
             self._fixnan_counter += 1
             member = f"_prev_fixnan_{self._fixnan_counter}"
+        # x is evaluated exactly once, as in ``nz``: a stateful call in it
+        # (``fixnan(100 * ta.rma(plusDM, len) / tr)``, TradingView's DMI) used
+        # to run twice per bar, once for the is_na() test and once for the
+        # store, double-stepping the RMA.
         x = self._visit_expr(node.args[0])
-        return f"(is_na({x}) ? {member} : ({member} = {x}))"
+        return (
+            f"([&]{{ auto _fixnan_v = ({x}); "
+            f"return is_na(_fixnan_v) ? {member} : ({member} = _fixnan_v); }}())"
+        )
 
     @staticmethod
     def _strategy_close_callsite_token(node: FuncCall) -> str:
@@ -2461,7 +3089,13 @@ class CallVisitor:
         if func_name == "entry":
             p = self._resolve_func_args(node, "strategy.entry")
             entry_id = self._visit_expr(p.get("id")) if "id" in p else '""'
-            direction = self._visit_expr(p.get("direction")) if "direction" in p else "true"
+            direction_node = p.get("direction")
+            direction = (
+                self._coerce_bool_expr(
+                    self._visit_expr(direction_node), direction_node
+                )
+                if direction_node is not None else "true"
+            )
             stop = p.get("stop")
             limit = p.get("limit")
             qty = p.get("qty")
@@ -2492,14 +3126,26 @@ class CallVisitor:
             comment = self._visit_expr(p.get("comment")) if p.get("comment") is not None else '""'
             qty = self._visit_expr(p.get("qty")) if p.get("qty") is not None else "na<double>()"
             qty_pct = self._visit_expr(p.get("qty_percent")) if p.get("qty_percent") is not None else "na<double>()"
-            immediately = self._visit_expr(p.get("immediately")) if p.get("immediately") is not None else "false"
+            immediately_node = p.get("immediately")
+            immediately = (
+                self._coerce_bool_expr(
+                    self._visit_expr(immediately_node), immediately_node
+                )
+                if immediately_node is not None else "false"
+            )
             callsite = self._strategy_close_callsite_token(node)
             return f"strategy_close({close_id}, {comment}, {qty}, {qty_pct}, {immediately}, {callsite})"
 
         if func_name == "close_all":
             p = self._resolve_func_args(node, "strategy.close_all")
             comment = self._visit_expr(p.get("comment")) if p.get("comment") is not None else '""'
-            immediately = self._visit_expr(p.get("immediately")) if p.get("immediately") is not None else "false"
+            immediately_node = p.get("immediately")
+            immediately = (
+                self._coerce_bool_expr(
+                    self._visit_expr(immediately_node), immediately_node
+                )
+                if immediately_node is not None else "false"
+            )
             # The engine's ID-less strategy_close path closes the complete
             # position. Reuse it so close_all preserves the Pine order comment
             # and same-tick fill flag instead of silently discarding both.
@@ -2546,8 +3192,8 @@ class CallVisitor:
                 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}, {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})"
+            comment = self._visit_expr(comment_n) if comment_n is not None else '""'
+            return f"strategy_exit_cancel_bracket({exit_id}, {from_id}, {comment})"
 
         if func_name == "cancel":
             p = self._resolve_func_args(node, "strategy.close")  # same shape: id first
@@ -2560,7 +3206,13 @@ class CallVisitor:
         if func_name == "order":
             p = self._resolve_func_args(node, "strategy.order")
             order_id = self._visit_expr(p.get("id")) if "id" in p else '""'
-            direction = self._visit_expr(p.get("direction")) if "direction" in p else "true"
+            direction_node = p.get("direction")
+            direction = (
+                self._coerce_bool_expr(
+                    self._visit_expr(direction_node), direction_node
+                )
+                if direction_node is not None else "true"
+            )
             qty = self._visit_expr(p.get("qty")) if "qty" in p else "0"
             limit_arg = self._visit_expr(p.get("limit")) if "limit" in p else "na<double>()"
             stop_arg = self._visit_expr(p.get("stop")) if "stop" in p else "na<double>()"
@@ -2576,7 +3228,14 @@ class CallVisitor:
         if isinstance(node.callee, MemberAccess):
             inner = node.callee.object
             if isinstance(inner, MemberAccess) and inner.member in ("closedtrades", "opentrades"):
-                idx = self._visit_expr(node.args[0]) if node.args else "0"
+                # The engine's accessors take an ``int`` trade index; a
+                # double-valued Pine expression narrows into it.
+                idx = (
+                    self._coerce_int_slot(
+                        self._visit_expr(node.args[0]), node.args[0], "int",
+                    )
+                    if node.args else "0"
+                )
                 is_open = inner.member == "opentrades"
                 # Open trades have no exit metadata in Pine
                 if is_open and func_name in (
@@ -2625,12 +3284,100 @@ class CallVisitor:
             f"have rejected. Add a handler above or extend STRATEGY_FUNCTIONS."
         )
 
+    # TradingView's parameter order of color.from_gradient.
+    _FROM_GRADIENT_PARAMS = (
+        "value", "bottom_value", "top_value", "bottom_color", "top_color",
+    )
+    # TradingView's parameter names of the other color.* functions.
+    _COLOR_PARAMS = {
+        "new": ("color", "transp"),
+        "rgb": ("red", "green", "blue", "transp"),
+        "r": ("color",), "g": ("color",), "b": ("color",), "t": ("color",),
+    }
+
+    def _color_arg_nodes(self, func_name: str, node) -> list:
+        """The argument nodes of a ``color.*`` call in parameter order: the
+        positional ones, then each keyword in its parameter's slot, up to the
+        last one given (``color.new(transp = 40, color = c)`` is
+        ``color.new(c, 40)``). A slot nothing fills is None."""
+        params = self._COLOR_PARAMS.get(func_name, ())
+        bound = list(node.args)
+        for index, name in enumerate(params):
+            if index >= len(node.args) and name in node.kwargs:
+                bound += [None] * (index + 1 - len(bound))
+                bound[index] = node.kwargs[name]
+        return bound
+
+    # Builtins whose call has no state and no side effect.
+    _PURE_CALL_NAMESPACES = frozenset({"color", "math", "str"})
+    _PURE_CALLS = frozenset({"na", "nz", "int", "float", "bool", "string"})
+
+    def _may_have_effects(self, node) -> bool:
+        """Whether evaluating ``node`` can change anything or keep state: it
+        calls a user function, a ``ta.*`` / ``request.*`` builtin, an
+        array or map method, ... -- anything but a pure builtin."""
+        for sub in self._walk_ast(node):
+            if isinstance(sub, FuncCall):
+                func_name, namespace = self._resolve_callee(sub.callee)
+                if namespace in self._PURE_CALL_NAMESPACES:
+                    continue
+                if namespace is None and func_name in self._PURE_CALLS \
+                        and func_name not in self._func_names:
+                    continue
+                return True
+        return False
+
     def _visit_color_call(self, func_name: str, node) -> str:
         """Emit color.* calls as integer representations."""
-        args = [self._visit_expr(a) for a in node.args]
+        if func_name == "from_gradient":
+            # Visual only: the colour it picks reaches no order, so the call
+            # yields the na colour. Its arguments still run once each, in
+            # parameter order, as on TradingView -- a stateful call in one
+            # (a user function keeping a series, a ta.* compute(), a counter)
+            # advances on every bar (lab tv probe pf-oi-from-gradient-args).
+            arguments = _merge_kwargs(node.args, node.kwargs,
+                                      list(self._FROM_GRADIENT_PARAMS), lambda a: a)
+            effects = []
+            for argument in arguments:
+                cpp = self._visit_expr(argument)
+                if self._may_have_effects(argument) and not cpp_is_plain_read(cpp):
+                    effects.append(cpp)
+            if not effects:
+                return "0"
+            return ("([&]() -> int64_t { "
+                    + " ".join(f"(void)({cpp});" for cpp in effects)
+                    + " return 0; }())")
+        # Keyword arguments take their parameter's slot; TradingView evaluates
+        # the arguments in parameter order, as the lowerings below do.
+        arg_nodes = self._color_arg_nodes(func_name, node)
+        if any(a is None for a in arg_nodes):
+            return "0"
+        args = [self._visit_expr(a) for a in arg_nodes]
         if func_name == "new":
             if len(args) >= 2:
-                return f'pine_color::new_color({args[0]}, (int)({args[1]}))'
+                base = self._coerce_int_slot(
+                    args[0], arg_nodes[0], "int64_t",
+                )
+                whole = _whole_transparency(arg_nodes[1])
+                alpha = color_alpha_cast(args[1], whole)
+                base_node = arg_nodes[0]
+                if (isinstance(base_node, ColorLiteral)
+                        or (isinstance(base_node, MemberAccess)
+                            and isinstance(base_node.object, Identifier)
+                            and base_node.object.name == "color")):
+                    # A literal color is never na; preserve the compact
+                    # historical spelling (including input.color defaults).
+                    return f"pine_color::new_color({base}, {alpha})"
+                # A color variable or ``na`` may carry the integer sentinel.
+                # Evaluate both authored arguments once, then preserve that
+                # sentinel instead of letting new_color mask it into a value.
+                return (
+                    f"[&]() -> int64_t {{ auto _pf_color_base = ({base}); "
+                    f"auto _pf_color_alpha = ({args[1]}); "
+                    f"if (is_na(_pf_color_base)) return na<int64_t>(); "
+                    f"return pine_color::new_color(_pf_color_base, "
+                    f"{color_alpha_cast('_pf_color_alpha', whole)}); }}()"
+                )
             return "0"
         if func_name in ("r", "g", "b", "t"):
             if args:
@@ -2638,17 +3385,72 @@ class CallVisitor:
             return "0"
         if func_name == "rgb":
             if len(args) >= 4:
-                return f"pine_color::new_color(((int64_t)({args[0]}) << 16 | (int64_t)({args[1]}) << 8 | (int64_t)({args[2]})), (int)({args[3]}))"
+                channels = [
+                    self._coerce_int_slot(args[i], arg_nodes[i], "int64_t")
+                    for i in range(3)
+                ]
+                alpha = color_alpha_cast(args[3], _whole_transparency(arg_nodes[3]))
+                return (
+                    "pine_color::new_color(static_cast<int64_t>("
+                    f"(static_cast<uint64_t>({channels[0]}) & 0xFFULL) << 16 | "
+                    f"(static_cast<uint64_t>({channels[1]}) & 0xFFULL) << 8 | "
+                    f"(static_cast<uint64_t>({channels[2]}) & 0xFFULL)), {alpha})"
+                )
             elif len(args) >= 3:
-                return f"pine_color::new_color(((int64_t)({args[0]}) << 16 | (int64_t)({args[1]}) << 8 | (int64_t)({args[2]})), 0)"
-            return "0"
-        if func_name == "from_gradient":
+                channels = [
+                    self._coerce_int_slot(args[i], arg_nodes[i], "int64_t")
+                    for i in range(3)
+                ]
+                return (
+                    "pine_color::new_color(static_cast<int64_t>("
+                    f"(static_cast<uint64_t>({channels[0]}) & 0xFFULL) << 16 | "
+                    f"(static_cast<uint64_t>({channels[1]}) & 0xFFULL) << 8 | "
+                    f"(static_cast<uint64_t>({channels[2]}) & 0xFFULL)), 0)"
+                )
             return "0"
         return "0"
 
+    def _str_format_expr(self, fmt_node, arg_nodes) -> str:
+        """Shared TradingView MessageFormat lowering for str.format and log.*."""
+        if self._pine_v5_body:
+            self._refuse_v5_bool_na_observer(fmt_node, "str.format()", arg_nodes)
+        fmt_arg = self._visit_expr(fmt_node)
+        rest = [f"_PFTvFormatValue({self._visit_expr(orig)})" for orig in arg_nodes]
+        vec = "{" + ", ".join(rest) + "}"
+        return f'pine_str_format_tv({fmt_arg}, {vec})'
+
     def _visit_str_call(self, func_name: str, node) -> str:
         args = _merge_kwargs(node.args, node.kwargs,
                              sigs.get_param_names("str", func_name), self._visit_expr)
+        arg_nodes = _merge_kwargs(
+            node.args, node.kwargs,
+            sigs.get_param_names("str", func_name), lambda a: a,
+        )
+
+        if func_name == "repeat":
+            if len(args) < 2:
+                self._codegen_warning(
+                    node,
+                    "str.repeat is missing its count argument; PineForge "
+                    "emits an empty string for this invalid TradingView call.",
+                )
+                return 'std::string("")'
+            count_node = arg_nodes[1] if len(arg_nodes) > 1 else None
+            if (count_node is not None
+                    and not isinstance(count_node, (NumberLiteral, BoolLiteral))):
+                warned = getattr(self, "_warned_repeat_na_sites", None)
+                if warned is None:
+                    warned = self._warned_repeat_na_sites = set()
+                if id(node) not in warned:
+                    warned.add(id(node))
+                    self._codegen_warning(
+                        count_node,
+                        "str.repeat count can be na: PineForge returns an empty "
+                        "string for that value, while TradingView returns na "
+                        "string. The engine has no nullable string value.",
+                        hint="Check na(count) before calling str.repeat when "
+                             "the result affects strategy logic.",
+                    )
 
         if func_name == "tostring":
             # Pine: str.tostring(enumVar) → field title / IANA string, not the int index
@@ -2664,56 +3466,45 @@ class CallVisitor:
                         return (
                             f"pine_enum_str_at({et}_str_values, {n}, {var})"
                         )
+            inferred = self._infer_type(val_arg) if val_arg is not None else ""
+            if inferred == "std::string":
+                return args[0] if args else 'std::string("")'
+            if inferred == "bool":
+                if self._pine_v5_body:
+                    self._refuse_v5_bool_na_observer(node, "str.tostring()", [val_arg])
+                return (f'({args[0]} ? std::string("true") : '
+                        'std::string("false"))')
             if len(args) >= 2:
-                return f"pine_str_tostring({args[0]}, {args[1]}, syminfo_mintick_)"
+                return f"pine_str_tostring_tv({args[0]}, {args[1]}, syminfo_mintick_)"
             if len(args) >= 1:
-                return f"std::to_string({args[0]})"
+                return f"pine_str_tostring_tv({args[0]}, std::string(), syminfo_mintick_)"
             return 'std::string("")'
 
         if func_name == "substring":
             if len(args) == 3:
-                return f"{args[0]}.substr({args[1]}, {args[2]} - {args[1]})"
+                # begin_pos is read twice: evaluate it once.
+                return evaluate_args_once(
+                    args, (1,), lambda a: f"{a[0]}.substr({a[1]}, {a[2]} - {a[1]})",
+                    "_pf_str_a")
             elif len(args) == 2:
                 return f"{args[0]}.substr({args[1]})"
             return 'std::string("")'
 
         if func_name == "format":
-            # str.format is variadic: signature has only ``formatStr``; the
-            # remaining args are placeholder substitutions. The runtime
-            # ``pine_str_format(fmt, vector<string>)`` requires every arg
-            # already converted to ``std::string``. We previously gated the
-            # ``std::to_string`` wrap on a source-text-prefix heuristic
-            # (``"`` / ``std::string`` / ``pine_str``), which mis-classified
-            # any string-typed bare identifier or string-returning helper
-            # call (e.g. ``str.tostring(x)`` bound to a variable). The type
-            # check below uses the analyzer's inferred PineType instead so
-            # ``std::string`` args pass through unchanged.
-            if node.args:
-                fmt_arg = self._visit_expr(node.args[0])
-                rest = []
-                for orig in node.args[1:]:
-                    visited = self._visit_expr(orig)
-                    inferred = self._infer_type(orig)
-                    if inferred == "std::string":
-                        rest.append(visited)
-                        continue
-                    # Booleans render as 0/1 via std::to_string; force the
-                    # TV-style "true"/"false" output so backtest logs and
-                    # alert messages line up with the TradingView side.
-                    if inferred == "bool":
-                        rest.append(
-                            f'({visited} ? std::string("true") : std::string("false"))'
-                        )
-                        continue
-                    rest.append(f'std::to_string({visited})')
-                if rest:
-                    vec = "{" + ", ".join(rest) + "}"
-                    return f'pine_str_format({fmt_arg}, {vec})'
-                return fmt_arg
+            format_node = (node.args[0] if node.args
+                           else node.kwargs.get("formatString"))
+            if format_node is not None:
+                return self._str_format_expr(format_node, node.args[1:])
             return 'std::string("")'
 
         if func_name == "format_time":
             ts = args[0] if args else "0"
+            ts_node = node.args[0] if node.args else node.kwargs.get("time")
+            if (ts_node is not None and self._holds_na_aware_wide_double(ts_node)
+                    and self._emitted_value_is_double(ts_node)):
+                # A double-valued 64-bit product (``_wide_int_arith_cpp``)
+                # narrows na-preserving into the int64_t timestamp (quirk 9).
+                ts = na_preserving_int_cast(ts, "int64_t")
             fmt = args[1] if len(args) > 1 else '"yyyy-MM-dd"'
             tz = args[2] if len(args) > 2 else '"UTC"'
             return f'pine_str_format_time({ts}, {fmt}, {tz})'
@@ -2723,20 +3514,27 @@ class CallVisitor:
                 # 4-arg form: replace the Nth occurrence (0-based, per Pine
                 # spec). Out-of-range / negative occurrence → original string.
                 return (
-                    f'[&](){{ std::string s={args[0]}; std::string t={args[1]}; '
-                    f'std::string r={args[2]}; int _occ=(int)({args[3]}); '
-                    f'if(t.empty()||_occ<0) return s; '
-                    f'size_t p=0; int _i=0; '
-                    f'while((p=s.find(t,p))!=std::string::npos){{ '
-                    f'if(_i==_occ){{ s.replace(p,t.length(),r); break; }} '
-                    f'p+=t.length(); _i++; }} return s; }}()'
+                    f'[&](){{ std::string __pf_s={args[0]}; std::string __pf_t={args[1]}; '
+                    f'std::string __pf_r={args[2]}; int __pf_occ={self._coerce_int_slot(args[3], arg_nodes[3], "int")}; '
+                    f'if(is_na(__pf_occ)) __pf_occ=0; '
+                    f'if(__pf_t.empty()||__pf_occ<0) return __pf_s; '
+                    f'size_t __pf_p=0; int __pf_i=0; '
+                    f'while((__pf_p=__pf_s.find(__pf_t,__pf_p))!=std::string::npos){{ '
+                    f'if(__pf_i==__pf_occ){{ __pf_s.replace(__pf_p,__pf_t.length(),__pf_r); break; }} '
+                    f'__pf_p+=__pf_t.length(); __pf_i++; }} return __pf_s; }}()'
                 )
             if len(args) >= 3:
-                return f'[&](){{ std::string s={args[0]}; auto p=s.find({args[1]}); if(p!=std::string::npos) s.replace(p,{args[1]}.length(),{args[2]}); return s; }}()'
+                # target is read twice: evaluate it once.
+                return evaluate_args_once(
+                    args, (1,),
+                    lambda a: f'[&](){{ std::string __pf_s={a[0]}; auto __pf_p=__pf_s.find({a[1]}); if(__pf_p!=std::string::npos) __pf_s.replace(__pf_p,{a[1]}.length(),{a[2]}); return __pf_s; }}()',
+                    "_pf_str_a")
             return 'std::string("")'
 
         if func_name in STR_FUNC_MAP and STR_FUNC_MAP[func_name] is not None:
-            return STR_FUNC_MAP[func_name](args)
+            return evaluate_args_once(
+                args, STR_ARGS_READ_REPEATEDLY.get(func_name, ()),
+                STR_FUNC_MAP[func_name], "_pf_str_a")
 
         return f'std::string("") /* unsupported: str.{func_name} */'
 
@@ -2744,7 +3542,7 @@ class CallVisitor:
         args = _merge_kwargs(node.args, node.kwargs, sigs.get_param_names("math", func_name), self._visit_expr)
         # Handle special cases first
         if func_name == "round" and len(args) == 2:
-            return f"(std::round({args[0]} * std::pow(10.0, {args[1]})) / std::pow(10.0, {args[1]}))"
+            return _math_round_digits_expr(args)
         if func_name == "round_to_mintick":
             # Engine method (engine.hpp): NaN- and mintick<=0-guarded,
             # unlike the previous inlined unguarded std::round.