@pineforge/codegen-pyodide 0.10.0 → 0.10.2

package/pineforge_codegen/codegen/types.py

@@ -34,11 +34,11 @@ tables it needs come from ``codegen/tables.py``.
 from __future__ import annotations
 
 from ..ast_nodes import (
-    BinOp, BoolLiteral, ExprStmt, FuncCall, FuncDef, Identifier, IfStmt,
+    ASTNode, Assignment, BinOp, BoolLiteral, ExprStmt, FuncCall, FuncDef, Identifier, IfStmt,
     MemberAccess, NaLiteral, NumberLiteral, StringLiteral, SwitchStmt,
-    Ternary, TupleLiteral, UnaryOp, VarDecl,
+    Subscript, Ternary, TupleLiteral, UnaryOp, VarDecl,
 )
-from ..symbols import PineType, TypeSpec
+from ..symbols import PineType, TypeSpec, method_receiver_type_name
 from .. import signatures as sigs
 from .tables import (
     ARRAY_DRAWING_NEW_CTORS,
@@ -47,8 +47,10 @@ from .tables import (
     BAR_FIELDS,
     DRAWING_NS,
     DRAWING_TYPE_TO_CPP,
+    MATRIX_RETURNING_METHODS,
     PINE_TYPE_TO_CPP,
     TA_RETURNS_BOOL,
+    checked_array_slice,
 )
 
 # Collection (array / map / matrix) methods that MUTATE the receiver in place.
@@ -145,7 +147,7 @@ class TypeInferer:
         if spec.kind == "array":
             return f"std::vector<{self._type_spec_to_cpp(spec.element)}>"
         if spec.kind == "map":
-            return f"std::unordered_map<{self._type_spec_to_cpp(spec.key)}, {self._type_spec_to_cpp(spec.value)}>"
+            return f"PineMap<{self._type_spec_to_cpp(spec.key)}, {self._type_spec_to_cpp(spec.value)}>"
         if spec.kind == "matrix":
             elem = self._type_spec_to_cpp(spec.element)
             if spec.element.kind == "primitive" and spec.element.name == "float":
@@ -153,17 +155,97 @@ class TypeInferer:
             return f"PineGenericMatrix<{elem}>"
         return "double"
 
+    def _udt_record_cpp_type(self, type_name: str) -> str:
+        """Generated backing-record type for one user-defined object type."""
+        return getattr(self, "_udt_record_cpp_names", {}).get(
+            type_name, f"_PFUdtRecord_{type_name}"
+        )
+
+    def _udt_arena_member_name(self, type_name: str) -> str:
+        """Per-strategy arena member owning one user-defined object's records."""
+        return getattr(self, "_udt_arena_member_names", {}).get(
+            type_name, f"_pf_udt_{self._safe_name(type_name)}"
+        )
+
+    def _udt_arena_cpp_type(self, type_name: str) -> str:
+        """Generated arena specialization for one user-defined object type."""
+        return (
+            f"{getattr(self, '_udt_arena_template_cpp_name', '_PFUdtArena')}<"
+            f"{type_name}, "
+            f"{self._udt_record_cpp_type(type_name)}>"
+        )
+
+    def _checkpoint_traits_cpp_type(self) -> str:
+        """Collision-safe generated checkpoint trait template name."""
+        return getattr(
+            self, "_checkpoint_traits_cpp_name", "_PFCheckpointTraits"
+        )
+
+    def _udt_direct_array_fields(self, type_name: str) -> tuple[str, ...]:
+        """Direct array-valued fields whose UDT copy semantics are unsupported.
+
+        Maps, matrices, and nested UDTs are numeric/shared-ID handles, so an
+        outer record copy is correctly shallow. Arrays still lower directly to
+        ``std::vector<T>``; copying such a record would silently deep-copy the
+        vector and diverge from Pine object identity. Keep this boundary narrow
+        and explicit until arrays themselves have a handle representation.
+        """
+        return tuple(
+            field_name
+            for field_name, spec in self._udt_field_type_specs.get(
+                type_name, {}
+            ).items()
+            if spec is not None and spec.kind == "array"
+        )
+
+    def _reject_unsupported_udt_copy(self, type_name: str, node) -> None:
+        """Fail closed before copying a record with direct vector storage."""
+        fields = self._udt_direct_array_fields(type_name)
+        if not fields:
+            return
+        rendered = ", ".join(fields)
+        self._codegen_error(
+            node,
+            f"{type_name}.copy() is unsupported because direct array field(s) "
+            f"{rendered} still use value storage",
+            hint=(
+                "Move the array outside the UDT and store a supported shared-ID "
+                "map/matrix or nested UDT handle until array fields gain handle "
+                "identity."
+            ),
+        )
+
     @staticmethod
-    def _default_for_type(cpp_type: str) -> str:
+    def _is_nullable_collection_cpp_type(cpp_type: str | None) -> bool:
+        """Whether ``cpp_type`` has a default-constructed Pine ``na`` ID.
+
+        Arrays still lower to ``std::vector`` and cannot distinguish a null ID
+        from a valid empty array. Keep them outside this predicate until their
+        runtime representation carries that distinction.
+        """
+        return bool(
+            cpp_type
+            and (
+                cpp_type.startswith("PineMap<")
+                or cpp_type == "PineMatrix"
+                or cpp_type.startswith("PineGenericMatrix<")
+            )
+        )
+
+    def _default_for_type(self, cpp_type: str) -> str:
         """Default initialiser for a primitive C++ type (matches Pine ``na``)."""
         if cpp_type == "std::string":
             return 'std::string("")'
         if cpp_type == "bool":
             return "false"
-        if cpp_type == "int":
+        if cpp_type in ("int", "int64_t"):
             return "0"
-        if cpp_type.startswith("std::vector") or cpp_type.startswith("std::unordered_map"):
+        if cpp_type in DRAWING_TYPE_TO_CPP.values():
+            return f"{cpp_type}{{}}"
+        if cpp_type.startswith("std::vector") or cpp_type.startswith("PineMap"):
             return f"{cpp_type}()"
+        if self._is_nullable_collection_cpp_type(cpp_type):
+            return f"{cpp_type}{{}}"
         return "0.0"
 
     def _default_for_spec(self, spec: TypeSpec | None) -> str:
@@ -180,24 +262,217 @@ class TypeInferer:
                 return f"{DRAWING_TYPE_TO_CPP[spec.name]}{{}}"
             return f"{spec.name}{{}}"
         cpp_type = self._type_spec_to_cpp(spec)
-        if cpp_type.startswith("std::vector") or cpp_type.startswith("std::unordered_map"):
+        if cpp_type.startswith("std::vector") or cpp_type.startswith("PineMap"):
             return f"{cpp_type}()"
+        if self._is_nullable_collection_cpp_type(cpp_type):
+            return f"{cpp_type}{{}}"
         return self._default_for_type(cpp_type)
 
+    def _collection_spec_for_name(self, name: str) -> TypeSpec | None:
+        """Resolve collection metadata with lexical precedence.
+
+        Source-ordered callable locals shadow loop bindings and parameters once
+        their declaration has executed; before that point, loop/parameter
+        bindings shadow top-level/on_bar state. The process-wide raw-name maps
+        are retained for top-level compatibility, but no callable may infer a
+        collection kind from a same-named sibling callable.
+        """
+        local_specs = getattr(self, "_current_func_collection_specs", {})
+        if name in local_specs:
+            return local_specs[name]
+        # A scalar/UDT local still shadows a same-named top-level collection.
+        # Returning None is semantically different from "not found locally": it
+        # prevents legacy global kind registries from resurrecting the hidden
+        # binding during member dispatch or alias analysis.
+        if name in getattr(self, "_current_func_collection_shadows", set()):
+            return None
+        loop_specs = getattr(self, "_current_loop_var_specs", None)
+        if loop_specs and name in loop_specs:
+            return loop_specs[name]
+        if name in getattr(self, "_current_loop_vars", set()):
+            return None
+        param_specs = getattr(self, "_current_func_param_specs", {})
+        if name in param_specs:
+            param_spec = param_specs[name]
+            # Keep the established unresolved/untyped-parameter compatibility
+            # route: scalar TypeSpecs inferred only from a call site did not
+            # historically mask a same-named top-level collection registry.
+            # Declared scalar/UDT parameters do shadow it, while inferred or
+            # declared collection parameters always carry their exact kind.
+            if (param_spec.kind in {"array", "map", "matrix", "udt"}
+                    or name in getattr(
+                        self, "_current_func_declared_param_names", set()
+                    )):
+                return param_spec
+        # During callable emission this is the copy-on-write lexical overlay;
+        # outside a callable it is the live top-level registry, including
+        # aliases discovered by codegen after construction.
+        return self._collection_types.get(name)
+
+    def _collection_name_is_lexically_shadowed(self, name: str) -> bool:
+        """Whether ``name`` is bound in the active callable/block scope.
+
+        A ``None`` collection lookup alone cannot distinguish a real scalar or
+        UDT tombstone from an absent name.  Callers that otherwise fall back to
+        the analyzer's popped symbol table use this predicate to avoid
+        resurrecting a hidden top-level collection. Untyped parameters retain
+        their established compatibility path and are intentionally not tested
+        here.
+        """
+        if name in getattr(self, "_current_loop_vars", set()):
+            return True
+        if name in getattr(self, "_current_func_collection_specs", {}):
+            return True
+        return name in getattr(self, "_current_func_collection_shadows", set())
+
+    def _activate_callable_collection_binding(
+        self, name: str, spec: TypeSpec | None
+    ) -> None:
+        """Install one callable-local binding after its declaration RHS.
+
+        Every raw kind marker is removed first. A collection installs its exact
+        TypeSpec; a scalar/UDT leaves a tombstone in the lexical shadow set.
+        Function and block entry already established copy-on-write state, so
+        this mutation is restored at the appropriate lexical boundary.
+        """
+        self._array_vars.discard(name)
+        self._map_vars.discard(name)
+        self._matrix_specs.pop(name, None)
+        self._current_func_collection_specs.pop(name, None)
+        self._collection_types.pop(name, None)
+        self._current_func_collection_shadows.add(name)
+        if spec is None or spec.kind not in {"array", "map", "matrix"}:
+            return
+        self._current_func_collection_specs[name] = spec
+        self._collection_types[name] = spec
+        if spec.kind == "array":
+            self._array_vars.add(name)
+        elif spec.kind == "map":
+            self._map_vars.add(name)
+        else:
+            self._matrix_specs[name] = spec
+
+    def _collection_receiver_expr(self, name: str) -> str:
+        """C++ receiver for an active collection identifier."""
+        pending = getattr(self, "_pending_decl_outer_alias", {})
+        if name in pending:
+            return pending[name]
+        safe = self._safe_name(name)
+        owner = getattr(self, "_active_func_name", None)
+        exact = (
+            self._func_var_storage_name(owner, name)
+            if owner is not None
+            else name
+        )
+        # Once an exact callable-local collection declaration has become
+        # lexically active, its per-written-callsite variant must read the
+        # same cloned member that its declaration-site initializer wrote.
+        # Before the declaration, ``_current_func_collection_specs`` has no
+        # entry, so an inherited same-named global still resolves normally.
+        if (
+            name in getattr(self, "_current_func_collection_specs", {})
+            and safe in self._active_var_remap
+        ):
+            return self._active_var_remap[safe]
+        # Preserve byte-identical output for every non-qualified callable.  A
+        # qualified persistent array becomes visible through the raw lexical
+        # spelling only after its VarDecl installs this active remap.
+        if exact != name:
+            return self._active_var_remap.get(safe, safe)
+        return safe
+
     def _array_spec_for_name(self, name: str) -> TypeSpec:
         """Spec for ``array<...>`` variable ``name`` (falls back to array<float>)."""
-        spec = self._collection_types.get(name)
+        spec = self._collection_spec_for_name(name)
         if spec is not None and spec.kind == "array":
             return spec
         return TypeSpec.array(TypeSpec.primitive("float"))
 
     def _map_spec_for_name(self, name: str) -> TypeSpec:
         """Spec for ``map<...>`` variable ``name`` (falls back to map<string, float>)."""
-        spec = self._collection_types.get(name)
+        spec = self._collection_spec_for_name(name)
         if spec is not None and spec.kind == "map":
             return spec
         return TypeSpec.map(TypeSpec.primitive("string"), TypeSpec.primitive("float"))
 
+    def _array_from_element_spec(self, node) -> TypeSpec | None:
+        """Exact scalar element spec used only by ``array.from`` lowering.
+
+        This intentionally does not make BinOp TypeSpecs globally visible:
+        doing so changes unrelated float-band comparator output.  Collection
+        construction needs the narrower fact so its vector type agrees with
+        the analyzer-captured declaration type, including lexical loop binders.
+        A primitive user-function result may have only the coarse ``PineType``
+        slot populated; recover that exact scalar here rather than silently
+        defaulting ``array.from(string_udf())`` to ``std::vector<double>``.
+        """
+        if isinstance(node, BinOp):
+            left = self._array_from_element_spec(node.left)
+            right = self._array_from_element_spec(node.right)
+            if node.op in ("==", "!=", ">", "<", ">=", "<=", "and", "or"):
+                return TypeSpec.primitive("bool")
+            if (left is not None and right is not None
+                    and left.kind == "primitive" and right.kind == "primitive"):
+                if left.name == "string" or right.name == "string":
+                    return TypeSpec.primitive("string")
+                if node.op == "/" or left.name == "float" or right.name == "float":
+                    return TypeSpec.primitive("float")
+                if left.name == "int" and right.name == "int":
+                    return TypeSpec.primitive("int")
+            return None
+        spec = self._type_spec_from_expr(node)
+        if spec is not None:
+            return spec
+        if isinstance(node, FuncCall):
+            func_name, namespace = self._resolve_callee(node.callee)
+            if namespace is None:
+                func_info = self._func_info_map.get(func_name)
+                pine_type = getattr(func_info, "return_type", None)
+                primitive_name = {
+                    PineType.INT: "int",
+                    PineType.FLOAT: "float",
+                    PineType.BOOL: "bool",
+                    PineType.STRING: "string",
+                    PineType.COLOR: "color",
+                }.get(pine_type)
+                if primitive_name is not None:
+                    return TypeSpec.primitive(primitive_name)
+        return None
+
+    @staticmethod
+    def _selection_terminal_expr(body: list[ASTNode] | None) -> ASTNode | None:
+        """Return one if/switch branch's value expression, if present."""
+        if not body:
+            return None
+        terminal = body[-1]
+        return terminal.expr if isinstance(terminal, ExprStmt) else terminal
+
+    @staticmethod
+    def _selection_node_is_na(node: ASTNode | None) -> bool:
+        """Whether a selection arm is explicit or implicit Pine ``na``."""
+        return (
+            node is None
+            or isinstance(node, NaLiteral)
+            or (isinstance(node, Identifier) and node.name == "na")
+        )
+
+    def _nullable_collection_selection_spec(
+        self,
+        branches: list[tuple[ASTNode | None, TypeSpec | None]],
+    ) -> TypeSpec | None:
+        """Unify compatible map/matrix selection arms around typed ``na``."""
+        concrete: list[TypeSpec] = []
+        for node, spec in branches:
+            if self._selection_node_is_na(node):
+                continue
+            if spec is None or spec.kind not in {"map", "matrix"}:
+                return None
+            concrete.append(spec)
+        if not concrete:
+            return None
+        first = concrete[0]
+        return first if all(spec == first for spec in concrete[1:]) else None
+
     def _type_spec_from_expr(self, node) -> TypeSpec | None:
         """Best-effort TypeSpec inference for an expression node.
 
@@ -210,26 +485,139 @@ class TypeInferer:
         if isinstance(node, StringLiteral):
             return TypeSpec.primitive("string")
         if isinstance(node, Identifier):
-            loop_specs = getattr(self, "_current_loop_var_specs", None)
-            if loop_specs and node.name in loop_specs:
-                return loop_specs[node.name]
-            if node.name in self._collection_types:
-                return self._collection_types[node.name]
-            param_specs = getattr(self, "_current_func_param_specs", {})
-            if node.name in param_specs:
-                return param_specs[node.name]
-            if node.name in self._udt_var_types:
-                return TypeSpec.udt(self._udt_var_types[node.name])
-            # Drawing-typed method/function parameter (L.6d / U.5): a ``line ln``
-            # method receiver registers in _udt_param_udt so its body getters
-            # resolve to the drawing udt and dispatch through the §4.3 path.
-            _pu = getattr(self, "_udt_param_udt", None)
-            if _pu and node.name in _pu and _pu[node.name] in DRAWING_TYPE_TO_CPP:
-                return TypeSpec.udt(_pu[node.name])
+            # An active lexical UDT/drawing binding must beat a same-spelled
+            # top-level primitive or collection.  This is intentionally the
+            # exact lexical prefix of _identifier_udt_binding(), not its raw-
+            # name fallback: method receivers such as ``line ln`` otherwise
+            # inherit an unrelated global ``ln`` before dispatch is resolved.
+            lexical_drawing = getattr(self, "_lexical_drawing_types", {})
+            drawing_cpp = lexical_drawing.get(node.name)
+            if drawing_cpp is not None:
+                for pine_name, cpp_name in DRAWING_TYPE_TO_CPP.items():
+                    if cpp_name == drawing_cpp:
+                        return TypeSpec.udt(pine_name)
+            lexical_udts = getattr(self, "_lexical_udt_types", {})
+            lexical_udt = lexical_udts.get(node.name)
+            if lexical_udt in self._udt_defs:
+                return TypeSpec.udt(lexical_udt)
+            collection_spec = self._collection_spec_for_name(node.name)
+            # This resolver also carries exact primitive loop/parameter/global
+            # metadata despite its historical name.  Preserve those scalar
+            # families here (notably bool for array.from); only arbitrary UDTs
+            # need the collision-safe lexical resolver below.
+            if (collection_spec is not None
+                    and collection_spec.kind != "udt"):
+                return collection_spec
+            found_udt_binding, exact_udt = self._identifier_udt_binding(
+                node.name
+            )
+            if found_udt_binding:
+                return (
+                    TypeSpec.udt(exact_udt)
+                    if exact_udt is not None
+                    else None
+                )
+            if self._collection_name_is_lexically_shadowed(node.name):
+                return None
             sym = self.ctx.symbols.resolve(node.name)
-            if sym is not None and getattr(sym, "type_spec", None) is not None:
-                return sym.type_spec
+            if sym is not None:
+                if getattr(sym, "type_spec", None) is not None:
+                    return sym.type_spec
+                primitive_name = {
+                    PineType.INT: "int",
+                    PineType.FLOAT: "float",
+                    PineType.BOOL: "bool",
+                    PineType.STRING: "string",
+                    PineType.COLOR: "color",
+                }.get(sym.pine_type)
+                if primitive_name is not None:
+                    return TypeSpec.primitive(primitive_name)
+            return None
+        if isinstance(node, Subscript):
+            # History access preserves the scalar drawing-handle type.  This
+            # is intentionally not generalized to arrays/maps: their
+            # subscripting rules are handled by the collection paths below.
+            receiver_spec = self._type_spec_from_expr(node.object)
+            if (receiver_spec is not None
+                    and receiver_spec.kind == "udt"
+                    and receiver_spec.name in DRAWING_TYPE_TO_CPP):
+                return receiver_spec
+            return None
+        if isinstance(node, Ternary):
+            true_spec = self._type_spec_from_expr(node.true_val)
+            false_spec = self._type_spec_from_expr(node.false_val)
+            collection_spec = self._nullable_collection_selection_spec([
+                (node.true_val, true_spec),
+                (node.false_val, false_spec),
+            ])
+            if collection_spec is not None:
+                return collection_spec
+            if true_spec is not None and true_spec == false_spec:
+                return true_spec
+            if (true_spec is not None
+                    and true_spec.kind == "udt"
+                    and true_spec.name in DRAWING_TYPE_TO_CPP
+                    and isinstance(node.false_val, NaLiteral)):
+                return true_spec
+            if (false_spec is not None
+                    and false_spec.kind == "udt"
+                    and false_spec.name in DRAWING_TYPE_TO_CPP
+                    and isinstance(node.true_val, NaLiteral)):
+                return false_spec
             return None
+        if isinstance(node, IfStmt):
+            true_node = self._selection_terminal_expr(node.body)
+            false_node = self._selection_terminal_expr(node.else_body)
+            true_spec = self._type_spec_from_expr(true_node)
+            false_spec = self._type_spec_from_expr(false_node)
+            collection_spec = self._nullable_collection_selection_spec([
+                (true_node, true_spec),
+                (false_node, false_spec),
+            ])
+            if collection_spec is not None:
+                return collection_spec
+            true_is_na = (
+                isinstance(true_node, NaLiteral)
+                or (isinstance(true_node, Identifier)
+                    and true_node.name == "na")
+            )
+            false_is_na = (
+                isinstance(false_node, NaLiteral)
+                or (isinstance(false_node, Identifier)
+                    and false_node.name == "na")
+            )
+            if (true_spec is not None
+                    and true_spec.kind == "udt"
+                    and true_spec.name in DRAWING_TYPE_TO_CPP
+                    and true_spec == false_spec):
+                return true_spec
+            if (true_spec is not None
+                    and true_spec.kind == "udt"
+                    and true_spec.name in DRAWING_TYPE_TO_CPP
+                    and false_is_na):
+                return true_spec
+            if (false_spec is not None
+                    and false_spec.kind == "udt"
+                    and false_spec.name in DRAWING_TYPE_TO_CPP
+                    and true_is_na):
+                return false_spec
+            return None
+        if isinstance(node, SwitchStmt):
+            branches: list[tuple[ASTNode | None, TypeSpec | None]] = []
+            for _case_expr, case_body in node.cases:
+                terminal = self._selection_terminal_expr(case_body)
+                branches.append((
+                    terminal,
+                    self._type_spec_from_expr(terminal),
+                ))
+            default_terminal = self._selection_terminal_expr(
+                node.default_body
+            )
+            branches.append((
+                default_terminal,
+                self._type_spec_from_expr(default_terminal),
+            ))
+            return self._nullable_collection_selection_spec(branches)
         if isinstance(node, MemberAccess):
             owner = self._type_spec_from_expr(node.object)
             if owner is not None and owner.kind == "udt" and owner.name:
@@ -237,6 +625,73 @@ class TypeInferer:
             return None
         if isinstance(node, FuncCall):
             func_name, namespace = self._resolve_callee(node.callee)
+            if namespace is None:
+                func_info = self._func_info_map.get(func_name)
+                return_spec = getattr(func_info, "return_type_spec", None)
+                if return_spec is not None:
+                    return return_spec
+                udt_return = getattr(func_info, "udt_return_type", None)
+                if (udt_return in DRAWING_TYPE_TO_CPP
+                        or udt_return in self._udt_defs):
+                    return TypeSpec.udt(udt_return)
+            if isinstance(node.callee, MemberAccess):
+                receiver_spec = self._type_spec_from_expr(
+                    node.callee.object
+                )
+                receiver_name = method_receiver_type_name(receiver_spec)
+                method_info = (
+                    getattr(self, "_func_info_map", {}).get(
+                        f"{receiver_name}.{node.callee.member}"
+                    )
+                    if receiver_name is not None
+                    else None
+                )
+                if (
+                    method_info is not None
+                    and getattr(method_info, "is_udt_method", False)
+                ):
+                    return_spec = getattr(
+                        method_info, "return_type_spec", None
+                    )
+                    if return_spec is not None:
+                        return return_spec
+                    udt_return = getattr(
+                        method_info, "udt_return_type", None
+                    )
+                    if (
+                        udt_return in DRAWING_TYPE_TO_CPP
+                        or udt_return in self._udt_defs
+                    ):
+                        return TypeSpec.udt(udt_return)
+                    call_site_idx = self._callable_target_callsite_idx(
+                        method_info,
+                        node,
+                    )
+                    return_pine_type = (
+                        self._callsite_callable_return_pine_type(
+                            method_info,
+                            call_site_idx,
+                        )
+                    )
+                    primitive_name = {
+                        PineType.INT: "int",
+                        PineType.FLOAT: "float",
+                        PineType.BOOL: "bool",
+                        PineType.STRING: "string",
+                        PineType.COLOR: "color",
+                    }.get(return_pine_type)
+                    return (
+                        TypeSpec.primitive(primitive_name)
+                        if primitive_name is not None
+                        else None
+                    )
+                if (
+                    receiver_spec is not None
+                    and receiver_spec.kind == "udt"
+                    and receiver_spec.name in self._udt_defs
+                    and node.callee.member == "copy"
+                ):
+                    return receiver_spec
             # ticker.* constructors (inherit/standard/heikinashi) return a symbol
             # string; without this the member-type inference defaults to double
             # and a ``haTicker = ticker.heikinashi(...)`` global mis-declares as
@@ -255,6 +710,13 @@ class TypeInferer:
                 return TypeSpec.udt("chart.point")
             if namespace == "str" and func_name == "split":
                 return TypeSpec.array(TypeSpec.primitive("string"))
+            if namespace == "matrix" and func_name == "new":
+                elem = (
+                    self._type_spec_from_hint_name(targs[0])
+                    if targs
+                    else TypeSpec.primitive("float")
+                )
+                return TypeSpec.matrix(elem or TypeSpec.primitive("float"))
             if namespace == "array" and func_name in (
                 "new", "new_float", "new_int", "new_bool", "new_string", "from",
             ) or (namespace == "array" and func_name in ARRAY_DRAWING_NEW_CTORS):
@@ -273,41 +735,93 @@ class TypeInferer:
                 if targs:
                     return TypeSpec.array(self._type_spec_from_hint_name(targs[0]) or TypeSpec.udt(targs[0]))
                 if func_name == "from" and node.args:
-                    return TypeSpec.array(self._type_spec_from_expr(node.args[0]) or TypeSpec.primitive("float"))
+                    return TypeSpec.array(
+                        self._array_from_element_spec(node.args[0])
+                        or TypeSpec.primitive("float")
+                    )
                 return TypeSpec.array(TypeSpec.primitive("float"))
             # Functional-form array element/copy accessors: the receiver is
             # the first argument (``array.copy(arr)``), mirroring the
             # method-form handling below (``arr.copy()``).
-            if (namespace == "array" and node.args
+            if (namespace == "array"
                     and func_name in ("copy", "slice", "get", "first", "last",
                                       "pop", "shift", "remove")):
-                arg_spec = self._type_spec_from_expr(node.args[0])
+                receiver_node = node.args[0] if node.args else node.kwargs.get("id")
+                arg_spec = self._type_spec_from_expr(receiver_node)
                 if arg_spec is not None and arg_spec.kind == "array":
                     if func_name in ("copy", "slice"):
                         return arg_spec
                     return arg_spec.element
+            if namespace == "matrix" and func_name in MATRIX_RETURNING_METHODS:
+                receiver_node = node.args[0] if node.args else node.kwargs.get("id")
+                receiver_spec = self._type_spec_from_expr(receiver_node)
+                if receiver_spec is not None and receiver_spec.kind == "matrix":
+                    return receiver_spec
             if namespace == "map" and func_name == "new":
                 key = self._type_spec_from_hint_name(targs[0]) if len(targs) > 0 else TypeSpec.primitive("string")
                 val = self._type_spec_from_hint_name(targs[1]) if len(targs) > 1 else TypeSpec.primitive("float")
                 return TypeSpec.map(key or TypeSpec.primitive("string"), val or TypeSpec.primitive("float"))
-            if namespace in self._udt_defs and func_name == "new":
+            if namespace == "map" and func_name in {
+                "put", "get", "remove", "contains", "size", "keys",
+                "values", "copy", "put_all", "clear",
+            } and node.args:
+                receiver_spec = self._type_spec_from_expr(node.args[0])
+                if receiver_spec is not None and receiver_spec.kind == "map":
+                    if func_name in ("put", "get", "remove"):
+                        return receiver_spec.value
+                    if func_name == "keys":
+                        return TypeSpec.array(
+                            receiver_spec.key or TypeSpec.primitive("string")
+                        )
+                    if func_name == "values":
+                        return TypeSpec.array(
+                            receiver_spec.value or TypeSpec.primitive("float")
+                        )
+                    if func_name == "copy":
+                        return receiver_spec
+                    if func_name == "contains":
+                        return TypeSpec.primitive("bool")
+                    if func_name == "size":
+                        return TypeSpec.primitive("int")
+            if namespace in self._udt_defs and func_name in {"new", "copy"}:
                 return TypeSpec.udt(namespace)
             if isinstance(node.callee, MemberAccess):
                 recv_spec = self._type_spec_from_expr(node.callee.object)
+                member_name = node.callee.member
                 if recv_spec is not None and recv_spec.kind == "array":
-                    if func_name in ("get", "first", "last", "pop", "shift", "remove"):
+                    if member_name in (
+                        "get", "first", "last", "pop", "shift", "remove",
+                    ):
                         return recv_spec.element
-                    if func_name in ("copy", "slice"):
+                    if member_name in ("copy", "slice"):
                         return recv_spec
                 if recv_spec is not None and recv_spec.kind == "map":
-                    if func_name in ("get", "remove"):
+                    if member_name in ("put", "get", "remove"):
                         return recv_spec.value
-                    if func_name == "keys":
+                    if member_name == "keys":
                         return TypeSpec.array(recv_spec.key or TypeSpec.primitive("string"))
-                    if func_name == "values":
+                    if member_name == "values":
                         return TypeSpec.array(recv_spec.value or TypeSpec.primitive("float"))
+                    if member_name == "copy":
+                        return recv_spec
+                    if member_name == "contains":
+                        return TypeSpec.primitive("bool")
+                    if member_name == "size":
+                        return TypeSpec.primitive("int")
+                receiver_name = method_receiver_type_name(recv_spec)
+                if receiver_name is not None:
+                    method_info = getattr(
+                        self, "_func_info_map", {}
+                    ).get(
+                        f"{receiver_name}.{member_name}"
+                    )
+                    return_spec = getattr(
+                        method_info, "return_type_spec", None
+                    )
+                    if return_spec is not None:
+                        return return_spec
                 if recv_spec is not None and recv_spec.kind == "matrix":
-                    if func_name in ("copy", "submatrix", "transpose", "concat"):
+                    if func_name in MATRIX_RETURNING_METHODS:
                         return recv_spec
                     if func_name in ("row", "col"):
                         return TypeSpec.array(recv_spec.element)
@@ -325,6 +839,76 @@ class TypeInferer:
                         return TypeSpec.udt("line")
         return None
 
+    def _identifier_udt_binding(
+        self, name: str
+    ) -> tuple[bool, str | None]:
+        """Return ``(binding_known, exact_udt_or_none)`` for ``name``.
+
+        ``ctx.udt_var_types`` is a legacy raw-name registry: a declaration in
+        an unrelated callable can overwrite the type of a same-named global.
+        Every correctness-sensitive consumer must prefer the active lexical
+        binding (including scalar tombstones), then exact parameter/local and
+        direct-program metadata, before consulting that registry.
+        """
+        known_udts = set(self._udt_defs) | set(DRAWING_TYPE_TO_CPP)
+
+        lexical_drawing = getattr(self, "_lexical_drawing_types", {})
+        if name in lexical_drawing and lexical_drawing[name] is not None:
+            cpp_type = lexical_drawing[name]
+            for pine_name, candidate_cpp in DRAWING_TYPE_TO_CPP.items():
+                if candidate_cpp == cpp_type:
+                    return True, pine_name
+
+        lexical = getattr(self, "_lexical_udt_types", {})
+        if name in lexical:
+            candidate = lexical[name]
+            return True, candidate if candidate in known_udts else None
+
+        param_specs = getattr(self, "_current_func_param_specs", {})
+        param_spec = param_specs.get(name) or param_specs.get(
+            self._safe_name(name)
+        )
+        if (param_spec is not None
+                and param_spec.kind == "udt"
+                and param_spec.name in known_udts):
+            return True, param_spec.name
+        param_types = getattr(self, "_current_func_param_types", {})
+        if name in param_types or self._safe_name(name) in param_types:
+            return True, None
+
+        local_types = getattr(self, "_current_func_local_types", {})
+        if name in local_types:
+            local_cpp = local_types[name]
+            candidate = local_cpp.removesuffix("&").removesuffix("*")
+            return True, candidate if candidate in known_udts else None
+
+        param_udts = getattr(self, "_udt_param_udt", {})
+        candidate = param_udts.get(name) or param_udts.get(
+            self._safe_name(name)
+        )
+        if candidate in known_udts:
+            return True, candidate
+
+        global_types = getattr(self, "_global_udt_types", {})
+        if name in global_types:
+            candidate = global_types[name]
+            return True, candidate if candidate in known_udts else None
+
+        member_resolver = getattr(self, "_member_udt_type", None)
+        candidate = (
+            member_resolver(name)
+            if callable(member_resolver)
+            else self._udt_var_types.get(name)
+        )
+        if candidate is not None:
+            return True, candidate if candidate in known_udts else None
+        return False, None
+
+    def _identifier_udt_type(self, name: str) -> str | None:
+        """Exact UDT type for ``name``; scalar tombstones return ``None``."""
+        _found, udt_type = self._identifier_udt_binding(name)
+        return udt_type
+
     # ------------------------------------------------------------------
     # Method lowering for collection types (used by visit_call paths)
     # ------------------------------------------------------------------
@@ -377,7 +961,11 @@ class TypeInferer:
         if method == "copy":
             lower_receiver = lambda recv: f"{arr_cpp_type}({recv})"
         elif method == "slice":
-            lower_receiver = lambda recv: f"{arr_cpp_type}({recv}.begin()+(int)({args[0]}),{recv}.begin()+(int)({args[1]}))"
+            # Bounds-checked in the shared helper; the element type stays
+            # caller-supplied so the typed lane keeps its own vector type.
+            lower_receiver = lambda recv: checked_array_slice(
+                recv, args, result_type=arr_cpp_type
+            )
         elif method == "join" and elem_cpp == "std::string":
             sep = args[0] if args else 'std::string(",")'
             lower_receiver = lambda recv: f"[&](){{ std::string r; for(size_t i=0;i<{recv}.size();i++){{ if(i>0)r+={sep}; r+={recv}[i]; }} return r; }}()"
@@ -402,42 +990,77 @@ class TypeInferer:
                     f"codegen: unhandled array method '{method}' — analyzer should have "
                     f"rejected. Add it to ARRAY_METHODS."
                 )
-            lower_receiver = lambda recv: ARRAY_METHODS[method](recv, args)
+            # Pine evaluates call arguments before entering the array
+            # calculation, even when an empty receiver makes the result ``na``.
+            # The empty guards in these methods must therefore consume a
+            # one-evaluation binding rather than leaving the original argument
+            # expression after the guard.  Build the binding into
+            # ``lower_receiver`` so a temporary receiver is still evaluated
+            # first by ``_array_receiver_once_expr``.
+            eager_scalar_arg_methods = {
+                "stdev": (0,),
+                "variance": (0,),
+                "percentile_linear_interpolation": (0,),
+                "percentile_nearest_rank": (0,),
+            }
+            bound_args = list(args)
+            arg_bindings: list[tuple[str, str]] = []
+            occupied = "\n".join((array_expr, *args))
+            counter = getattr(self, "_array_arg_counter", 0)
+            for arg_index in eager_scalar_arg_methods.get(method, ()):
+                if arg_index >= len(args):
+                    continue
+                while True:
+                    token = f"__pf_array_arg_{counter}"
+                    counter += 1
+                    if token not in occupied:
+                        break
+                bound_args[arg_index] = token
+                arg_bindings.append((token, args[arg_index]))
+            self._array_arg_counter = counter
+
+            def lower_receiver(recv: str) -> str:
+                lowered = ARRAY_METHODS[method](recv, bound_args)
+                for token, original in reversed(arg_bindings):
+                    lowered = (
+                        f"[&](){{ auto {token}=({original}); "
+                        f"return {lowered}; }}()"
+                    )
+                return lowered
 
         return self._array_receiver_once_expr(array_expr, args, lower_receiver)
 
     def _map_method_expr(
         self, map_expr: str, method: str, args: list[str], spec: TypeSpec | None = None,
     ) -> str:
-        """Lower ``map.method(...)`` to its C++ form using the receiver's spec for default-key/value typing."""
-        spec = spec or TypeSpec.map(TypeSpec.primitive("string"), TypeSpec.primitive("float"))
-        key_cpp = self._type_spec_to_cpp(spec.key)
-        value_cpp = self._type_spec_to_cpp(spec.value)
-        map_cpp = self._type_spec_to_cpp(spec)
-        default_value = (
-            'std::string("")' if value_cpp == "std::string"
-            else ("false" if value_cpp == "bool" else self._default_for_type(value_cpp))
-        )
+        """Lower a Pine map operation to the ordered, alias-preserving runtime.
+
+        ``PineMap`` owns all missing-value, insertion-order and explicit-copy
+        semantics.  Keeping this lowering as a direct method delegation also
+        guarantees that each receiver and argument expression occurs exactly
+        once; the typed-parameter lane may still wrap arguments to impose
+        Pine's source evaluation order.
+        """
         if method == "put":
-            return f"({map_expr}[{args[0]}] = {args[1]})"
+            return f"{map_expr}.put({args[0]}, {args[1]})"
         if method == "get":
-            return f"({map_expr}.count({args[0]}) ? {map_expr}[{args[0]}] : {default_value})"
+            return f"{map_expr}.get({args[0]})"
         if method == "remove":
-            return f"[&](){{ auto it={map_expr}.find({args[0]}); if(it!={map_expr}.end()){{ auto v=it->second; {map_expr}.erase(it); return v; }} return {default_value}; }}()"
+            return f"{map_expr}.remove({args[0]})"
         if method == "contains":
-            return f"({map_expr}.count({args[0]}) > 0)"
+            return f"{map_expr}.contains({args[0]})"
         if method == "size":
-            return f"(double){map_expr}.size()"
+            return f"{map_expr}.size()"
         if method == "clear":
             return f"{map_expr}.clear()"
         if method == "keys":
-            return f"[&](){{ std::vector<{key_cpp}> v; for(auto& p:{map_expr}) v.push_back(p.first); return v; }}()"
+            return f"{map_expr}.keys()"
         if method == "values":
-            return f"[&](){{ std::vector<{value_cpp}> v; for(auto& p:{map_expr}) v.push_back(p.second); return v; }}()"
+            return f"{map_expr}.values()"
         if method == "copy":
-            return f"{map_cpp}({map_expr})"
+            return f"{map_expr}.copy()"
         if method == "put_all":
-            return f"{map_expr}.insert({args[0]}.begin(), {args[0]}.end())"
+            return f"{map_expr}.put_all({args[0]})"
         # Defensive: support_checker rejects any map.* method not in SUPPORTED_MAP
         # (derived from MAP_METHODS, which mirrors this if-chain). Reaching here
         # means the checker was bypassed or the tables drifted.
@@ -452,13 +1075,39 @@ class TypeInferer:
 
     def _type_for_decl(self, node: VarDecl) -> str:
         """Determine the C++ type for a ``VarDecl``: explicit hint, then symbol, then RHS inference."""
+        def promote_wide_int(cpp_type: str) -> str:
+            if cpp_type != "int":
+                return cpp_type
+            owner = self._func_info_map.get(
+                getattr(self, "_active_func_name", "") or ""
+            )
+            if self._expr_returns_wide_int(
+                node.value,
+                owner,
+                set(),
+                getattr(self, "_active_call_site_idx", None),
+            ) or self._is_int64_builtin_init(node.name):
+                return "int64_t"
+            return cpp_type
+
         if node.type_hint:
             spec = self._type_spec_from_hint_name(node.type_hint)
             if spec is not None:
-                return self._type_spec_to_cpp(spec)
+                return promote_wide_int(self._type_spec_to_cpp(spec))
             if node.type_hint in self._udt_defs:
                 return node.type_hint
-            return PINE_TYPE_TO_CPP.get(node.type_hint, "double")
+            return promote_wide_int(
+                PINE_TYPE_TO_CPP.get(node.type_hint, "double")
+            )
+        # The analyzer records exact callable-local collection bindings before
+        # its lexical scopes are popped.  In particular, an inferred local
+        # such as ``selected = cond ? na : global_map`` has a map TypeSpec even
+        # though generic C++ expression inference sees ``na`` as ``double``.
+        # Consume nullable map/matrix forms here. Arrays still lack a runtime
+        # null-ID representation and retain their established inference path.
+        captured = self._callable_collection_bindings.get(id(node))
+        if captured is not None and captured.kind in {"map", "matrix"}:
+            return self._type_spec_to_cpp(captured)
         # Drawing handle local (L-N6): a hintless local whose RHS resolves to a
         # drawing udt must declare as the handle struct, not the analyzer's
         # scalar default. Covers ``ln = arr.get(i)``, alias ``b = a``, field read
@@ -475,6 +1124,12 @@ class TypeInferer:
                 _dret = self._drawing_call_return_cpp(node.value)
                 if _dret is not None:
                     return _dret
+        # Analyzer scopes are popped before codegen, so ctx.symbols.resolve may
+        # find a same-named global instead of this active callable's plain
+        # local.  The local binding is known from the emitted body inventory;
+        # infer it from its own RHS rather than borrowing the global's PineType.
+        if node.name in getattr(self, "_current_func_locals", set()):
+            return promote_wide_int(self._infer_type(node.value))
         sym = self.ctx.symbols.resolve(node.name)
         if sym is not None:
             inferred = self._infer_type(node.value)
@@ -482,8 +1137,8 @@ class TypeInferer:
                 return inferred
             cpp_type = PINE_TYPE_TO_CPP.get(sym.pine_type, "double")
             if cpp_type != "double" or sym.pine_type != PineType.UNKNOWN:
-                return cpp_type
-        return self._infer_type(node.value)
+                return promote_wide_int(cpp_type)
+        return promote_wide_int(self._infer_type(node.value))
 
     def _series_type_for(self, name: str) -> str:
         """C++ element type for a series variable's history buffer."""
@@ -499,6 +1154,323 @@ class TypeInferer:
             return PINE_TYPE_TO_CPP.get(sym.pine_type, "double")
         return "double"
 
+    def _series_param_element_cpp_type(
+        self,
+        func_info,
+        index: int,
+        call_site_idx: int | None = None,
+    ) -> str:
+        """Canonical element type for one history-referenced UDF parameter.
+
+        A Pine parameter used as ``src[n]`` is a typed time series, not an
+        implicitly-float series.  The old emitter hard-coded every such
+        parameter as ``Series<double>``.  That happened to work for price
+        sources, but rejected real ``series int``/``series bool`` bindings and
+        let synthetic-expression bridges conceal the same mismatch by
+        converting their values to double.
+
+        Pine ``int`` also carries epoch-millisecond builtins such as ``time``.
+        Use the codegen's existing wide integer representation at this
+        callable boundary so one declared ``int`` parameter can safely accept
+        both ``bar_index`` and timestamp values without narrowing.  Scalar
+        integer values are widened when a synthetic bridge is required.
+        """
+        declared_specs = list(
+            getattr(self.ctx, "func_declared_param_type_specs", {}).get(
+                func_info.name, ()
+            )
+        )
+        declared_spec = (
+            declared_specs[index] if index < len(declared_specs) else None
+        )
+        # A declared type is authoritative across every written call. Only a
+        # truly untyped slot may consult the per-callsite specialization map.
+        spec = declared_spec
+        if spec is not None and spec.kind == "primitive":
+            if spec.name == "int":
+                return "int64_t"
+            if spec.name == "bool":
+                return "bool"
+            if spec.name == "color":
+                return "int"
+            if spec.name == "float":
+                return "double"
+
+        if call_site_idx is not None:
+            variant = getattr(
+                self.ctx, "func_callsite_param_types", {}
+            ).get((func_info.name, call_site_idx))
+            pine_type = (
+                variant[index]
+                if variant is not None and index < len(variant)
+                else PineType.UNKNOWN
+            )
+            if pine_type == PineType.INT:
+                return "int64_t"
+            if pine_type == PineType.BOOL:
+                return "bool"
+            if pine_type == PineType.COLOR:
+                return "int"
+            if pine_type == PineType.FLOAT:
+                return "double"
+
+        specs = list(getattr(func_info, "param_type_specs", ()) or ())
+        spec = specs[index] if index < len(specs) else None
+        if spec is not None and spec.kind == "primitive":
+            if spec.name == "int":
+                return "int64_t"
+            if spec.name == "bool":
+                return "bool"
+            if spec.name == "color":
+                return "int"
+            if spec.name == "float":
+                return "double"
+        param_types = list(getattr(func_info, "param_types", ()) or ())
+        pine_type = param_types[index] if index < len(param_types) else None
+        if pine_type == PineType.INT:
+            return "int64_t"
+        if pine_type == PineType.BOOL:
+            return "bool"
+        if pine_type == PineType.COLOR:
+            return "int"
+        return "double"
+
+    def _callsite_callable_return_pine_type(
+        self, func_info, call_site_idx: int | None
+    ):
+        if call_site_idx is not None:
+            variant = getattr(
+                self.ctx, "func_callsite_return_types", {}
+            ).get((func_info.name, call_site_idx))
+            if variant is not None and variant != PineType.UNKNOWN:
+                return variant
+        return getattr(func_info, "return_type", PineType.UNKNOWN)
+
+    def _func_int_return_uses_wide_history(
+        self,
+        func_info,
+        seen: set[str] | None = None,
+        call_site_idx: int | None = None,
+    ) -> bool:
+        """Whether an integer callable must preserve the ``int64_t`` family.
+
+        History-referenced ``int`` parameters are one source of wide values,
+        but not the only one.  A parameterless helper can capture ``time[1]``
+        directly, and an otherwise-pure wrapper can return that helper.  The
+        analyzer's Pine-level return type is intentionally just ``INT`` in all
+        of those cases, so follow the terminal expression/call chain here to
+        prevent the C++ callable boundary from narrowing epoch milliseconds.
+        """
+        if self._callsite_callable_return_pine_type(
+            func_info, call_site_idx
+        ) != PineType.INT:
+            return False
+        node = getattr(func_info, "node", None)
+        if node is None:
+            return False
+
+        if seen is None:
+            seen = set()
+        func_name = getattr(func_info, "name", "")
+        if func_name in seen:
+            return False
+        seen = {*seen, func_name}
+
+        series_names = self.ctx.func_series_vars.get(func_info.name, set())
+        if any(
+            param in series_names
+            and self._series_param_element_cpp_type(
+                func_info, index, call_site_idx
+            )
+                == "int64_t"
+            for index, param in enumerate(node.params)
+        ):
+            return True
+
+        if not node.body:
+            return False
+        terminal = node.body[-1]
+        if isinstance(terminal, ExprStmt):
+            terminal = terminal.expr
+        return self._expr_returns_wide_int(
+            terminal, func_info, seen, call_site_idx
+        )
+
+    def _expr_returns_wide_int(
+        self,
+        expr,
+        owner_info,
+        seen: set[str],
+        call_site_idx: int | None = None,
+    ) -> bool:
+        """Trace wide integer provenance through a callable return expression."""
+        if expr is None:
+            return False
+        if isinstance(expr, Subscript):
+            return self._expr_returns_wide_int(
+                expr.object, owner_info, seen, call_site_idx
+            )
+        if isinstance(expr, Identifier):
+            # A terminal local can be a narrow-looking alias for ``time[1]``.
+            # Resolve its declaration inside this callable without consulting
+            # the already-popped analyzer scope.
+            node = getattr(owner_info, "node", None)
+            if node is not None:
+                if expr.name in node.params:
+                    return False
+                local_key = (
+                    f"{getattr(owner_info, 'name', '')}:local:{expr.name}"
+                )
+                if local_key in seen:
+                    return False
+                local_seen = {*seen, local_key}
+                for child in self._walk_ast_list(node.body):
+                    if (
+                        isinstance(child, VarDecl)
+                        and child.name == expr.name
+                        and child.value is not None
+                    ):
+                        if self._expr_returns_wide_int(
+                            child.value,
+                            owner_info,
+                            local_seen,
+                            call_site_idx,
+                        ):
+                            return True
+                    if (
+                        isinstance(child, Assignment)
+                        and isinstance(child.target, Identifier)
+                        and child.target.name == expr.name
+                    ):
+                        if self._expr_returns_wide_int(
+                            child.value,
+                            owner_info,
+                            local_seen,
+                            call_site_idx,
+                        ):
+                            return True
+            return self._expr_is_int64_builtin(expr)
+        if self._expr_is_int64_builtin(expr):
+            return True
+        if isinstance(expr, FuncCall):
+            func_name, namespace = self._resolve_callee(expr.callee)
+            if namespace is None and func_name in {
+                "int",
+                "float",
+                "nz",
+                "fixnan",
+            }:
+                # Casts and Pine's missing-value wrappers preserve the wide
+                # integer provenance needed by an int destination. ``nz`` may
+                # obtain it from either the source or replacement argument.
+                return any(
+                    self._expr_returns_wide_int(
+                        arg, owner_info, seen, call_site_idx
+                    )
+                    for arg in expr.args
+                )
+            if namespace == "math" and func_name in {"abs", "max", "min"}:
+                return any(
+                    self._expr_returns_wide_int(
+                        arg, owner_info, seen, call_site_idx
+                    )
+                    for arg in expr.args
+                )
+
+            callee_info = None
+            if namespace is None and func_name:
+                callee_info = self._func_info_map.get(func_name)
+            elif isinstance(expr.callee, MemberAccess):
+                receiver = expr.callee.object
+                owner_node = getattr(owner_info, "node", None)
+                if (
+                    getattr(owner_info, "is_udt_method", False)
+                    and owner_node is not None
+                    and owner_node.params
+                    and isinstance(receiver, Identifier)
+                    and receiver.name == owner_node.params[0]
+                ):
+                    receiver_specs = list(
+                        getattr(owner_info, "param_type_specs", ()) or ()
+                    )
+                    receiver_name = method_receiver_type_name(
+                        receiver_specs[0] if receiver_specs else None
+                    ) or getattr(owner_info, "udt_type_name", None)
+                    if receiver_name is not None:
+                        callee_info = self._func_info_map.get(
+                            f"{receiver_name}.{expr.callee.member}"
+                        )
+                if callee_info is None:
+                    receiver_spec = self._type_spec_from_expr(receiver)
+                    receiver_name = method_receiver_type_name(
+                        receiver_spec
+                    )
+                    if receiver_name is not None:
+                        callee_info = self._func_info_map.get(
+                            f"{receiver_name}.{expr.callee.member}"
+                        )
+            return (
+                callee_info is not None
+                and self._func_int_return_uses_wide_history(
+                    callee_info,
+                    seen,
+                    call_site_idx=call_site_idx,
+                )
+            )
+        if isinstance(expr, BinOp):
+            return (
+                self._expr_returns_wide_int(
+                    expr.left, owner_info, seen, call_site_idx
+                )
+                or self._expr_returns_wide_int(
+                    expr.right, owner_info, seen, call_site_idx
+                )
+            )
+        if isinstance(expr, UnaryOp):
+            return self._expr_returns_wide_int(
+                expr.operand, owner_info, seen, call_site_idx
+            )
+        if isinstance(expr, Ternary):
+            return (
+                self._expr_returns_wide_int(
+                    expr.true_val, owner_info, seen, call_site_idx
+                )
+                or self._expr_returns_wide_int(
+                    expr.false_val, owner_info, seen, call_site_idx
+                )
+            )
+        if isinstance(expr, IfStmt):
+            branches = [expr.body, expr.else_body]
+            return any(
+                branch
+                and self._expr_returns_wide_int(
+                    branch[-1].expr
+                    if isinstance(branch[-1], ExprStmt)
+                    else branch[-1],
+                    owner_info,
+                    seen,
+                    call_site_idx,
+                )
+                for branch in branches
+            )
+        if isinstance(expr, SwitchStmt):
+            branches = [body for _, body in expr.cases]
+            if expr.default_body:
+                branches.append(expr.default_body)
+            return any(
+                branch
+                and self._expr_returns_wide_int(
+                    branch[-1].expr
+                    if isinstance(branch[-1], ExprStmt)
+                    else branch[-1],
+                    owner_info,
+                    seen,
+                    call_site_idx,
+                )
+                for branch in branches
+            )
+        return False
+
     def _expr_is_int64_builtin(self, expr) -> bool:
         """True if ``expr`` is a top-level int64-returning Pine builtin: either a
         call to one of ``INT64_BUILTINS`` (``time(...)``, ``timestamp(...)``, …)
@@ -514,6 +1486,28 @@ class TypeInferer:
             return expr.name in INT64_BUILTIN_IDENTIFIERS
         return False
 
+    def _fixnan_site_cpp_type(self, site) -> str:
+        """Storage type for one fixnan previous-value slot.
+
+        ``PineType.INT`` does not distinguish ordinary counters from epoch
+        milliseconds, but fixnan stores the exact prior value. Inspect the
+        authored argument's wide provenance so the state member cannot narrow
+        ``time[1]`` before an otherwise-int64 local receives it.
+        """
+        cpp_type = PINE_TYPE_TO_CPP.get(site.pine_type, "double")
+        if site.pine_type != PineType.INT:
+            return cpp_type
+        node = getattr(site, "node", None)
+        args = getattr(node, "args", ()) if node is not None else ()
+        owner_info = self._func_info_map.get(
+            getattr(site, "owner_func", None) or ""
+        )
+        if args and self._expr_returns_wide_int(
+            args[0], owner_info, set(), None
+        ):
+            return "int64_t"
+        return cpp_type
+
     def _int64_reassign_targets(self) -> set[str]:
         """Names of vars that are reassigned (``:=``/``=``) anywhere in the AST
         with an RHS that is a top-level int64-returning builtin. Cached on the
@@ -522,14 +1516,31 @@ class TypeInferer:
         cached = getattr(self, "_int64_reassign_cache", None)
         if cached is not None:
             return cached
-        from ..ast_nodes import Assignment
         targets: set[str] = set()
+        # Callable locals need their lexical owner so a reassignment through a
+        # wrapper/method returning wide history is recognized as well as a
+        # direct ``time[1]`` RHS.
+        for info in getattr(self.ctx, "func_infos", ()):
+            node = getattr(info, "node", None)
+            if node is None:
+                continue
+            for child in self._walk_ast_list(node.body):
+                if (
+                    isinstance(child, Assignment)
+                    and isinstance(child.target, Identifier)
+                    and self._expr_returns_wide_int(
+                        child.value, info, set(), None
+                    )
+                ):
+                    targets.add(child.target.name)
         ast = getattr(self.ctx, "ast", None)
         if ast is not None:
             for node in self._walk_ast(ast):
                 if (isinstance(node, Assignment)
                         and isinstance(node.target, Identifier)
-                        and self._expr_is_int64_builtin(node.value)):
+                        and self._expr_returns_wide_int(
+                            node.value, None, set(), None
+                        )):
                     targets.add(node.target.name)
         self._int64_reassign_cache = targets
         return targets
