@pineforge/codegen-pyodide 0.8.0 → 0.9.0

package/pineforge_codegen/codegen/types.py

@@ -41,13 +41,33 @@ from ..ast_nodes import (
 from ..symbols import PineType, TypeSpec
 from .. import signatures as sigs
 from .tables import (
+    ARRAY_DRAWING_NEW_CTORS,
     ARRAY_METHODS,
     BAR_BUILTINS,
     BAR_FIELDS,
+    DRAWING_NS,
+    DRAWING_TYPE_TO_CPP,
     PINE_TYPE_TO_CPP,
     TA_RETURNS_BOOL,
 )
 
+# Collection (array / map / matrix) methods that MUTATE the receiver in place.
+# Used by the BUG-2 collection-lvalue-alias path to decide whether a local
+# bound to an existing collection lvalue must alias (mutated) or may value-copy
+# (read-only). A method missing here only costs the alias optimization; a
+# non-mutating method accidentally present would alias a read-only local, which
+# is still correct (reads through a reference equal reads through a copy).
+COLLECTION_MUTATING_METHODS = frozenset({
+    # array
+    "push", "unshift", "insert", "remove", "pop", "shift", "clear",
+    "set", "fill", "sort", "reverse", "concat",
+    # map
+    "put", "put_all",
+    # matrix
+    "add_row", "add_col", "remove_row", "remove_col", "reshape",
+    "swap_rows", "swap_columns",
+})
+
 
 class TypeInferer:
     """Type-spec / C++-type inference helpers shared across visitor mixins.
@@ -100,6 +120,12 @@ class TypeInferer:
                 return TypeSpec.map(key, val)
         if name in self._udt_defs:
             return TypeSpec.udt(name)
+        # Drawing-objects-as-data (spec §4.1 / P3): scalar ``line``/``box``/
+        # ``label``/``linefill``/``chart.point`` hints carry the handle identity
+        # via a udt TypeSpec. (``array<line>`` already resolves via the array
+        # fallback above.) Drawing names are NOT in _udt_defs.
+        if name in DRAWING_TYPE_TO_CPP:
+            return TypeSpec.udt(name)
         return None
 
     def _type_spec_to_cpp(self, spec: TypeSpec | None) -> str:
@@ -110,6 +136,11 @@ class TypeInferer:
             return {"float": "double", "int": "int", "bool": "bool",
                     "string": "std::string", "color": "int"}.get(spec.name or "float", "double")
         if spec.kind == "udt" and spec.name:
+            # Drawing handle structs (P1): map BEFORE the _udt_defs check so
+            # array<line> -> std::vector<Line> and scalar line -> Line instead
+            # of the old collapse to double / unknown-type-name.
+            if spec.name in DRAWING_TYPE_TO_CPP:
+                return DRAWING_TYPE_TO_CPP[spec.name]
             return spec.name if spec.name in self._udt_defs else "double"
         if spec.kind == "array":
             return f"std::vector<{self._type_spec_to_cpp(spec.element)}>"
@@ -143,6 +174,10 @@ class TypeInferer:
         UDTs would otherwise fall through to ``0`` which is type-incompatible.
         """
         if spec is not None and spec.kind == "udt" and spec.name:
+            # Drawing handle default (P2): brace-init the C++ struct name
+            # (Line{} = na handle), NOT the lowercase Pine name (line{}).
+            if spec.name in DRAWING_TYPE_TO_CPP:
+                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"):
@@ -175,10 +210,22 @@ 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])
             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
@@ -190,12 +237,27 @@ class TypeInferer:
             return None
         if isinstance(node, FuncCall):
             func_name, namespace = self._resolve_callee(node.callee)
+            # 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
+            # double then assigns a std::string. (Analyzer agrees: ticker.* -> STRING.)
+            if namespace == "ticker":
+                return TypeSpec.primitive("string")
             targs = self._template_args_from_call(node)
