@pineforge/codegen-pyodide 0.10.0 → 0.10.2

package/pineforge_codegen/codegen/visit_call.py

@@ -133,14 +133,21 @@ all tables it needs come from ``codegen/tables.py``, AST classes from
 from __future__ import annotations
 
 from ..ast_nodes import (
+    ASTNode,
     FuncCall,
     Identifier,
     MemberAccess,
     NaLiteral,
     TupleLiteral,
     StringLiteral,
+    VarDecl,
+)
+from ..symbols import TypeSpec, method_receiver_type_name
+from ..method_binding import (
+    MethodBindError,
+    bind_method_call,
+    signature_from_callable,
 )
-from ..symbols import TypeSpec
 from .. import signatures as sigs
 from .drawing import ALL_DRAWING_METHODS
 from .tables import (
@@ -148,9 +155,11 @@ from .tables import (
     ARRAY_METHODS,
     BAR_FIELDS,
     BAR_SERIES_PUSH,
+    CHECKED_ARRAY_METHOD_KWARGS,
     DRAWING_NS,
     DRAWING_TYPE_TO_CPP,
     MAP_METHODS,
+    MAP_METHOD_KWARGS,
     MATH_FUNC_MAP,
     MATRIX_METHODS,
     MATRIX_METHOD_KWARGS,
@@ -163,7 +172,6 @@ from .tables import (
     TIME_FIELD_EXPRS,
     _math_minmax_na_expr,
     _merge_kwargs,
-    _merge_kwargs_with_defaults,
     tz_time_field_lambda,
 )
 
@@ -243,6 +251,149 @@ class CallVisitor:
             return f"{base}_cs{self._active_call_site_idx}"
         return base
 
+    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)
+        receiver_name = method_receiver_type_name(receiver_spec)
+        if receiver_name is None:
+            return receiver_spec, None
+        method_info = self._func_info_map.get(f"{receiver_name}.{member}")
+        if (
+            method_info is None
+            or not getattr(method_info, "is_udt_method", False)
+        ):
+            return receiver_spec, None
+        return receiver_spec, method_info
+
+    def _bind_typed_method_args(self, method_info, node: FuncCall):
+        """Bind typed method arguments through the analyzer-shared rules."""
+
+        param_names = (
+            list(method_info.node.params[1:])
+            if method_info.node is not None
+            else []
+        )
+        param_defaults = list(
+            getattr(method_info, "param_defaults", ()) or ()
+        )[1:]
+        hints = list(
+            (getattr(method_info.node, "annotations", None) or {}).get(
+                "param_type_hints", ()
+            )
+            if method_info.node is not None
+            else ()
+        )[1:]
+        signature = signature_from_callable(
+            method_info.name,
+            param_names,
+            param_defaults,
+            hints,
+        )
+        try:
+            return bind_method_call(signature, node)
+        except MethodBindError as exc:
+            self._codegen_error(node, str(exc))
+            raise AssertionError("unreachable") from exc
+
+    def _emit_udt_new_expr(
+        self,
+        type_name: str,
+        field_initializers: list[str],
+    ) -> str:
+        """Allocate one authored UDT record and return its numeric object ID."""
+        record_type = self._udt_record_cpp_type(type_name)
+        arena = self._udt_arena_member_name(type_name)
+        return f"{arena}.create({record_type}{{{', '.join(field_initializers)}}})"
+
+    def _emit_udt_copy_expr(self, type_name: str, source_cpp: str) -> str:
+        """Allocate a detached outer record while shallow-copying nested IDs."""
+        return f"{self._udt_arena_member_name(type_name)}.copy({source_cpp})"
+
+    def _emit_typed_user_method_call(
+        self,
+        node: FuncCall,
+        receiver_spec: TypeSpec,
+        method_info,
+    ) -> str:
+        """Lower a typed extension method with ordinary callable semantics."""
+        callee = node.callee
+        assert isinstance(callee, MemberAccess)
+        receiver_node = callee.object
+        fn_cpp = self._udt_method_call_emit_name(method_info, node)
+
+        binding = self._bind_typed_method_args(method_info, node)
+        rest_nodes = list(binding.args_by_param)
+        receiver_cpp = self._visit_typed_method_param(
+            method_info,
+            node,
+            receiver_node,
+            0,
+        )
+        rest_cpp = [
+            self._visit_typed_method_param(
+                method_info,
+                node,
+                arg,
+                index + 1,
+            )
+            for index, arg in enumerate(rest_nodes)
+        ]
+
+        receiver_root = receiver_node
+        while isinstance(receiver_root, MemberAccess):
+            receiver_root = receiver_root.object
+        receiver_passes_by_reference = (
+            receiver_spec.kind in {"array", "matrix"}
+            or (
+                receiver_spec.kind == "udt"
+                and receiver_spec.name not in self._udt_defs
+            )
+        )
+        return self._ordered_user_call_expr(
+            fn_cpp,
+            [receiver_node, *rest_nodes],
+            [receiver_cpp, *rest_cpp],
+            source_order_nodes=[
+                receiver_node,
+                *binding.evaluation_order,
+            ],
+            force_stage=(
+                receiver_passes_by_reference
+                and not isinstance(receiver_root, Identifier)
+            ),
+        )
+
+    def _callable_target_callsite_idx(self, fi, node: FuncCall) -> int | None:
+        """Return the primitive profile selected by this emitted call path."""
+        cs_info = self.ctx.func_call_cs_map.get(id(node))
+        count = self.ctx.func_call_site_counts.get(fi.name, 0)
+        if self._active_call_site_idx is not None and (
+            cs_info is not None or count > 1
+        ):
+            return self._active_call_site_idx
+        if cs_info is not None and cs_info[0] == fi.name:
+            return cs_info[1]
+        return None
+
+    @staticmethod
+    def _series_bridge_value_expr(expr_cpp: str, cpp_type: str) -> str:
+        """Convert one scalar to a Series element without erasing Pine na.
+
+        Numeric C++ casts do not translate sentinels: INT64_MIN converted to
+        double is finite, while NaN converted to an integer is undefined.  A
+        history bridge must re-materialize ``na<T>`` in the destination family
+        before pushing the value.
+        """
+        return (
+            "([&]() { auto _pf_series_raw = ("
+            + expr_cpp
+            + "); return is_na(_pf_series_raw) ? na<"
+            + cpp_type
+            + ">() : static_cast<"
+            + cpp_type
+            + ">(_pf_series_raw); }())"
+        )
+
     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":
@@ -281,27 +432,660 @@ class CallVisitor:
             for idx, arg in enumerate(arg_nodes)
         ]
 