@@ -566,12 +1577,15 @@ class TypeInferer:
         for ``double`` (already the default lowering), so those paths are
         unchanged.
         """
-        # Collections / UDT / drawing handles never take a scalar ``na<T>()``:
-        # leave them to the drawing-na / default lowering in _visit_rhs_value.
-        if (name in self._array_vars
-                or name in self._map_vars
-                or name in getattr(self, "_matrix_specs", {})
-                or name in self._udt_var_types):
+        # Maps and matrices use their default-constructed null ID for Pine
+        # ``na``. Arrays still lack a nullable runtime representation.
+        collection_spec = self._collection_spec_for_name(name)
+        if (collection_spec is not None
+                and collection_spec.kind in {"map", "matrix"}):
+            return self._type_spec_to_cpp(collection_spec)
+        if ((collection_spec is not None
+                and collection_spec.kind == "array")
+                or self._identifier_udt_type(name) is not None):
             return None
         cpp_type: str | None = None
         # 1. ``var`` member (class-scope OR function-local: both are recorded in
@@ -605,134 +1619,6 @@ class TypeInferer:
             return cpp_type
         return None
 
-    # ------------------------------------------------------------------
-    # BUG C: user-defined-UDT lvalue aliasing
-    # ------------------------------------------------------------------
-
-    def _is_udt_lvalue(self, expr) -> str | None:
-        """If ``expr`` is a *user-defined* UDT lvalue (a bare ``Identifier`` that
-        names a class-scope ``var``/global UDT member, e.g. ``wyckoffSwingLow``,
-        or an element selected from ``array<UDT>``), return its UDT type name;
-        else ``None``.
-
-        Pine UDTs are reference types, so a local initialised from such an lvalue
-        and then mutated through must write back to the global. Drawing UDTs are
-        handled by the separate ``_uses_drawing`` path and are excluded here."""
-        if isinstance(expr, FuncCall):
-            callee = expr.callee
-            func_name, namespace = self._resolve_callee(callee)
-            receiver = None
-            if namespace == "array" and func_name in ("get", "first", "last") and expr.args:
-                receiver = expr.args[0]
-            elif (isinstance(callee, MemberAccess)
-                  and func_name in ("get", "first", "last")):
-                receiver = callee.object
-            if receiver is not None:
-                spec = self._type_spec_from_expr(receiver)
-                elem = spec.element if spec is not None and spec.kind == "array" else None
-                if (elem is not None and elem.kind == "udt" and elem.name in self._udt_defs
-                        and elem.name not in DRAWING_TYPE_TO_CPP):
-                    return elem.name
-            return None
-        if not isinstance(expr, Identifier):
-            return None
-        udt_t = self._udt_var_types.get(expr.name)
-        if udt_t is None or udt_t not in self._udt_defs:
-            return None
-        if udt_t in DRAWING_TYPE_TO_CPP:
-            return None
-        # Must be a known global/class-scope member (not a function param or a
-        # plain local snapshot) for write-through to be observable.
-        if expr.name in getattr(self, "_current_func_locals", set()):
-            # A function-local of UDT type that is itself a persistent ``var``
-            # member still write-through aliases; but a plain inline local does
-            # not represent shared state. Only treat ``var`` func-locals (in
-            # func_var_members) as aliasable shared state.
-            fname = getattr(self, "_active_func_name", None)
-            var_locals = {n for n, _, _ in self.ctx.func_var_members.get(fname, [])} if fname else set()
-            if expr.name not in var_locals:
-                return None
-        return udt_t
-
-    def _udt_lvalue_selection_type(self, expr) -> str | None:
-        """UDT type if ``expr`` is a UDT lvalue OR a ternary/switch whose every
-        selectable branch is a UDT lvalue of the SAME user-defined UDT type.
-        Returns ``None`` otherwise (so plain ``UDT a = b`` value-snapshots, calls,
-        ``.new(...)`` ctors, and mixed/non-lvalue selections never alias)."""
-        direct = self._is_udt_lvalue(expr)
-        if direct is not None:
-            return direct
-        branches: list = []
-        if isinstance(expr, Ternary):
-            branches = [expr.true_val, expr.false_val]
-        elif isinstance(expr, SwitchStmt):
-            for _case_expr, stmts in (expr.cases or []):
-                if not stmts:
-                    return None
-                last = stmts[-1]
-                branches.append(last.expr if isinstance(last, ExprStmt) else last)
-            if expr.default_body:
-                last = expr.default_body[-1]
-                branches.append(last.expr if isinstance(last, ExprStmt) else last)
-        else:
-            return None
-        if not branches:
-            return None
-        types = {self._is_udt_lvalue(b) for b in branches}
-        if len(types) == 1 and None not in types:
-            return next(iter(types))
-        return None
-
-    def _udt_local_alias_kind(self, node: VarDecl) -> tuple[str, str] | None:
-        """Decide whether a hintless/typed local UDT declaration must ALIAS the
-        global(s) it selects rather than value-copy (BUG C).
-
-        Returns ``("ref", udt_type)`` for a non-rebinding reference alias,
-        ``("ptr", udt_type)`` for a pointer alias (the local is later reassigned
-        to a *different* UDT lvalue, which a C++ reference cannot do), or
-        ``None`` to keep the existing value-copy semantics.
-
-        Conditions (all required):
-          * RHS is a UDT lvalue or a ternary/switch selecting same-typed UDT
-            lvalues (``_udt_lvalue_selection_type``).
-          * The local is MUTATED later in the enclosing function body
-            (``local.field := ...``) — a pure read-only snapshot needn't alias.
-
-        The mutation requirement is the safety guard: a local that is only read
-        keeps value semantics, and a local initialised from a non-lvalue (a
-        ``.new()`` ctor, a function return, or a plain local copy) returns
-        ``None`` here, preserving intentional independent-copy semantics."""
-        from ..ast_nodes import Assignment
-        body = getattr(self, "_current_func_body", None)
-        if body is None:
-            return None
-        udt_t = self._udt_lvalue_selection_type(node.value)
-        if udt_t is None:
-            return None
-        name = node.name
-        mutated = False
-        rebinds_to_other_lvalue = False
-        for stmt in self._walk_ast_list(body):
-            if not isinstance(stmt, Assignment):
-                continue
-            tgt = stmt.target
-            # Mutation through the local: ``p.field := ...``
-            if (isinstance(tgt, MemberAccess)
-                    and isinstance(tgt.object, Identifier)
-                    and tgt.object.name == name):
-                mutated = True
-            # Rebind of the local itself to another UDT lvalue: ``p := other``
-            elif isinstance(tgt, Identifier) and tgt.name == name:
-                if self._udt_lvalue_selection_type(stmt.value) is not None:
-                    rebinds_to_other_lvalue = True
-                else:
-                    # Reassigned to a non-lvalue (e.g. ``.new()`` / a copy):
-                    # aliasing would be wrong; bail to value-copy.
-                    return None
-        if not mutated:
-            return None
-        return ("ptr" if rebinds_to_other_lvalue else "ref"), udt_t
-
     # ------------------------------------------------------------------
     # BUG 2: collection (array / map / matrix) lvalue aliasing
     # ------------------------------------------------------------------
@@ -745,15 +1631,9 @@ class TypeInferer:
         if not isinstance(expr, Identifier):
             return None
         name = expr.name
-        if name in self._matrix_specs:
-            return self._matrix_specs[name]
-        spec = self._collection_types.get(name)
+        spec = self._collection_spec_for_name(name)
         if spec is not None and spec.kind in ("array", "map", "matrix"):
             return spec
-        if name in self._array_vars:
-            return self._array_spec_for_name(name)
-        if name in self._map_vars:
-            return self._map_spec_for_name(name)
         return None
 
     def _collection_lvalue_selection_spec(self, expr):
@@ -761,7 +1641,7 @@ class TypeInferer:
         whose every selectable branch is a collection lvalue of the SAME C++
         type; ``None`` otherwise (so ``array.new(...)`` ctors, copies, function
         returns, and mixed selections keep value-copy semantics). Mirrors
-        ``_udt_lvalue_selection_type`` for the BUG-2 collection-alias path."""
+        the former UDT alias-selection path."""
         direct = self._collection_lvalue_spec(expr)
         if direct is not None:
             return direct
@@ -821,22 +1701,6 @@ class TypeInferer:
         for s in stmts:
             yield from self._walk_ast(s)
 
-    def _addr_of_udt_selection(self, expr, local_name: str):
-        """Render the address-of form of a UDT lvalue selection for a pointer
-        alias (BUG C rebind case): ``other`` -> ``&(other)``;
-        ``cond ? a : b`` -> ``(cond ? &(a) : &(b))``. The selectable branches are
-        guaranteed (by ``_udt_lvalue_selection_type``) to be UDT lvalues."""
-        if isinstance(expr, Identifier):
-            return f"&({self._safe_name(expr.name)})"
-        if isinstance(expr, Ternary):
-            cond = self._visit_expr(expr.condition)
-            t = self._addr_of_udt_selection(expr.true_val, local_name)
-            f = self._addr_of_udt_selection(expr.false_val, local_name)
-            return f"({cond} ? {t} : {f})"
-        # Switch selection: lower to nested ternaries over case equality. Rare in
-        # practice; fall back to address-of the whole lowered expression.
-        return f"&({self._visit_expr(expr)})"
-
     def _infer_cpp_type_for_security_elem(self, node) -> str:
         """C++ type for one element of the ``request.security(..., expr, ...)`` payload.
 