+            # Drawing-objects-as-data return typing (spec §4.5 DRAWING_RETURN_SPECS):
+            # *.new / *.copy -> handle of the self-type; linefill.get_line* -> line.
+            if namespace in DRAWING_NS:
+                if func_name in ("new", "copy"):
+                    return TypeSpec.udt(namespace)
+                if namespace == "linefill" and func_name in ("get_line1", "get_line2"):
+                    return TypeSpec.udt("line")
+            if self._is_chart_point_callee(node.callee):
+                return TypeSpec.udt("chart.point")
             if namespace == "str" and func_name == "split":
                 return TypeSpec.array(TypeSpec.primitive("string"))
             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):
                 if func_name == "new_int":
                     return TypeSpec.array(TypeSpec.primitive("int"))
                 if func_name == "new_bool":
@@ -204,6 +266,10 @@ class TypeInferer:
                     return TypeSpec.array(TypeSpec.primitive("string"))
                 if func_name == "new_float":
                     return TypeSpec.array(TypeSpec.primitive("float"))
+                if func_name in ARRAY_DRAWING_NEW_CTORS:
+                    # array.new_line()/new_box()/new_label()/new_linefill() ->
+                    # std::vector<Line/Box/Label/Linefill> (typed alias of new<T>).
+                    return TypeSpec.array(TypeSpec.udt(ARRAY_DRAWING_NEW_CTORS[func_name]))
                 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:
@@ -249,12 +315,58 @@ class TypeInferer:
                         return recv_spec.element
                     if func_name == "eigenvalues":
                         return TypeSpec.array(TypeSpec.primitive("float"))
+                # Drawing method-form: ``a.copy()`` -> same handle type;
+                # ``lf.get_line1()`` -> line. (L-N6 alias-vs-copy typing.)
+                if (recv_spec is not None and recv_spec.kind == "udt"
+                        and recv_spec.name in DRAWING_TYPE_TO_CPP):
+                    if func_name == "copy":
+                        return recv_spec
+                    if recv_spec.name == "linefill" and func_name in ("get_line1", "get_line2"):
+                        return TypeSpec.udt("line")
         return None
 
     # ------------------------------------------------------------------
     # Method lowering for collection types (used by visit_call paths)
     # ------------------------------------------------------------------
 
+    def _array_receiver_once_expr(
+        self, array_expr: str, args: list[str], lower_receiver,
+    ) -> str:
+        """Lower an array method without duplicating its receiver evaluation.
+
+        ``ARRAY_METHODS`` is intentionally a compact table of expression
+        templates.  Many templates need the receiver more than once (for
+        example ``begin()`` + ``end()``).  Substituting a temporary-producing
+        receiver directly into those slots creates distinct objects, so the
+        resulting iterator range is invalid.  Render first with a fresh token;
+        when the template uses it repeatedly and the real receiver is not a
+        plain identifier lvalue, bind it to one lambda-local forwarding
+        reference and render every use through that binding.  The lambda's
+        deduced ``auto`` return copies scalar results before a temporary
+        receiver dies; mutations still reach lvalue arrays through the
+        forwarding reference.  Single-use and plain-identifier lowerings
+        remain byte-for-byte unchanged.
+
+        This is receiver-only by design: Pine argument evaluation and the
+        separate empty-array semantics are outside this fix.
+        """
+        counter = getattr(self, "_array_receiver_counter", 0)
+        occupied = "\n".join((array_expr, *args))
+        while True:
+            receiver = f"__pf_array_receiver_{counter}"
+            counter += 1
+            if receiver not in occupied:
+                break
+        self._array_receiver_counter = counter
+
+        lowered = lower_receiver(receiver)
+        if lowered.count(receiver) <= 1 or array_expr.isidentifier():
+            return lower_receiver(array_expr)
+        return (
+            f"[&]() {{ auto&& {receiver} = ({array_expr}); "
+            f"return {lowered}; }}()"
+        )
+
     def _array_method_expr(
         self, array_expr: str, method: str, args: list[str], spec: TypeSpec | None = None,
     ) -> str:
@@ -263,34 +375,36 @@ class TypeInferer:
         arr_cpp_type = self._type_spec_to_cpp(spec)
         elem_cpp = self._type_spec_to_cpp(spec.element) if spec.element is not None else "double"
         if method == "copy":
-            return f"{arr_cpp_type}({array_expr})"
-        if method == "slice":
-            return f"{arr_cpp_type}({array_expr}.begin()+(int)({args[0]}),{array_expr}.begin()+(int)({args[1]}))"
-        if method == "join":
+            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]}))"
+        elif method == "join" and elem_cpp == "std::string":
             sep = args[0] if args else 'std::string(",")'
-            if elem_cpp == "std::string":
-                return f"[&](){{ std::string r; for(size_t i=0;i<{array_expr}.size();i++){{ if(i>0)r+={sep}; r+={array_expr}[i]; }} return r; }}()"
-        numeric_only = {
-            "sum", "avg", "min", "max", "range", "stdev", "variance", "median",
-            "mode", "percentile_linear_interpolation", "percentile_nearest_rank",
-            "percentrank", "abs", "standardize", "covariance", "binary_search",
-            "binary_search_leftmost", "binary_search_rightmost", "sort_indices",
-        }
-        if method in numeric_only and elem_cpp not in ("double", "int"):
-            self._codegen_error(
-                None,
-                f"array.{method} requires a numeric array",
-                hint="Use numeric arrays for aggregate/statistical array functions.",
-            )
-        if method in ARRAY_METHODS:
-            return ARRAY_METHODS[method](array_expr, args)
-        # Defensive: support_checker rejects any array.* method not in
-        # SUPPORTED_ARRAY (derived from ARRAY_METHODS). Reaching here means the
-        # checker was bypassed or the tables drifted.
-        raise ValueError(
-            f"codegen: unhandled array method '{method}' — analyzer should have "
-            f"rejected. Add it to ARRAY_METHODS."
-        )
+            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; }}()"
+        else:
+            numeric_only = {
+                "sum", "avg", "min", "max", "range", "stdev", "variance", "median",
+                "mode", "percentile_linear_interpolation", "percentile_nearest_rank",
+                "percentrank", "abs", "standardize", "covariance", "binary_search",
+                "binary_search_leftmost", "binary_search_rightmost", "sort_indices",
+            }
+            if method in numeric_only and elem_cpp not in ("double", "int"):
+                self._codegen_error(
+                    None,
+                    f"array.{method} requires a numeric array",
+                    hint="Use numeric arrays for aggregate/statistical array functions.",
+                )
+            if method not in ARRAY_METHODS:
+                # Defensive: support_checker rejects any array.* method not in
+                # SUPPORTED_ARRAY (derived from ARRAY_METHODS). Reaching here means the
+                # checker was bypassed or the tables drifted.
+                raise ValueError(
+                    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)
+
+        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,
@@ -345,6 +459,22 @@ class TypeInferer:
             if node.type_hint in self._udt_defs:
                 return node.type_hint
             return PINE_TYPE_TO_CPP.get(node.type_hint, "double")
+        # 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
+        # ``lvl.ln``, and ``c = a.copy()``. Also records _udt_var_types so later
+        # uses (``ln.set_x2(...)`` / ``ln.slope()``) resolve to the drawing udt.
+        if getattr(self, "_uses_drawing", False):
+            rhs_spec = self._type_spec_from_expr(node.value)
+            if (rhs_spec is not None and rhs_spec.kind == "udt"
+                    and rhs_spec.name in DRAWING_TYPE_TO_CPP):
+                self._udt_var_types.setdefault(node.name, rhs_spec.name)
+                return DRAWING_TYPE_TO_CPP[rhs_spec.name]
+            # Scalar drawing getter local (get_text -> std::string, etc.).
+            if isinstance(node.value, FuncCall):
+                _dret = self._drawing_call_return_cpp(node.value)
+                if _dret is not None:
+                    return _dret
         sym = self.ctx.symbols.resolve(node.name)
         if sym is not None:
             inferred = self._infer_type(node.value)
@@ -369,25 +499,290 @@ class TypeInferer:
             return PINE_TYPE_TO_CPP.get(sym.pine_type, "double")
         return "double"
 
+    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(...)``, …)
+        or a bare ``Identifier`` spelled like ``time`` / ``time_close`` /
+        ``timenow`` (which Pine exposes as a value, not a call)."""
+        from .tables import INT64_BUILTINS, INT64_BUILTIN_IDENTIFIERS
+        if expr is None:
+            return False
+        if isinstance(expr, FuncCall):
+            func_name, namespace = self._resolve_callee(expr.callee)
+            return namespace is None and func_name in INT64_BUILTINS
+        if isinstance(expr, Identifier):
+            return expr.name in INT64_BUILTIN_IDENTIFIERS
+        return False
+
+    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
+        instance. Pine ``int`` collapses these to 32-bit, but the runtime stores
+        the epoch in 64 bits, so the member must be promoted to ``int64_t``."""
+        cached = getattr(self, "_int64_reassign_cache", None)
+        if cached is not None:
+            return cached
+        from ..ast_nodes import Assignment
+        targets: set[str] = set()
+        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)):
+                    targets.add(node.target.name)
+        self._int64_reassign_cache = targets
+        return targets
+
     def _is_int64_builtin_init(self, name: str) -> bool:
-        """True if ``name``'s defining expression is a top-level call to a
-        Pine builtin that returns ``int64_t`` (``time``, ``time_close``,
-        ``timestamp``). The Pine type system collapses these to ``int``
-        but the engine encodes the ``na`` sentinel in the upper 32 bits,
-        so storing into ``Series<int>`` would silently corrupt na detection.
+        """True if ``name``'s initializer OR any ``:=``/``=`` reassignment has an
+        RHS that is a top-level int64-returning builtin (``time``, ``time_close``,
+        ``timenow``, ``timestamp``, ``time_tradingday``). The Pine type system
+        collapses these to ``int`` but the engine encodes the ``na`` sentinel
+        (and the full epoch-ms value, which overflows int32) in 64 bits, so
+        storing into ``int`` silently corrupts both the value and na detection.
+        A reassignment like ``var int entryTime = na`` then ``entryTime := time``
+        must promote even though the *initializer* alone is ``na``.
         """
-        from .tables import INT64_BUILTINS
         expr = (
             self.ctx.global_expr_map.get(name)
             or self.ctx.var_member_init_exprs.get(name)
         )
-        if expr is None:
-            return False
+        if self._expr_is_int64_builtin(expr):
+            return True
+        return name in self._int64_reassign_targets()
+
+    # ------------------------------------------------------------------
+    # 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):
-            func_name, namespace = self._resolve_callee(expr.callee)
-            if namespace is None and func_name in INT64_BUILTINS:
-                return True
-        return False
+            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
+    # ------------------------------------------------------------------
+
+    def _collection_lvalue_spec(self, expr):
+        """If ``expr`` is a bare ``Identifier`` naming an array/map/matrix
+        var/global member, return its ``TypeSpec``; else ``None``. Pine
+        collections are reference types, so a local bound to such an lvalue and
+        then mutated through must ALIAS it, not value-copy."""
+        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)
+        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):
+        """``TypeSpec`` if ``expr`` is a collection lvalue OR a ternary/switch
+        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."""
+        direct = self._collection_lvalue_spec(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
+        specs = [self._collection_lvalue_spec(b) for b in branches]
+        if any(s is None for s in specs):
+            return None
+        cpp_types = {self._type_spec_to_cpp(s) for s in specs}
+        if len(cpp_types) == 1:
+            return specs[0]
+        return None
+
+    def _collection_local_must_alias(self, node) -> bool:
+        """True when the local ``node`` declares an alias of an existing
+        collection lvalue that is later MUTATED in the enclosing function body
+        (``local.push/unshift/insert/remove/set/clear/pop/...``). A purely-read
+        local needn't alias; a local REASSIGNED to a different value can't be a
+        C++ reference, so it bails to value-copy (returns ``False``)."""
+        from ..ast_nodes import Assignment
+        body = getattr(self, "_current_func_body", None)
+        if body is None:
+            return False
+        name = node.name
+        mutated = False
+        for stmt in self._walk_ast_list(body):
+            # Rebind of the local itself (``orderBlocks := other``) — a C++
+            # reference cannot rebind, so keep value-copy semantics.
+            if (isinstance(stmt, Assignment)
+                    and isinstance(stmt.target, Identifier)
+                    and stmt.target.name == name):
+                return False
+            if (isinstance(stmt, FuncCall)
+                    and isinstance(stmt.callee, MemberAccess)
+                    and isinstance(stmt.callee.object, Identifier)
+                    and stmt.callee.object.name == name
+                    and stmt.callee.member in COLLECTION_MUTATING_METHODS):
+                mutated = True
+        return mutated
+
+    def _walk_ast_list(self, stmts):
+        """Yield every node within a list of statements (depth-first)."""
+        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.
@@ -459,6 +854,8 @@ class TypeInferer:
                     return "double"
             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]
             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)
@@ -467,6 +864,12 @@ class TypeInferer:
             return "double"
         if isinstance(node, FuncCall):
             func_name, namespace = self._resolve_callee(node.callee)
+            # 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):
+                _dret = self._drawing_call_return_cpp(node)
+                if _dret is not None:
+                    return _dret
             if func_name in ("time", "time_close") and namespace is None and node.args:
                 return "int64_t"
             if func_name == "timestamp" and namespace is None:
@@ -491,6 +894,12 @@ class TypeInferer:
             if namespace == "str":
                 if func_name == "split":
                     return "std::vector<std::string>"
+                if func_name in ("contains", "startswith", "endswith"):
+                    return "bool"
+                if func_name == "tonumber":
+                    return "double"
+                if func_name in ("length", "pos"):
+                    return "int"
                 return "std::string"
             if namespace == "ta" and func_name == "pivot_point_levels":
                 return "std::vector<double>"
@@ -539,6 +948,12 @@ class TypeInferer:
             # pine_str_tostring); bare reads must declare std::string.
             if ename == "format":
                 return "std::string"
+            if ename == "timeframe":
+                if node.member in ("period", "main_period"):
+                    return "std::string"
+                if node.member == "multiplier":
+                    return "int"
+                return "bool"
             # syminfo.* type inference: look up in SYMINFO_MEMBER_MAP
             # and derive C++ type from the expression (na<T>() or function call).
             if ename == "syminfo":
@@ -546,6 +961,9 @@ class TypeInferer:
                 sym_key = f"syminfo.{node.member}"
                 if sym_key in _pf_sigs.SYMINFO_VARIABLES:
                     return PINE_TYPE_TO_CPP.get(_pf_sigs.SYMINFO_VARIABLES[sym_key], "double")
+            spec = self._type_spec_from_expr(node)
+            if spec is not None:
+                return self._type_spec_to_cpp(spec)
         if isinstance(node, Ternary):
             tt = self._infer_type(node.true_val)
             ft = self._infer_type(node.false_val)
@@ -553,6 +971,12 @@ class TypeInferer:
                 return tt if tt.startswith("std::vector") else ft
             if tt == "std::string" or ft == "std::string":
                 return "std::string"
+            if tt == "double" or ft == "double":
+                return "double"
+            if tt == "int64_t" or ft == "int64_t":
+                return "int64_t"
+            if tt == "bool" and ft == "bool":
+                return "bool"
             return tt
         # Block-as-expression cases: read the type of the last statement of
         # the first branch / case; matches Pine semantics for ``x = if...``.
@@ -575,16 +999,24 @@ class TypeInferer:
     def _infer_tuple_types(self, func_node: FuncDef, count: int) -> list[str]:
         """Infer the C++ type of each element returned by a tuple-returning function.
 
-        Builds a lightweight local-type map from the function's
-        ``VarDecl``s so identifiers referenced inside the final
-        ``[a, b, c]`` literal resolve precisely; falls back to
-        ``_infer_type`` when no local declaration matches."""
+        Builds a lightweight local-type map from the function's ``VarDecl``s
+        (including ones nested inside if/for/switch blocks) so identifiers
+        referenced inside the final ``[a, b, c]`` literal resolve precisely.
+        An explicit type hint wins (``string tag = na`` -> ``std::string``,
+        not the ``double`` implied by ``na``); otherwise the initializer
+        expression is inferred. Falls back to ``_infer_type`` when no local
+        declaration matches."""
         if not func_node.body:
             return ["double"] * count
 
         local_types: dict[str, str] = {}
-        for stmt in func_node.body:
-            if isinstance(stmt, VarDecl) and stmt.value is not None:
+        for stmt in self._walk_ast(func_node):
+            if isinstance(stmt, VarDecl) and stmt.value is not None and stmt.name:
+                if stmt.type_hint:
+                    spec = self._type_spec_from_hint_name(stmt.type_hint)
+                    if spec is not None:
+                        local_types[stmt.name] = self._type_spec_to_cpp(spec)
+                        continue
                 local_types[stmt.name] = self._infer_type(stmt.value)
 
         last_stmt = func_node.body[-1]