+    def _array_method_arg_nodes(self, method: str, node: FuncCall) -> list:
+        """Merge checked-array method kwargs into Pine signature order."""
+        param_names = CHECKED_ARRAY_METHOD_KWARGS.get(method)
+        if param_names is None:
+            return list(node.args)
+        return _merge_kwargs(node.args, node.kwargs, param_names, lambda arg: arg)
+
+    def _array_function_arg_nodes(self, method: str, node: FuncCall) -> list:
+        """Merge ``array.method(id=..., ...)`` arguments in signature order."""
+        if method == "copy":
+            if len(node.args) == 1 and not node.kwargs:
+                return list(node.args)
+            if not node.args and set(node.kwargs) == {"id"}:
+                return [node.kwargs["id"]]
+            self._codegen_error(
+                node,
+                "array.copy: expected exactly one receiver 'id'",
+                hint="Use array.copy(source) or array.copy(id=source).",
+            )
+        param_names = CHECKED_ARRAY_METHOD_KWARGS.get(method)
+        if param_names is None:
+            return list(node.args)
+        return _merge_kwargs(
+            node.args, node.kwargs, ["id", *param_names], lambda arg: arg
+        )
+
+    def _map_identifier_is_visible_binding(self, node: FuncCall) -> bool:
+        """Whether ``map`` is a lexical value at this exact source position.
+
+        Global collection registries are intentionally pre-populated before
+        code emission, so raw membership in ``_var_names`` / collection maps
+        cannot answer this question: a later ``map`` declaration must not
+        capture an earlier built-in ``map.*`` call.  Callable/block overlays,
+        by contrast, are activated in source order and therefore take first
+        refusal.  For a direct top-level binding, compare the containing
+        top-level statement indexes; the binding becomes visible only after
+        its declaration statement, never inside its own RHS.
+        """
+        name = "map"
+        if (
+            name in getattr(self, "_current_func_param_types", {})
+            or name in getattr(self, "_current_func_collection_specs", {})
+            or name in getattr(self, "_current_func_collection_shadows", set())
+            or name in getattr(self, "_current_func_local_types", {})
+            or name in getattr(self, "_current_loop_vars", set())
+            or getattr(self, "_block_map_binding_visible", False)
+        ):
+            return True
+
+        top_index_by_node = getattr(self, "_top_level_index_by_ast_node", None)
+        top_index_by_span = getattr(self, "_top_level_index_by_source_span", None)
+        map_decl_index = getattr(self, "_top_level_map_decl_index", None)
+        if top_index_by_node is None or top_index_by_span is None:
+            top_index_by_node = {}
+            top_index_by_span = {}
+            ambiguous_spans = set()
+            map_decl_index = None
+            for index, statement in enumerate(self.ctx.ast.body):
+                for candidate in self._walk_ast(statement):
+                    top_index_by_node[id(candidate)] = index
+                    loc = getattr(candidate, "loc", None)
+                    if loc is not None:
+                        span = (
+                            type(candidate), loc.file, loc.line, loc.col, loc.end_col,
+                        )
+                        previous = top_index_by_span.get(span)
+                        if previous is None:
+                            top_index_by_span[span] = index
+                        elif previous != index:
+                            ambiguous_spans.add(span)
+                if (
+                    map_decl_index is None
+                    and isinstance(statement, VarDecl)
+                    and statement.name == name
+                ):
+                    map_decl_index = index
+            for span in ambiguous_spans:
+                top_index_by_span.pop(span, None)
+            self._top_level_index_by_ast_node = top_index_by_node
+            self._top_level_index_by_source_span = top_index_by_span
+            self._top_level_map_decl_index = map_decl_index
+
+        if map_decl_index is None:
+            return False
+        call_index = top_index_by_node.get(id(node))
+        if call_index is None:
+            # Setup-time rewrites (notably request.security timeframe input
+            # substitution) may clone an expression.  Those clones retain the
+            # original source span, so recover their containing top-level
+            # statement from the unmodified AST instead of treating every
+            # synthetic node as if all globals were already visible.
+            loc = getattr(node, "loc", None)
+            if loc is not None:
+                call_index = top_index_by_span.get(
+                    (type(node), loc.file, loc.line, loc.col, loc.end_col)
+                )
+        if call_index is None:
+            # With no identity or source ancestry there is no evidence that a
+            # later global binding was visible.  Fail closed to the built-in
+            # namespace; synthetic lexical receivers must preserve provenance.
+            return False
+        return map_decl_index < call_index
+
+    def _map_call_arg_nodes(
+        self,
+        method: str,
+        node: FuncCall,
+        *,
+        functional: bool,
+        allow_keywords: bool,
+    ) -> list:
+        """Validate and bind one established map-call form.
+
+        Map lowerings index directly into their argument arrays.  Before this
+        guard, malformed calls therefore either reached a raw ``IndexError``
+        or, for keyword-only ``map.*`` functional calls, silently lowered to
+        ``0``.  Keep routing policy separate from signature validation: only
+        the typed-map UDF-parameter method lane currently accepts canonical
+        keywords; all other lanes retain their established positional-only
+        semantics and fail closed when keywords are supplied.
+        """
+        if method == "new":
+            param_names: list[str] = []
+        else:
+            method_params = MAP_METHOD_KWARGS.get(method)
+            if method_params is None:
+                return list(node.args)
+            param_names = (["id", *method_params] if functional
+                           else list(method_params))
+
+        signature = f"map.{method}({', '.join(param_names)})"
+        unknown = sorted(set(node.kwargs) - set(param_names))
+        if unknown:
+            name = unknown[0]
+            hint = f"Expected {signature}."
+            if method == "put_all" and name == "from":
+                hint = f"Use 'id2=' for the source map. Expected {signature}."
+            self._codegen_error(
+                node,
+                f"map.{method}: unknown keyword argument '{name}'",
+                hint=hint,
+            )
+
+        if len(node.args) > len(param_names):
+            self._codegen_error(
+                node,
+                (
+                    f"map.{method}: too many positional arguments "
+                    f"(expected {len(param_names)}, got {len(node.args)})"
+                ),
+                hint=f"Expected {signature}.",
+            )
+
+        for name in param_names[:len(node.args)]:
+            if name in node.kwargs:
+                self._codegen_error(
+                    node,
+                    (
+                        f"map.{method}: argument '{name}' passed both "
+                        "positionally and by keyword"
+                    ),
+                    hint=f"Expected {signature}; bind each argument once.",
+                )
+
+        bound: list = [None] * len(param_names)
+        for index, arg in enumerate(node.args):
+            bound[index] = arg
+        for name, value in node.kwargs.items():
+            bound[param_names.index(name)] = value
+
+        missing = [
+            name for name, value in zip(param_names, bound) if value is None
+        ]
+        if missing:
+            self._codegen_error(
+                node,
+                f"map.{method}: missing required argument '{missing[0]}'",
+                hint=f"Expected {signature}.",
+            )
+
+        if node.kwargs and not allow_keywords:
+            form = "functional" if functional else "receiver-method"
+            self._codegen_error(
+                node,
+                (
+                    f"map.{method}: keyword arguments are not supported "
+                    f"for this {form} call form"
+                ),
+                hint=f"Use the established positional form: {signature}.",
+            )
+
+        return bound
+
+    def _map_param_method_expr(
+        self, map_expr: str, method: str, arg_nodes: list, spec: TypeSpec,
+    ) -> str:
+        """Lower one map operation with receiver-first, ordered single use.
+
+        C++17 sequences a member-call receiver before its arguments but does
+        not order sibling arguments. Pine requires receiver, key, then value.
+        Nested immediately-invoked lambdas bind the receiver first and every
+        argument in source/signature order, while retaining lvalue aliases and
+        extending temporary receiver lifetime through the operation.
+        """
+        args = [self._visit_expr(arg) for arg in arg_nodes]
+        occupied = "\n".join((map_expr, *args))
+        counter = getattr(self, "_map_param_arg_counter", 0)
+        bindings: list[tuple[str, str]] = []
+        for arg in args:
+            while True:
+                token = f"__pf_map_param_arg_{counter}"
+                counter += 1
+                if token not in occupied:
+                    break
+            bindings.append((token, arg))
+        self._map_param_arg_counter = counter
+
+        receiver_counter = getattr(self, "_map_receiver_counter", 0)
+        while True:
+            receiver_token = f"__pf_map_receiver_{receiver_counter}"
+            receiver_counter += 1
+            if receiver_token not in occupied:
+                break
+        self._map_receiver_counter = receiver_counter
+
+        lowered = self._map_method_expr(
+            receiver_token, method, [token for token, _arg in bindings], spec
+        )
+        for token, arg in reversed(bindings):
+            lowered = (
+                f"[&](auto&& {token})->decltype(auto){{ "
+                f"return {lowered}; }}(({arg}))"
+            )
+        return (
+            f"[&](auto&& {receiver_token})->decltype(auto){{ "
+            f"return {lowered}; }}(({map_expr}))"
+        )
+
+    def _expr_contains_map_operation(
+        self,
+        node,
+        visiting_callables: frozenset[str] = frozenset(),
+        lexical_specs: dict[str, TypeSpec | None] | None = None,
+    ) -> bool:
+        """Whether an expression directly or transitively operates on a map.
+
+        C++17 does not order sibling function arguments.  We keep ordinary
+        calls byte-identical and only stage calls whose argument tree can
+        observe map identity/state (including a user helper whose body performs
+        such an operation).
+        """
+        if not isinstance(node, ASTNode):
+            return False
+        lexical_specs = lexical_specs or {}
+        if isinstance(node, FuncCall):
+            callee = node.callee
+            if isinstance(callee, MemberAccess):
+                if (
+                    isinstance(callee.object, Identifier)
+                    and callee.object.name == "map"
+                    and callee.member in (set(MAP_METHODS) | {"new"})
+                ):
+                    return True
+                receiver_spec = self._map_effect_type_spec(
+                    callee.object, lexical_specs
+                )
+                if (
+                    receiver_spec is not None
+                    and receiver_spec.kind == "map"
+                    and callee.member in MAP_METHODS
+                ):
+                    return True
+
+            info_key, func_info = self._map_effect_callable_info(
+                node, lexical_specs
+            )
+            if (
+                func_info is not None
+                and getattr(func_info, "node", None) is not None
+                and info_key not in visiting_callables
+            ):
+                next_visiting = visiting_callables | {info_key}
+                child_specs = self._map_effect_callable_specs(
+                    func_info,
+                    node,
+                    lexical_specs,
+                )
+                if any(
+                    self._expr_contains_map_operation(
+                        child,
+                        next_visiting,
+                        child_specs,
+                    )
+                    for child in func_info.node.body
+                ):
+                    return True
+
+        for value in vars(node).values():
+            if isinstance(value, ASTNode):
+                if self._expr_contains_map_operation(
+                    value, visiting_callables, lexical_specs
+                ):
+                    return True
+            elif isinstance(value, list):
+                if any(
+                    self._expr_contains_map_operation(
+                        item, visiting_callables, lexical_specs
+                    )
+                    for item in value
+                    if isinstance(item, ASTNode)
+                ):
+                    return True
+            elif isinstance(value, dict):
+                if any(
+                    self._expr_contains_map_operation(
+                        item, visiting_callables, lexical_specs
+                    )
+                    for item in value.values()
+                    if isinstance(item, ASTNode)
+                ):
+                    return True
+        return False
+
+    def _map_effect_type_spec(
+        self,
+        node,
+        lexical_specs: dict[str, TypeSpec | None],
+    ) -> TypeSpec | None:
+        """Resolve an expression type in the callable being inspected.
+
+        The ordinary codegen resolver describes the function currently being
+        emitted, not a transitive helper whose AST is being audited for effects.
+        Respect that helper's parameter/local bindings first, then fall back to
+        the established expression inference for globals and constructors.
+        """
+        if isinstance(node, Identifier) and node.name in lexical_specs:
+            return lexical_specs[node.name]
+        if isinstance(node, MemberAccess):
+            owner = self._map_effect_type_spec(node.object, lexical_specs)
+            if owner is not None and owner.kind == "udt" and owner.name:
+                return (self._udt_field_type_specs.get(owner.name) or {}).get(
+                    node.member
+                )
+        if isinstance(node, FuncCall):
+            _key, info = self._map_effect_callable_info(node, lexical_specs)
+            return_spec = getattr(info, "return_type_spec", None)
+            if return_spec is not None:
+                return return_spec
+        return self._type_spec_from_expr(node)
+
+    def _map_effect_callable_info(
+        self,
+        node: FuncCall,
+        lexical_specs: dict[str, TypeSpec | None],
+    ):
+        """Resolve a plain UDF or UDT method for transitive effect analysis."""
+        callee = node.callee
+        if isinstance(callee, Identifier):
+            key = callee.name
+            return key, self._func_info_map.get(key)
+        if isinstance(callee, MemberAccess):
+            receiver_spec = self._map_effect_type_spec(
+                callee.object, lexical_specs
+            )
+            receiver_name = method_receiver_type_name(receiver_spec)
+            if receiver_name is not None:
+                key = f"{receiver_name}.{callee.member}"
+                return key, self._func_info_map.get(key)
+        return "", None
+
+    def _map_effect_callable_specs(
+        self,
+        func_info,
+        call: FuncCall,
+        caller_specs: dict[str, TypeSpec | None],
+    ) -> dict[str, TypeSpec | None]:
+        """Build the inspected callee's lexical TypeSpec environment.
+
+        Declared and already-inferred parameter specs are authoritative.  Any
+        unresolved slot is filled from this exact call's argument in the
+        caller's lexical environment, which also lets an untyped map flow
+        through multiple helper layers before analyzer call-site inference has
+        materialized every nested parameter.
+        """
+        func_node = func_info.node
+        params = list(func_node.params) if func_node is not None else []
+        declared_specs = list(getattr(func_info, "param_type_specs", ()) or ())
+        result: dict[str, TypeSpec | None] = {
+            param: declared_specs[index] if index < len(declared_specs) else None
+            for index, param in enumerate(params)
+        }
+
+        is_method = bool(getattr(func_info, "is_udt_method", False))
+        if is_method and isinstance(call.callee, MemberAccess):
+            binding = self._bind_typed_method_args(func_info, call)
+            positional = [call.callee.object, *binding.args_by_param]
+        else:
+            positional = list(call.args)
+        for index, actual in enumerate(positional):
+            if index >= len(params) or result[params[index]] is not None:
+                continue
+            result[params[index]] = self._map_effect_type_spec(
+                actual, caller_specs
+            )
+
+        if not is_method:
+            for name, actual in call.kwargs.items():
+                if name not in params:
+                    continue
+                if result[name] is None:
+                    result[name] = self._map_effect_type_spec(
+                        actual, caller_specs
+                    )
+
+        # Direct callable locals already carry analyzer-owned lexical
+        # provenance.  They override same-named parameters/globals exactly as
+        # they do during real function emission.
+        result.update(self._func_collection_types.get(func_info.name, {}))
+        return result
+
+    def _ordered_user_call_expr(
+        self,
+        call_head: str,
+        arg_nodes: list,
+        arg_exprs: list[str],
+        *,
+        source_order_nodes: list | None = None,
+        force_stage: bool = False,
+    ) -> str:
+        """Emit a user call with deterministic argument evaluation when needed.
+
+        ``arg_nodes``/``arg_exprs`` are in destination parameter order.
+        ``source_order_nodes`` records the caller's written order, allowing
+        named arguments to be evaluated as written while still occupying their
+        declared parameter slots.
+        """
+        raw = f"{call_head}({', '.join(arg_exprs)})"
+        has_map_effect = any(
+            self._expr_contains_map_operation(node) for node in arg_nodes
+        )
+        if not force_stage and (len(arg_exprs) < 2 or not has_map_effect):
+            return raw
+
+        occupied = "\n".join((call_head, *arg_exprs))
+        counter = getattr(self, "_ordered_call_arg_counter", 0)
+        tokens: list[str] = []
+        for _ in arg_exprs:
+            while True:
+                token = f"__pf_call_arg_{counter}"
+                counter += 1
+                if token not in occupied:
+                    break
+            tokens.append(token)
+        self._ordered_call_arg_counter = counter
+
+        remaining = list(range(len(arg_nodes)))
+        evaluation_order: list[int] = []
+        for source_node in source_order_nodes or arg_nodes:
+            for index in remaining:
+                if arg_nodes[index] is source_node:
+                    evaluation_order.append(index)
+                    remaining.remove(index)
+                    break
+        evaluation_order.extend(remaining)
+
+        lowered = f"{call_head}({', '.join(tokens)})"
+        for index in reversed(evaluation_order):
+            lowered = (
+                f"[&](auto&& {tokens[index]})->decltype(auto){{ "
+                f"return {lowered}; }}(({arg_exprs[index]}))"
+            )
+        return lowered
+
+    def _visit_typed_method_param(
+        self,
+        func_info,
+        call_node: FuncCall,
+        arg_node,
+        param_index: int,
+    ) -> str:
+        """Lower one typed-method parameter with history-Series awareness."""
+        param_name = (
+            func_info.node.params[param_index]
+            if func_info.node is not None
+            and param_index < len(func_info.node.params)
+            else None
+        )
+        param_specs = list(
+            getattr(func_info, "param_type_specs", ()) or ()
+        )
+        param_spec = (
+            param_specs[param_index]
+            if param_index < len(param_specs)
+            else None
+        )
+        if param_spec is not None and param_spec.kind in {"map", "matrix"}:
+            # Both UDT-method dispatch paths funnel through this helper after
+            # positional/keyword/default merging.  Lower a bare ``na`` (and
+            # nullable selections containing it) against the declared exact
+            # parameter type instead of the legacy numeric ``na<double>()``.
+            return self._visit_rhs_value(
+                arg_node,
+                target_cpp_type=self._type_spec_to_cpp(param_spec),
+            )
+        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)
+        expected_cpp_type = self._series_param_element_cpp_type(
+            func_info,
+            param_index,
+            self._callable_target_callsite_idx(func_info, call_node),
+        )
+        if isinstance(arg_node, Identifier):
+            arg_name = arg_node.name
+            if (
+                (arg_name in BAR_FIELDS or arg_name in BAR_SERIES_PUSH)
+                and expected_cpp_type == "double"
+            ):
+                return f"_s_{arg_name}"
+            safe = self._safe_name(arg_name)
+            is_current_series_param = (
+                arg_name in self._current_func_series_params
+            )
+            if (
+                is_current_series_param
+                and self._current_func_series_param_types.get(arg_name)
+                    == expected_cpp_type
+            ):
+                return safe
+            if self._active_var_remap and safe in self._active_var_remap:
+                safe = self._active_var_remap[safe]
+            if (
+                not is_current_series_param
+                and self._binding_is_series(arg_name, safe)
+                and self._series_type_for(arg_name) == expected_cpp_type
+            ):
+                return safe
+        expr_cpp = self._visit_expr(arg_node)
+        cpp_type = expected_cpp_type
+        bridge_cpp = self._series_bridge_value_expr(expr_cpp, cpp_type)
+        member = self._inline_history_member(
+            "series_arg", call_node, arg_idx=param_index
+        )
+        return (
+            f"([&]() -> const Series<{cpp_type}>& {{ "
+            f"{cpp_type} _sv = {bridge_cpp}; "
+            f"if (history_advances_new_bar()) {member}.push(_sv); "
+            f"else {member}.update(_sv); "
+            f"return {member}; }}())"
+        )
+
+    def _visit_udt_method_series_arg(
+        self,
+        func_info,
+        call_node: FuncCall,
+        arg_node,
+        rest_index: int,
+    ) -> str:
+        """Backward-compatible wrapper for non-receiver method arguments."""
+        return self._visit_typed_method_param(
+            func_info,
+            call_node,
+            arg_node,
+            rest_index + 1,
+        )
+
     def _visit_func_call(self, node: FuncCall) -> str:
         callee = node.callee
         if isinstance(callee, MemberAccess):
+            recv_spec, method_info = self._typed_user_method_info(
+                callee.object,
+                callee.member,
+            )
+            if method_info is not None and recv_spec is not None:
+                # Pine extension methods are exact type-directed overloads.
+                # They must win before collection/drawing builtins; otherwise
+                # a user ``array<int>.push`` silently executes push_back.
+                return self._emit_typed_user_method_call(
+                    node,
+                    recv_spec,
+                    method_info,
+                )
             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 self._udt_defs
+                and callee.member == "copy"
+            ):
+                if node.args or node.kwargs:
+                    self._codegen_error(
+                        node,
+                        f"{recv_spec.name}.copy() expects no arguments",
+                        hint="Call copy() on the UDT object without arguments.",
+                    )
+                self._reject_unsupported_udt_copy(recv_spec.name, node)
+                return self._emit_udt_copy_expr(
+                    recv_spec.name,
+                    self._visit_expr(callee.object),
+                )
+            if (
+                recv_spec is not None
+                and recv_spec.kind == "map"
+                and not isinstance(callee.object, (Identifier, MemberAccess))
+                and callee.member in MAP_METHODS
+            ):
+                # Returned, constructed and selected map IDs are ordinary
+                # receivers too. Parenthesize the expression so ternaries and
+                # other compound producers remain one C++ receiver expression.
+                arg_nodes = self._map_call_arg_nodes(
+                    callee.member,
+                    node,
+                    functional=False,
+                    allow_keywords=False,
+                )
+                receiver = f"({self._visit_expr(callee.object)})"
+                return self._map_param_method_expr(
+                    receiver,
+                    callee.member,
+                    arg_nodes,
+                    recv_spec,
+                )
             if recv_spec is not None and recv_spec.kind == "udt" and recv_spec.name:
                 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._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
-                    # parallel array lines up with ``param_names`` (rest of
-                    # the signature). Probe: udt-method-probe-04-default-param.
-                    param_defaults = list(getattr(fi_u, "param_defaults", []) or [])[1:]
-                    rest_nodes = _merge_kwargs_with_defaults(
-                        node.args, node.kwargs, param_names,
-                        param_defaults, lambda x: x,
+                    receiver_root = callee.object
+                    while isinstance(receiver_root, MemberAccess):
+                        receiver_root = receiver_root.object
+                    stage_receiver = not isinstance(receiver_root, Identifier)
+                    binding = self._bind_typed_method_args(fi_u, node)
+                    rest_nodes = list(binding.args_by_param)
+                    rest = [
+                        self._visit_udt_method_series_arg(
+                            fi_u, node, arg, index
+                        )
+                        for index, arg in enumerate(rest_nodes)
+                    ]
+                    return self._ordered_user_call_expr(
+                        fn_cpp,
+                        [callee.object, *rest_nodes],
+                        [recv_e, *rest],
+                        source_order_nodes=[
+                            callee.object,
+                            *binding.evaluation_order,
+                        ],
+                        # Generated UDT methods accept ``T&``. A constructor or
+                        # 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,
                     )
-                    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
@@ -320,6 +1104,21 @@ class CallVisitor:
                     list(node.args), node,
                 )
 
+        # Array method on an arbitrary expression receiver, e.g.
+        # ``make_array().get(-1)``, ``m.row(0).last()``, or
+        # ``(cond ? a : b).get(-1)``. Identifier and member receivers have
+        # dedicated paths below; other receiver shapes used to fall through to
+        # ``None(...)`` despite carrying a known array spec.
+        if (isinstance(callee, MemberAccess)
+                and not isinstance(callee.object, (Identifier, MemberAccess))
+                and callee.member in ARRAY_METHODS):
+            recv_spec = self._type_spec_from_expr(callee.object)
+            if recv_spec is not None and recv_spec.kind == "array":
+                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)
+
         # 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
@@ -333,20 +1132,49 @@ class CallVisitor:
             obj = callee.object
             if isinstance(obj, MemberAccess):
                 root = obj.object
-                if not (isinstance(root, Identifier) and root.name in (
+                root_is_builtin_namespace = (
+                    isinstance(root, Identifier)
+                    and root.name in (
                     "strategy", "ta", "math", "input", "str", "timeframe", "syminfo",
                     "barstate", "color", "request", "runtime", "array", "matrix", "map",
-                )):
+                    )
+                )
+                if (
+                    root_is_builtin_namespace
+                    and root.name == "map"
+                    and self._map_identifier_is_visible_binding(node)
+                ):
+                    root_is_builtin_namespace = False
+                if not root_is_builtin_namespace:
                     recv_spec = self._type_spec_from_expr(obj)
                     recv = self._visit_expr(obj)
                     meth = callee.member
+                    if (
+                        recv_spec is not None
+                        and recv_spec.kind == "map"
+                        and meth in MAP_METHODS
+                    ):
+                        arg_nodes = self._map_call_arg_nodes(
+                            meth,
+                            node,
+                            functional=False,
+                            allow_keywords=False,
+                        )
+                        return self._map_param_method_expr(
+                            recv,
+                            meth,
+                            arg_nodes,
+                            recv_spec,
+                        )
                     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:
+                        arg_nodes = self._array_method_arg_nodes(meth, node)
                         return self._array_method_expr(
-                            recv, meth, self._array_method_args(meth, node.args, recv_spec), recv_spec
+                            recv,
+                            meth,
+                            self._array_method_args(meth, arg_nodes, 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)
                     if meth == "delete":
                         meth = "_delete_"
@@ -354,27 +1182,101 @@ class CallVisitor:
             # obj.method() where obj is a user var/param — not namespace::method
             if isinstance(obj, Identifier):
                 oname = obj.name
-                if (
+                receiver_is_visible = (
+                    oname != "map"
+                    or self._map_identifier_is_visible_binding(node)
+                )
+                if receiver_is_visible and (
                     oname in self._var_names
                     or oname in self._current_func_param_types
                     or oname in self._current_loop_vars
                     or oname in self._global_member_vars
                 ):
                     meth_raw = callee.member
-                    # map.put / map.get / … must lower to unordered_map ops, not `.put` on C++
-                    if oname in self._map_vars and meth_raw in MAP_METHODS:
-                        m = self._safe_name(oname)
-                        margs = [self._visit_expr(a) for a in node.args]
-                        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)
+                    # Function parameters have lexical precedence over the
+                    # global collection registries.  Route a declared/inferred
+                    # ``array<T>`` parameter before consulting same-named
+                    # global map/array/matrix entries, and retain its element
+                    # TypeSpec for checked reads and mutations.
+                    param_spec = getattr(
+                        self, "_current_func_param_specs", {}
+                    ).get(oname)
+                    active_local_shadow = (
+                        oname in getattr(
+                            self, "_current_func_collection_specs", {}
+                        )
+                        or oname in getattr(
+                            self, "_current_func_collection_shadows", set()
+                        )
+                    )
+                    if (
+                        param_spec is not None
+                        and param_spec.kind == "array"
+                        and not active_local_shadow
+                        and meth_raw in ARRAY_METHODS
+                    ):
+                        arr = self._collection_receiver_expr(oname)
+                        arg_nodes = self._array_method_arg_nodes(meth_raw, node)
                         margs = self._array_method_args(
-                            meth_raw, node.args, self._array_spec_for_name(oname)
+                            meth_raw, arg_nodes, param_spec
+                        )
+                        return self._array_method_expr(
+                            arr, meth_raw, margs, param_spec
+                        )
+                    if (
+                        param_spec is not None
+                        and param_spec.kind == "map"
+                        and not active_local_shadow
+                        and meth_raw in MAP_METHODS
+                    ):
+                        m = self._collection_receiver_expr(oname)
+                        arg_nodes = self._map_call_arg_nodes(
+                            meth_raw,
+                            node,
+                            functional=False,
+                            allow_keywords=True,
                         )
-                        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)
-                        self._check_matrix_method_allowed(meth_raw, self._matrix_specs[oname], node)
+                        return self._map_param_method_expr(
+                            m, meth_raw, arg_nodes, param_spec
+                        )
+                    recv_spec = self._collection_spec_for_name(oname)
+                    # Resolve the lexical TypeSpec once and route by its exact
+                    # kind.  Raw membership sets can contain a same-named
+                    # binding from another scope; overlapping methods such as
+                    # ``get`` must never use those as a tie-breaker.
+                    if (
+                        recv_spec is not None
+                        and recv_spec.kind == "map"
+                        and meth_raw in MAP_METHODS
+                    ):
+                        m = self._collection_receiver_expr(oname)
+                        arg_nodes = self._map_call_arg_nodes(
+                            meth_raw,
+                            node,
+                            functional=False,
+                            allow_keywords=False,
+                        )
+                        return self._map_param_method_expr(
+                            m, meth_raw, arg_nodes, recv_spec
+                        )
+                    if (
+                        recv_spec is not None
+                        and recv_spec.kind == "array"
+                        and meth_raw in ARRAY_METHODS
+                    ):
+                        arr = self._collection_receiver_expr(oname)
+                        arg_nodes = self._array_method_arg_nodes(meth_raw, node)
+                        margs = self._array_method_args(
+                            meth_raw, arg_nodes, recv_spec
+                        )
+                        return self._array_method_expr(arr, meth_raw, margs, recv_spec)
+                    if (
+                        recv_spec is not None
+                        and recv_spec.kind == "matrix"
+                        and meth_raw in MATRIX_METHODS
+                    ):
+                        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(
@@ -391,27 +1293,35 @@ class CallVisitor:
                                 f"matrix.{meth_raw}: wrong number of arguments",
                                 hint="Check Pine v6 matrix method signature (positional vs keyword).",
                             )
-                    safe_o = self._safe_name(oname)
-                    udt_t = self._udt_var_types.get(oname) or self._udt_var_types.get(safe_o)
-                    if udt_t is None:
-                        udt_t = self._udt_param_udt.get(oname) or self._udt_param_udt.get(safe_o)
+                    recv_spec = self._type_spec_from_expr(obj)
+                    udt_t = (
+                        recv_spec.name
+                        if recv_spec is not None and recv_spec.kind == "udt"
+                        else None
+                    )
                     if udt_t is not None:
                         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._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
-                            # lines up with ``param_names``. Probe:
-                            # udt-method-probe-04-default-param.
-                            param_defaults = list(getattr(fi_u, "param_defaults", []) or [])[1:]
-                            rest_nodes = _merge_kwargs_with_defaults(
-                                node.args, node.kwargs, param_names,
-                                param_defaults, lambda x: x,
+                            binding = self._bind_typed_method_args(fi_u, node)
+                            rest_nodes = list(binding.args_by_param)
+                            rest = [
+                                self._visit_udt_method_series_arg(
+                                    fi_u, node, arg, index
+                                )
+                                for index, arg in enumerate(rest_nodes)
+                            ]
+                            return self._ordered_user_call_expr(
+                                fn_cpp,
+                                [obj, *rest_nodes],
+                                [recv_e, *rest],
+                                source_order_nodes=[
+                                    obj,
+                                    *binding.evaluation_order,
+                                ],
                             )
-                            rest = [self._visit_expr(a) for a in rest_nodes]
-                            return f"{fn_cpp}({', '.join([recv_e] + rest)})"
                     args = ", ".join(self._visit_expr(a) for a in node.args)
                     recv = self._visit_expr(obj)
                     meth = meth_raw
@@ -466,6 +1376,8 @@ class CallVisitor:
             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 self._is_lazy_saturated_roc3_site(site):
+                return self._lazy_saturated_roc3_expr(site)
             if uses_precalc:
                 return (
                     f"(_use_precalc ? _precalc_{ta_mem}[bar_index_] : "
@@ -497,26 +1409,64 @@ class CallVisitor:
             return self._visit_str_call(func_name, node)
 
         # Map method syntax: m.put(key, val) where namespace is the map variable name
-        if namespace is not None and namespace in self._map_vars and func_name in MAP_METHODS:
-            m = self._safe_name(namespace)
-            args = [self._visit_expr(a) for a in node.args]
-            return self._map_method_expr(m, func_name, args, self._map_spec_for_name(namespace))
+        namespace_spec = (
+            self._collection_spec_for_name(namespace)
+            if namespace is not None
+            else None
+        )
+        if (
+            namespace == "map"
+            and not self._map_identifier_is_visible_binding(node)
+        ):
+            # A later global named ``map`` is already present in the flat
+            # collection registry, but is not yet a lexical receiver here.
+            namespace_spec = None
+        if (
+            namespace_spec is not None
+            and namespace_spec.kind == "map"
+            and func_name in MAP_METHODS
+        ):
+            m = self._collection_receiver_expr(namespace)
+            arg_nodes = self._map_call_arg_nodes(
+                func_name,
+                node,
+                functional=False,
+                allow_keywords=False,
+            )
+            return self._map_param_method_expr(
+                m, func_name, arg_nodes, namespace_spec
+            )
 
         # map.method(m, args...) — functional form
         if namespace == "map":
+            if func_name == "new" or func_name in MAP_METHODS:
+                # This dispatch point comes after lexical receiver routing, so
+                # a parameter/local/global named ``map`` retains precedence
+                # over the built-in namespace.
+                self._map_call_arg_nodes(
+                    func_name,
+                    node,
+                    functional=True,
+                    allow_keywords=False,
+                )
             if func_name == "new":
                 spec = self._type_spec_from_expr(node) or TypeSpec.map(TypeSpec.primitive("string"), TypeSpec.primitive("float"))
-                return f"{self._type_spec_to_cpp(spec)}()"
+                return f"{self._type_spec_to_cpp(spec)}::new_()"
             if func_name in MAP_METHODS and node.args:
                 m = 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]) if node.args else None
-                return self._map_method_expr(m, func_name, rest, spec)
+                return self._map_param_method_expr(
+                    m, func_name, list(node.args[1:]), spec
+                )
             return "0"
 
-        if namespace is not None and namespace in self._matrix_specs and func_name in MATRIX_METHODS:
-            arr = self._safe_name(namespace)
-            self._check_matrix_method_allowed(func_name, self._matrix_specs[namespace], node)
+        if (
+            namespace_spec is not None
+            and namespace_spec.kind == "matrix"
+            and func_name in MATRIX_METHODS
+        ):
+            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)
@@ -533,10 +1483,15 @@ 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)
-            spec = self._array_spec_for_name(namespace)
-            args = self._array_method_args(func_name, node.args, spec)
+        if (
+            namespace_spec is not None
+            and namespace_spec.kind == "array"
+            and func_name in ARRAY_METHODS
+        ):
+            arr = self._collection_receiver_expr(namespace)
+            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)
 
         # Array operations — emit proper C++ vector operations
@@ -559,10 +1514,15 @@ class CallVisitor:
                 elems = ", ".join(self._visit_expr(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 node.args:
-                arr = self._visit_expr(node.args[0])
-                spec = self._type_spec_from_expr(node.args[0])
-                rest = self._array_method_args(func_name, node.args[1:], spec)
+            if func_name in ARRAY_METHODS and (
+                node.args or node.kwargs or func_name == "copy"
+            ):
+                all_nodes = self._array_function_arg_nodes(func_name, node)
+                if not all_nodes:
+                    return "0"
+                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 "0"
 
@@ -1017,14 +1977,16 @@ class CallVisitor:
                     if not isinstance(node.args[0], _Ident):
                         self._codegen_error(node, f"matrix.{func_name} receiver must be a variable reference")
                     recv_name = node.args[0].name
-                    if recv_name not in self._matrix_specs:
+                    recv_spec = self._collection_spec_for_name(recv_name)
+                    if recv_spec is None or recv_spec.kind != "matrix":
                         self._codegen_error(node, f"matrix.{func_name}: receiver '{recv_name}' is not a known matrix variable")
-                    self._check_matrix_method_allowed(func_name, self._matrix_specs[recv_name], node)
+                    self._check_matrix_method_allowed(func_name, recv_spec, node)
                 if func_name == "sort":
                     if isinstance(node.args[0], _Ident):
                         recv_name = node.args[0].name
-                        if recv_name in self._matrix_specs:
-                            self._check_matrix_method_allowed(func_name, self._matrix_specs[recv_name], node)
+                        recv_spec = self._collection_spec_for_name(recv_name)
+                        if recv_spec is not None and recv_spec.kind == "matrix":
+                            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:
@@ -1071,21 +2033,21 @@ class CallVisitor:
         if namespace in self._udt_defs and func_name == "new":
             fields = self._udt_defs[namespace]
             field_names = [f.name for f in fields]
-            init_vals = {}
+            init_nodes = {}
             for i, a in enumerate(node.args):
                 if i < len(field_names):
-                    init_vals[field_names[i]] = self._visit_expr(a)
+                    init_nodes[field_names[i]] = a
             for k, v in node.kwargs.items():
-                init_vals[k] = self._visit_expr(v)
+                init_nodes[k] = v
             field_inits = []
             field_specs = self._udt_field_type_specs.get(namespace, {})
             for f in fields:
-                val = None
-                if f.name in init_vals:
-                    val = init_vals[f.name]
+                value_node = None
+                if f.name in init_nodes:
+                    value_node = init_nodes[f.name]
                 elif f.default:
-                    val = self._visit_expr(f.default)
-                if val is not None:
+                    value_node = f.default
+                if value_node is not None:
                     # 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
@@ -1094,24 +2056,40 @@ class CallVisitor:
                     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":
                         f_cpp_type = "int64_t"
+                    val = self._visit_rhs_value(
+                        value_node,
+                        target_cpp_type=(
+                            f_cpp_type
+                            if (self._is_nullable_collection_cpp_type(f_cpp_type)
+                                or f_cpp_type in self._udt_defs
+                                or f_cpp_type in DRAWING_TYPE_TO_CPP.values())
+                            else None
+                        ),
+                    )
                     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})"
+                    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}")
-            # Mark the constructed object non-na (the struct's ``__pf_na`` is the
-            # last declared field, so this designator stays in declaration order).
-            # A bare default-constructed UDT keeps ``__pf_na = true`` (na); only a
-            # real ``.new(...)`` flips it false so ``na(obj)`` reports correctly.
-            field_inits.append(".__pf_na = false")
-            return f"{namespace}{{{', '.join(field_inits)}}}"
+            return self._emit_udt_new_expr(namespace, field_inits)
 
         # UDT copy: TypeName.copy(obj)
         if namespace in self._udt_defs and func_name == "copy":
-            if node.args:
-                return self._visit_expr(node.args[0])
-            return f"{namespace}{{}}"
+            if len(node.args) != 1 or node.kwargs:
+                self._codegen_error(
+                    node,
+                    f"{namespace}.copy(...) expects exactly one object argument",
+                    hint="Prefer the canonical object.copy() form.",
+                )
+            self._reject_unsupported_udt_copy(namespace, node)
+            return self._emit_udt_copy_expr(
+                namespace,
+                self._visit_expr(node.args[0]),
+            )
 
         # Safety net before the generic emitter. Every builtin namespace and
         # bare builtin that codegen knows how to emit has been dispatched (and
@@ -1162,33 +2140,96 @@ 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:
-                if isinstance(arg_node, Identifier):
+                expected_cpp_type = self._series_param_element_cpp_type(
+                    fi_lookup,
+                    arg_idx,
+                    self._callable_target_callsite_idx(fi_lookup, node),
+                )
+                chart_execution_context = (
+                    id(node) not in self._requested_context_inline_node_ids
+                    and (
+                        getattr(self, "_active_func_name", None),
+                        self._current_instance_name,
+                    ) not in self._requested_context_only_inline_contexts
+                )
+                if not chart_execution_context and isinstance(arg_node, Identifier):
+                    # request.security/request.security_lower_tf own a separate
+                    # evaluator clock and inline their UDF expressions in
+                    # security.py.  Preserve the pre-factor direct-Series
+                    # lowering in the otherwise-emitted helper bodies.
                     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:
+                    if (
+                        (aname in BAR_FIELDS or aname in BAR_SERIES_PUSH)
+                        and expected_cpp_type == "double"
+                    ):
                         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]
+                    safe = self._safe_name(aname)
+                    is_current_series_param = (
+                        aname in self._current_func_series_params
+                    )
+                    if (
+                        is_current_series_param
+                        and self._current_func_series_param_types.get(aname)
+                            == expected_cpp_type
+                    ):
+                        return safe
+                    if self._active_var_remap and safe in self._active_var_remap:
+                        safe = self._active_var_remap[safe]
+                    if (
+                        not is_current_series_param
+                        and self._binding_is_series(aname, safe)
+                        and self._series_type_for(aname)
+                            == expected_cpp_type
+                    ):
                         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"
+                cpp_t = expected_cpp_type
+                bridge_cpp = self._series_bridge_value_expr(
+                    expr_cpp, cpp_t
+                )
                 member = self._inline_history_member(
-                    "series_arg", node, arg_idx=arg_idx
+                    (
+                        "udf_series_arg"
+                        if chart_execution_context
+                        else "series_arg"
+                    ),
+                    node,
+                    arg_idx=arg_idx,
                 )
+                if not chart_execution_context:
+                    return (
+                        f"([&]() -> const Series<{cpp_t}>& {{ "
+                        f"{cpp_t} _sv = {bridge_cpp}; "
+                        f"if (history_advances_new_bar()) {member}.push(_sv); "
+                        f"else {member}.update(_sv); "
+                        f"return {member}; }}())"
+                    )
+                # A chart-executed plain UDF's history-reading parameter
+                # belongs to this lexical call site, not to the caller Series
+                # object.  The on_bar preamble has already advanced its
+                # synthetic buffer by one chart slot, so execution replaces
+                # that slot rather than pushing a second one.
                 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"{cpp_t} _sv = {bridge_cpp}; "
+                    f"{member}.update(_sv); "
                     f"return {member}; }}())"
                 )
+            # A concrete nullable collection specialization learned through an
+            # untyped wrapper chain also target-types its call arguments.
+            if fi_lookup is not None:
+                param_specs = getattr(fi_lookup, "param_type_specs", []) or []
+                if arg_idx < len(param_specs):
+                    param_spec = param_specs[arg_idx]
+                    if (param_spec is not None
+                            and param_spec.kind in {"map", "matrix"}):
+                        return self._visit_rhs_value(
+                            arg_node,
+                            target_cpp_type=self._type_spec_to_cpp(param_spec),
+                        )
             return self._visit_expr(arg_node)
 
+        ordered_arg_nodes: list = []
         if node.kwargs:
             # Try to resolve kwargs using FuncInfo params for user-defined functions
             fi = self._func_info_map.get(func_name)
@@ -1196,16 +2237,28 @@ class CallVisitor:
                 param_names = list(fi.node.params)  # params is list[str]
                 # Merge kwargs then visit with series awareness
                 merged = _merge_kwargs(node.args, node.kwargs, param_names, lambda a: a)
+                ordered_arg_nodes = list(merged)
                 all_args = [_visit_arg_for_series(a, i) for i, a in enumerate(merged)]
             elif sigs.is_intrinsic_function(namespace, func_name):
                 # Known intrinsic — use signature registry for kwargs resolution
                 param_names = sigs.get_param_names(namespace, func_name)
-                all_args = _merge_kwargs(node.args, node.kwargs, param_names, self._visit_expr)
+                merged = _merge_kwargs(
+                    node.args, node.kwargs, param_names, lambda a: a
+                )
+                ordered_arg_nodes = list(merged)
+                all_args = [self._visit_expr(a) for a in merged]
             else:
                 # Unknown function: positional args + kwargs values as fallback
-                all_args = [_visit_arg_for_series(a, i) for i, a in enumerate(node.args)]
-                all_args.extend(self._visit_expr(v) for v in node.kwargs.values())
+                ordered_arg_nodes = [*node.args, *node.kwargs.values()]
+                all_args = [
+                    _visit_arg_for_series(a, i)
+                    for i, a in enumerate(node.args)
+                ]
+                all_args.extend(
+                    self._visit_expr(v) for v in node.kwargs.values()
+                )
         else:
+            ordered_arg_nodes = list(node.args)
             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
@@ -1224,6 +2277,7 @@ class CallVisitor:
             if fi and fi.node and fi.name == "isInSession" and len(fi.node.params) >= 2 and len(all_args) == 1:
                 # Mirror Pine default `timeframe.period` instead of hard-coding 15m.
                 all_args.append("script_tf_")
+                ordered_arg_nodes.append(None)
         prefix = f"{namespace}::" if namespace else ""
         # Use safe name for user-defined functions to avoid member name collision
         emit_name = self._func_safe_name(func_name) if func_name in self._func_names else func_name
@@ -1253,7 +2307,15 @@ class CallVisitor:
             # Inside a per-call-site variant: propagate call-site index to
             # sub-functions that also have variants (for state isolation)
             emit_name = f"{self._func_safe_name(func_name)}_cs{self._active_call_site_idx}"
-        return f"{prefix}{emit_name}({', '.join(all_args)})"
+        call_head = f"{prefix}{emit_name}"
+        if namespace is None and func_name in self._func_names:
+            return self._ordered_user_call_expr(
+                call_head,
+                ordered_arg_nodes,
+                all_args,
+                source_order_nodes=[*node.args, *node.kwargs.values()],
+            )
+        return f"{call_head}({', '.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
@@ -1314,6 +2376,24 @@ class CallVisitor:
         x = self._visit_expr(node.args[0])
         return f"(is_na({x}) ? {member} : ({member} = {x}))"
 
+    @staticmethod
+    def _strategy_close_callsite_token(node: FuncCall) -> str:
+        """Return the stable runtime token for an authored close statement.
+
+        A generated strategy is compiled from one Pine source unit, so the
+        parser's 1-based line and column identify the syntactic callsite.  The
+        same inner UDF/loop node retains that location across every emitted or
+        runtime execution.  Zero is reserved for source-less synthetic calls
+        so existing compatibility behavior remains available.
+        """
+        loc = node.loc
+        if loc is None or loc.line <= 0 or loc.col <= 0:
+            return "0ULL"
+        token = ((int(loc.line) & 0xFFFFFFFF) << 32) | (
+            int(loc.col) & 0xFFFFFFFF
+        )
+        return f"{token}ULL"
+
     def _visit_strategy_call(self, func_name: str, node: FuncCall) -> str:
         if func_name in ("convert_to_account", "convert_to_symbol"):
             p = self._resolve_func_args(node, f"strategy.{func_name}")
@@ -1359,10 +2439,17 @@ class CallVisitor:
             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"
-            return f"strategy_close({close_id}, {comment}, {qty}, {qty_pct}, {immediately})"
+            callsite = self._strategy_close_callsite_token(node)
+            return f"strategy_close({close_id}, {comment}, {qty}, {qty_pct}, {immediately}, {callsite})"
 
         if func_name == "close_all":
-            return "strategy_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"
+            # 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.
+            return f'strategy_close("", {comment}, na<double>(), na<double>(), {immediately})'
 
         if func_name == "exit":
             p = self._resolve_func_args(node, "strategy.exit")