@@ -882,6 +1746,10 @@ class TypeInferer:
         and ternaries / if / switch expressions. Returns the string
         ``"double"`` as the safe fallback when no narrower type can be
         determined."""
+        if isinstance(node, Subscript) and isinstance(node.object, FuncCall):
+            # A callable-result history read keeps the callable's scalar
+            # family. Collection subscripts follow separate element-type paths.
+            return self._infer_type(node.object)
         if isinstance(node, NumberLiteral):
             return "double" if isinstance(node.value, float) else "int"
         if isinstance(node, BoolLiteral):
@@ -895,7 +1763,8 @@ class TypeInferer:
                 return "int64_t"
             if node.name in BAR_FIELDS or node.name in BAR_BUILTINS:
                 return "double"
-            if node.name in self._known_vars:
+            if (node.name in self._known_vars
+                    and not self._known_var_is_lexically_shadowed(node.name)):
                 val = self._known_vars[node.name]
                 if isinstance(val, bool):
                     return "bool"
@@ -905,10 +1774,16 @@ class TypeInferer:
                     return "int"
                 if isinstance(val, float):
                     return "double"
+            if node.name in getattr(
+                self, "_current_func_series_param_types", {}
+            ):
+                return self._current_func_series_param_types[node.name]
             if node.name in self._current_func_param_types:
                 return self._current_func_param_types[node.name]
             if node.name in getattr(self, "_current_func_local_types", {}):
                 return self._current_func_local_types[node.name]
+            if node.name in getattr(self, "_current_loop_vars", set()):
+                return "double"
             sym = self.ctx.symbols.resolve(node.name)
             if sym is not None and getattr(sym, "type_spec", None) is not None:
                 return self._type_spec_to_cpp(sym.type_spec)
@@ -917,6 +1792,18 @@ class TypeInferer:
             return "double"
         if isinstance(node, FuncCall):
             func_name, namespace = self._resolve_callee(node.callee)
+            # Nested trade-accessor calls bypass the flat namespace signature
+            # table.  Their textual metadata accessors return std::string from
+            # the runtime, so hintless locals must not use the double fallback.
+            if (isinstance(node.callee, MemberAccess)
+                    and isinstance(node.callee.object, MemberAccess)
+                    and isinstance(node.callee.object.object, Identifier)
+                    and node.callee.object.object.name == "strategy"
+                    and node.callee.object.member in ("closedtrades", "opentrades")
+                    and func_name in (
+                        "entry_id", "exit_id", "entry_comment", "exit_comment",
+                    )):
+                return "std::string"
             # Drawing scalar getter return type (get_text -> std::string,
             # get_x* -> int64_t, get_y*/get_price/get_top/get_bottom -> double).
             if getattr(self, "_uses_drawing", False):
@@ -965,17 +1852,48 @@ class TypeInferer:
                 recv_spec = self._type_spec_from_expr(node.callee.object)
                 if recv_spec is not None and recv_spec.kind == "array" and member_name == "join":
                     return "std::string"
-                if recv_spec is not None and recv_spec.kind == "udt" and recv_spec.name:
-                    fi_u = self._func_info_map.get(f"{recv_spec.name}.{member_name}")
+                receiver_name = method_receiver_type_name(recv_spec)
+                if receiver_name is not None:
+                    fi_u = self._func_info_map.get(
+                        f"{receiver_name}.{member_name}"
+                    )
                     if fi_u is not None:
-                        return PINE_TYPE_TO_CPP.get(fi_u.return_type, "double")
+                        call_site_idx = self._callable_target_callsite_idx(
+                            fi_u, node
+                        )
+                        if self._func_int_return_uses_wide_history(
+                            fi_u, call_site_idx=call_site_idx
+                        ):
+                            return "int64_t"
+                        if getattr(fi_u, "return_type_spec", None) is not None:
+                            return self._type_spec_to_cpp(fi_u.return_type_spec)
+                        return PINE_TYPE_TO_CPP.get(
+                            self._callsite_callable_return_pine_type(
+                                fi_u, call_site_idx
+                            ),
+                            "double",
+                        )
+            if namespace is None and func_name in self._func_info_map:
+                fi_u = self._func_info_map[func_name]
+                call_site_idx = self._callable_target_callsite_idx(fi_u, node)
+                if self._func_int_return_uses_wide_history(
+                    fi_u, call_site_idx=call_site_idx
+                ):
+                    return "int64_t"
             spec = self._type_spec_from_expr(node)
             if spec is not None:
                 return self._type_spec_to_cpp(spec)
             if namespace in self._udt_defs and func_name == "new":
                 return namespace
             if namespace is None and func_name in self._func_info_map:
-                return PINE_TYPE_TO_CPP.get(self._func_info_map[func_name].return_type, "double")
+                fi_u = self._func_info_map[func_name]
+                return PINE_TYPE_TO_CPP.get(
+                    self._callsite_callable_return_pine_type(
+                        fi_u,
+                        self._callable_target_callsite_idx(fi_u, node),
+                    ),
+                    "double",
+                )
             site = self._get_ta_site(node)
             if site is not None:
                 ta_name = self._ta_name_from_site(site)
@@ -1018,6 +1936,11 @@ class TypeInferer:
             if spec is not None:
                 return self._type_spec_to_cpp(spec)
         if isinstance(node, Ternary):
+            ternary_spec = self._type_spec_from_expr(node)
+            if (ternary_spec is not None
+                    and ternary_spec.kind == "udt"
+                    and ternary_spec.name in DRAWING_TYPE_TO_CPP):
+                return self._type_spec_to_cpp(ternary_spec)
             tt = self._infer_type(node.true_val)
             ft = self._infer_type(node.false_val)
             if tt.startswith("std::vector") or ft.startswith("std::vector"):
@@ -1034,6 +1957,11 @@ class TypeInferer:
         # Block-as-expression cases: read the type of the last statement of
         # the first branch / case; matches Pine semantics for ``x = if...``.
         if isinstance(node, IfStmt):
+            block_spec = self._type_spec_from_expr(node)
+            if (block_spec is not None
+                    and block_spec.kind == "udt"
+                    and block_spec.name in DRAWING_TYPE_TO_CPP):
+                return self._type_spec_to_cpp(block_spec)
             if node.body:
                 last = node.body[-1]
                 if isinstance(last, ExprStmt):
@@ -1065,6 +1993,11 @@ class TypeInferer:
         local_types: dict[str, str] = {}
         for stmt in self._walk_ast(func_node):
             if isinstance(stmt, VarDecl) and stmt.value is not None and stmt.name:
+                captured = self._callable_collection_bindings.get(id(stmt))
+                if (captured is not None
+                        and captured.kind in {"array", "map", "matrix"}):
+                    local_types[stmt.name] = self._type_spec_to_cpp(captured)
+                    continue
                 if stmt.type_hint:
                     spec = self._type_spec_from_hint_name(stmt.type_hint)
                     if spec is not None: