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

package/pineforge_codegen/analyzer/base.py

@@ -29,6 +29,9 @@ from ..symbols import (
     method_receiver_type_name,
 )
 from ..errors import SourceLocation, Diagnostic, CompileError, Level, Phase
+from ..limits import TimeBudget, iter_ast_nodes
+from ..security_contexts import PASS_WARNINGS_ANNOTATION, context_key, reads_bar_series
+from ..session_reads import emitted_session_reads
 from ..method_binding import (
     BoundMethodArgs,
     MethodBindError,
@@ -124,9 +127,19 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
     the package layout.
     """
 
-    def __init__(self, ast: Program, filename: str = "<stdin>") -> None:
+    def __init__(self, ast: Program, filename: str = "<stdin>",
+                 budget: TimeBudget | None = None,
+                 session_clones: frozenset[str] | None = None) -> None:
         self._ast = ast
         self._filename = filename
+        self._budget = budget
+        # The functions that may be emitted once per call site for their
+        # session.<flag>[k] reads; None: every one that reads a flag at an
+        # offset (pineforge_codegen._generate passes none first, then each
+        # time adds the ones whose reads the C++ holds).
+        self._session_clones = session_clones
+        self._session_uncloned: frozenset[str] = frozenset()
+        self._budget_visit_count = 0
         self._method_signatures = inventory_method_signatures(ast)
         self._method_call_bindings: dict[
             tuple[int, str], BoundMethodArgs
@@ -142,7 +155,12 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         self._func_infos: list[FuncInfo] = []
         self._fixnan_sites: list[FixnanCallSite] = []
         self._strategy_params: dict = {}
-        self._diagnostics: list[Diagnostic] = []
+        # The warnings of the passes between the support checker and here,
+        # held on the Program as (message, hint, location).
+        self._diagnostics: list[Diagnostic] = [
+            Diagnostic(level=Level.WARNING, phase=Phase.ANALYZER, location=loc,
+                       message=message, hint=hint)
+            for message, hint, loc in (ast.annotations or {}).get(PASS_WARNINGS_ANNOTATION, ())]
         self._global_var_decls: list[tuple[str, PineType]] = []
         # Top-level ordinary bindings are lexical global state even when a
         # same-named callable history reference has already polluted the
@@ -231,6 +249,8 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         self._func_tuple_element_count: dict[str, int] = {}
         self._func_tuple_element_types: dict[str, tuple[PineType, ...]] = {}
         self._tuple_element_types_by_node: dict[int, tuple[PineType, ...]] = {}
+        # request.security call id -> its tuple's size (``call_handlers``).
+        self._security_tuple_shapes: dict[int, int] = {}
         # Track user-defined functions whose body returns a UDT instance —
         # maps func_name -> UDT type name. Detected from the body's final
         # expression (``=> Sample.new(...)`` or last stmt ``Sample.new(...)``).
@@ -282,6 +302,14 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         # their established paths.
         self._func_var_storage_names: dict[str, dict[str, str]] = {}
         self._func_series_vars: dict[str, set] = {}   # func_name -> set[str]
+        self._session_history_unsafe: dict[str, str] = {}
+        # Plain UDF -> script variables (and ``bar_index``) its body reads
+        # through history, in source order; id(Subscript) -> (UDF, name, node)
+        # for each such read. See ``_note_function_global_history_read``.
+        self._func_global_history_reads: dict[str, list[str]] = {}
+        self._func_global_history_nodes: dict[int, tuple] = {}
+        self._global_history_only_stateful: set[str] = set()
+        self._global_history_typing_warned: set[tuple] = set()
         # Declaration-bound non-persistent history locals are distinct from
         # history parameters/global reads carried by ``func_series_vars``.
         # Codegen needs this exact subset when a raw spelling also belongs to
@@ -604,6 +632,8 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 for name, specs in self._func_param_type_specs.items()
             },
             func_security_clone_only=self._func_security_clone_only,
+            session_history_unsafe=self._session_history_unsafe,
+            session_uncloned=self._session_uncloned,
             func_cs_ta_clone_names=self._func_cs_ta_clone_names,
             udt_defs=self._udt_fields,
             enum_defs=self._enum_defs,
@@ -622,6 +652,11 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 for owner, names in self._func_var_storage_names.items()
             },
             func_series_vars=self._func_series_vars,
+            func_global_history_reads={
+                owner: list(names)
+                for owner, names in self._func_global_history_reads.items()
+            },
+            func_global_history_nodes=dict(self._func_global_history_nodes),
             nonpersistent_series_decl_names=set(
                 self._nonpersistent_series_decl_names
             ),
@@ -2204,8 +2239,14 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                     out |= self._collect_security_mutable_globals(arg, resolving)
                 for value in node.kwargs.values():
                     out |= self._collect_security_mutable_globals(value, resolving)
-                for stmt in self._func_defs[func_name].body:
-                    out |= self._collect_security_mutable_globals(stmt, resolving)
+                # One walk of a body holds every global it reads, and the walk
+                # returns their union: a helper reached again (``f(x) + f(x)``,
+                # a diamond of such helpers) is not walked once per path.
+                walked = f"walked:{func_name}"
+                if walked not in resolving:
+                    resolving.add(walked)
+                    for stmt in self._func_defs[func_name].body:
+                        out |= self._collect_security_mutable_globals(stmt, resolving)
                 resolving.remove(call_key)
                 return out
 
@@ -2243,6 +2284,99 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
 
         return out
 
+    def _session_history_unsafe_functions(
+            self, func_defs: dict, find_calls, known_func_names: set[str],
+            calls_by_parent: dict) -> dict[str, str]:
+        """The functions and methods that cannot keep a ``session.*`` flag's
+        history per call site, each with the reason (name -> why).
+
+        A read in a function keeps its call site's history: the function is
+        emitted once per call site (``_session_call_*``, codegen). Four kinds
+        of callable do not get that:
+
+        * a method: a call on a receiver the analyzer cannot type
+          (``mk().m()``, a loop variable) is not told apart from the method's
+          other calls;
+        * a function a method calls, once in the method's one body;
+        * a function a request.security expression evaluates: the evaluator
+          inlines it or calls its chart variant, on the requested clock. The
+          functions reached are those the expression calls, those they call,
+          and those a global variable's definition or a mutable global's
+          statements call when anything it reaches spells the global's name
+          (the evaluator follows a mutable global by name, so a function's
+          own binding of the name does not stop it);
+        * a function a UDT field default calls, once for every ``new()``.
+
+        Codegen refuses a ``session.<flag>[k]`` it emits in one of them; a read
+        it never emits (in ``plot()``, a dropped argument) refuses nothing.
+        Every such emitted read failed the C++ compile before this lane.
+        """
+        unsafe: dict[str, str] = {}
+
+        def mark(names, why: str) -> None:
+            for name in sorted(names):
+                unsafe.setdefault(name, why)
+
+        def closure(roots) -> set[str]:
+            found, pending = set(), list(roots)
+            while pending:
+                name = pending.pop()
+                if name in found or name not in func_defs:
+                    continue
+                found.add(name)
+                pending.extend(callee for callee, _call in calls_by_parent.get(name, []))
+            return found
+
+        methods = {name for name in func_defs if "." in name}
+        mark(methods, "a method, whose calls PineForge cannot always tell apart")
+        mark(closure(callee for m in methods for callee, _call in calls_by_parent.get(m, [])),
+             "which a method calls")
+
+        # A request.security expression's reach.
+        pending: list[tuple[Any, str | None]] = [
+            (sec.expression, getattr(sec, "containing_func", "") or None)
+            for sec in getattr(self, "_security_calls", []) or []
+            if getattr(sec, "expression", None) is not None
+        ]
+        reached: set[str] = set()
+        seen_nodes: set[int] = set()
+        followed: set[str] = set()
+        while pending:
+            node, owner = pending.pop()
+            if id(node) in seen_nodes:
+                continue
+            seen_nodes.add(id(node))
+            if self._budget is not None:
+                self._budget.check(getattr(node, "loc", None), Phase.ANALYZER)
+            for callee, _call in find_calls(node, known_func_names, owner):
+                if callee not in reached and callee in func_defs:
+                    reached.add(callee)
+                    pending.append((func_defs[callee], callee))
+            for child, _depth in iter_ast_nodes(node):
+                if not isinstance(child, Identifier) or child.name in followed:
+                    continue
+                name = child.name
+                info = self._global_binding_infos.get(name)
+                if info is not None and (info.is_var or name in self._global_reassigned_names):
+                    followed.add(name)
+                    pending.extend((stmt, None) for stmt in info.source_stmts)
+                elif name in self._global_expr_map:
+                    followed.add(name)
+                    pending.append((self._global_expr_map[name], None))
+        mark(reached, "which a request.security expression evaluates on the requested clock")
+
+        # A UDT field default's call, for the types a script builds.
+        built = {node.callee.object.name for node, _depth in iter_ast_nodes(self._ast)
+                 if isinstance(node, FuncCall) and isinstance(node.callee, MemberAccess)
+                 and node.callee.member == "new" and isinstance(node.callee.object, Identifier)}
+        mark(closure(callee
+                     for stmt in self._ast.body
+                     if isinstance(stmt, TypeDecl) and stmt.name in built
+                     for field in stmt.fields if field.default is not None
+                     for callee, _call in find_calls(field.default, known_func_names, None)),
+             "which a UDT field default calls once for every new()")
+        return unsafe
+
     def _propagate_call_site_counts(self) -> None:
         """Propagate stateful UDF identity through complete call paths.
 
@@ -2564,12 +2698,15 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                         owner_requirements.add(actual.name)
                         series_changed = True
 
-        # Codegen synthesizes a Series buffer for two expression shapes that
+        # Codegen synthesizes a Series buffer for three expression shapes that
         # do not appear in ``_func_series_vars`` themselves:
         #
         #   * a call result read through history, e.g. ``f()[1]``;
         #   * a scalar expression bridged into a UDF series parameter, e.g.
-        #     ``history(close + open)`` where ``history(src) => src[1]``.
+        #     ``history(close + open)`` where ``history(src) => src[1]``;
+        #   * a session.* flag read at an offset, e.g. ``session.ismarket[1]``,
+        #     whose history in a function is the calls' of its call site
+        #     (TradingView's tapes, tests/test_e2e_session_history.py).
         #
         # A buffer is mutable per-call-site state just like TA/fixnan.  Mark
         # its lexical owner stateful before the normal call-path closure so a
@@ -2609,6 +2746,15 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 return True
             return False
 
+        # A read written in a request.security expression keeps the requested
+        # clock's history (codegen security.py), not its function's calls.
+        requested_node_ids = {
+            id(child)
+            for sec in getattr(self, "_security_calls", []) or []
+            if getattr(sec, "expression", None) is not None
+            for child, _depth in iter_ast_nodes(sec.expression)
+        }
+
         def _has_synthetic_history_state(
                 node, seen: set[int] | None = None) -> bool:
             if node is None:
@@ -2645,6 +2791,21 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             name for name, func_def in func_defs.items()
             if _has_synthetic_history_state(func_def)
         }
+        # A plain function that reads a flag at an offset is emitted once per
+        # call site, if this analysis may clone it. A callable that cannot
+        # keep its call sites apart gets no clone for it (codegen refuses such
+        # a read where it emits one).
+        self._session_history_unsafe = self._session_history_unsafe_functions(
+            func_defs, _find_calls, known_func_names, calls_by_parent)
+        session_readers = frozenset(
+            name for name, func_def in func_defs.items()
+            if name not in self._session_history_unsafe
+            and emitted_session_reads(func_def, requested_node_ids)
+        )
+        cloned = (session_readers if self._session_clones is None
+                  else session_readers & self._session_clones)
+        self._session_uncloned = session_readers - cloned
+        synthetic_history_stateful |= cloned
 
         # request.security owns a separate evaluator context and already
         # materializes/remaps its embedded TA state per SecurityCallInfo.  Do
@@ -2665,8 +2826,10 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 )
 
         # Canonical direct-state predicate.  TA-only and fixnan-only helpers
-        # are just as stateful as functions carrying an explicit series/var.
-        stateful = (
+        # are just as stateful as functions carrying an explicit series/var,
+        # and so is a function reading a script variable through history: its
+        # call sites each own that history.
+        direct_state = (
             set(self._func_series_vars)
             | set(self._func_var_members)
             | set(self._func_ta_ranges)
@@ -2679,15 +2842,40 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         # marker is intentionally separate from request.security evaluator
         # identity, so ordinary security calls remain shared unless the
         # dedicated timeframe-monomorphization pass clones them.
-        changed = True
-        while changed:
-            changed = False
-            for fname, calls in calls_by_parent.items():
-                if fname in stateful:
-                    continue
-                if any(sub in stateful for sub, _ in calls):
-                    stateful.add(fname)
-                    changed = True
+        def close_over_callers(seed: set[str]) -> set[str]:
+            closed = set(seed)
+            changed = True
+            while changed:
+                changed = False
+                for fname, calls in calls_by_parent.items():
+                    if fname in closed:
+                        continue
+                    if any(sub in closed for sub, _ in calls):
+                        closed.add(fname)
+                        changed = True
+            return closed
+
+        # A function whose untyped parameter receives two primitive families
+        # at its written calls is TradingView's once per family: one variant
+        # per call site, each typed from its own call.
+        family_polymorphic = self._untyped_param_family_conflicts(
+            func_defs, func_info_by_name, call_edges, _bound_user_call_args)
+        family_polymorphic = self._bounded_family_polymorphism(
+            family_polymorphic,
+            direct_state | set(self._func_global_history_reads),
+            close_over_callers, call_edges, func_info_by_name)
+        stateful = close_over_callers(
+            direct_state
+            | set(self._func_global_history_reads)
+            | family_polymorphic
+        )
+        # Callables stateful only through a script variable's history, or
+        # their parameters' families: before those rules they shared one body,
+        # so their call-site typing must not refuse a script that transpiled
+        # then (``merge_profile`` below).
+        self._global_history_only_stateful = (
+            stateful - close_over_callers(direct_state)
+        )
 
         # Direct fixnan-only functions and pure transitive wrappers own no
         # TA/series member that would trip the emitter's ordinary body-clone
@@ -2862,6 +3050,200 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             _bound_user_call_args,
         )
 
+    # The primitive families a written call can pass an untyped parameter.
+    _ARGUMENT_FAMILIES = frozenset({
+        PineType.INT, PineType.FLOAT, PineType.BOOL, PineType.STRING,
+        PineType.COLOR,
+    })
+
+    def _untyped_param_family_conflicts(
+        self, func_defs, func_info_by_name, call_edges, bound_args,
+    ) -> set[str]:
+        """Plain functions TradingView compiles once per argument family.
+
+        An untyped parameter takes the type of each written call's argument:
+        ``s(x) => str.tostring(x)`` spells ``s(5)`` "5" and ``s(2.5)`` "2.5"
+        (lab tv pf-cgs2-untyped-params). One shared body is typed from the
+        first call, so a function whose untyped scalar parameter receives
+        another family -- anything but an int where the body holds a float,
+        which holds it exactly -- narrowed it (a float into an ``int``).
+        Only an argument whose type is known at its call counts: one reading
+        an untyped parameter of the calling function is typed by that
+        function's variant. The set holds each such function and, to a fixed
+        point, every function one of them forwards an untyped parameter to
+        (``wrap(y) => twice(y)``)."""
+
+        def untyped_params(name: str | None) -> dict[int, str]:
+            node = func_defs.get(name) if name is not None else None
+            if node is None:
+                return {}
+            specs = list(self._func_param_type_specs.get(name, ()))
+            return {
+                index: param
+                for index, param in enumerate(node.params)
+                if index >= len(specs) or specs[index] is None
+            }
+
+        def scalar_untyped_params(name: str) -> dict[int, str]:
+            info = func_info_by_name.get(name)
+            if (info is None or getattr(info, "is_udt_method", False)
+                    or not isinstance(func_defs.get(name), FuncDef)):
+                return {}
+            series = self._func_series_vars.get(name, set())
+            return {
+                index: param
+                for index, param in untyped_params(name).items()
+                if param not in series
+            }
+
+        def shared_family(name: str, index: int) -> PineType:
+            info = func_info_by_name[name]
+            specs = list(getattr(info, "param_type_specs", ()) or ())
+            spec = specs[index] if index < len(specs) else None
+            if spec is not None:
+                return self._primitive_pine_type_from_spec(spec)
+            types = list(getattr(info, "param_types", ()) or ())
+            return types[index] if index < len(types) else PineType.UNKNOWN
+
+        def reads(value, names: set[str]) -> bool:
+            return bool(names) and any(
+                isinstance(sub, Identifier) and sub.name in names
+                for sub, _depth in iter_ast_nodes(value)
+            )
+
+        conflicted: set[str] = set()
+        # The first conflicting call of each directly conflicted function:
+        # (parameter index, shared family, call family, call).
+        self._family_conflict_calls = {}
+        for owner, callee, call in call_edges:
+            params = scalar_untyped_params(callee)
+            if not params or callee in conflicted:
+                continue
+            owner_params = set(untyped_params(owner).values())
+            actuals = bound_args(callee, call)
+            recorded = self._callable_bound_param_types_by_node.get(id(call), [])
+            for index in params:
+                if (index >= len(actuals) or index >= len(recorded)
+                        or actuals[index] is None
+                        or reads(actuals[index], owner_params)):
+                    continue
+                family = recorded[index]
+                shared = shared_family(callee, index)
+                if (family in self._ARGUMENT_FAMILIES
+                        and shared in self._ARGUMENT_FAMILIES
+                        and family != shared
+                        and not (family == PineType.INT
+                                 and shared == PineType.FLOAT)):
+                    conflicted.add(callee)
+                    self._family_conflict_calls[callee] = (
+                        index, shared, family, call)
+                    break
+
+        changed = True
+        while changed:
+            changed = False
+            for owner, callee, call in call_edges:
+                if owner not in conflicted or callee in conflicted:
+                    continue
+                params = scalar_untyped_params(callee)
+                owner_params = set(untyped_params(owner).values())
+                actuals = bound_args(callee, call)
+                if any(
+                    index < len(actuals) and actuals[index] is not None
+                    and reads(actuals[index], owner_params)
+                    for index in params
+                ):
+                    conflicted.add(callee)
+                    changed = True
+        return conflicted
+
+    # Copies of one function family polymorphism may add: one per call path
+    # through the functions it makes stateful (``_build_func_instances``).
+    _MAX_FAMILY_VARIANTS = 64
+
+    def _bounded_family_polymorphism(
+        self, family, seed, close_over_callers, call_edges, func_info_by_name,
+    ) -> set[str]:
+        """``family`` without the functions whose variants would outgrow the
+        script: more copies in all than ``_MAX_FAMILY_VARIANTS`` and four per
+        written call, beyond those the functions' own state already makes.
+
+        Each function the family set makes stateful is emitted once per call
+        path from the script through stateful functions, so a diamond of
+        forwarding helpers (``fk(x) => f(k-1)(x) + f(k-1)(x)``) is 2**depth
+        copies of its leaf (42 MB of C++ at depth 16) and a forwarding chain
+        is its depth times its calls. Seventy flat calls are seventy copies,
+        one per written call, and stay, as do those of a helper forwarding
+        the parameter once. Past the bound, the function gaining the most
+        copies and the family functions it is reached from keep the one body
+        every earlier build emitted, typed from the first call, and a
+        conflicting parameter warns; the rest keep their variants."""
+        if not family:
+            return family
+        callers: dict[str, list[str | None]] = {}
+        for owner, callee, _call in call_edges:
+            callers.setdefault(callee, []).append(owner)
+        cap = 1 << 20
+
+        def path_counts(stateful: set[str]) -> dict[str, int]:
+            counts = {name: 0 for name in stateful}
+            for _round in range(len(stateful) + 1):
+                changed = False
+                for name in stateful:
+                    total = min(cap, sum(
+                        counts.get(owner, 0) if owner in stateful else 1
+                        for owner in callers.get(name, ())))
+                    if total != counts[name]:
+                        counts[name] = total
+                        changed = True
+                if not changed:
+                    break
+            return counts
+
+        before = path_counts(close_over_callers(seed))
+        bound = max(self._MAX_FAMILY_VARIANTS, 4 * len(call_edges))
+        kept = set(family)
+        dropped: set[str] = set()
+        while kept:
+            after = path_counts(close_over_callers(seed | kept))
+            added = {name: count - before.get(name, 0)
+                     for name, count in after.items()
+                     if count > before.get(name, 0)}
+            if sum(added.values()) <= bound:
+                break
+            worst = max(sorted(added), key=lambda name: added[name])
+            reached_from: set[str] = set()
+            pending = [worst]
+            while pending:
+                name = pending.pop()
+                if name in reached_from:
+                    continue
+                reached_from.add(name)
+                pending.extend(owner for owner in callers.get(name, ())
+                               if owner is not None)
+            implicated = kept & reached_from
+            if not implicated:
+                break
+            kept -= implicated
+            dropped |= implicated
+        for callee, (index, shared, incoming, call) in sorted(
+                getattr(self, "_family_conflict_calls", {}).items()):
+            info = func_info_by_name.get(callee)
+            if callee not in dropped or info is None or info.node is None:
+                continue
+            self._warn(
+                "Untyped parameter '" + info.node.params[index]
+                + "' of callable '" + callee + "' receives "
+                + shared.value + " and " + incoming.value
+                + " at its written calls; a copy per call path would exceed "
+                + f"{self._MAX_FAMILY_VARIANTS} copies and four per written "
+                + "call, so PineForge types it " + shared.value
+                + ", as its first call, and converts the other argument. "
+                + "Declare the parameter type to choose it.",
+                call.loc,
+            )
+        return kept
+
     @staticmethod
     def _primitive_pine_type_from_spec(spec) -> PineType:
         if spec is None or getattr(spec, "kind", None) != "primitive":
@@ -2932,6 +3314,31 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                     current[index] = candidate
                     changed = True
                 elif current[index] != candidate:
+                    if callee in self._global_history_only_stateful:
+                        # Its call sites shared one body before this callable
+                        # read a script variable's history; keep that body's
+                        # typing, the first type, rather than refuse a script
+                        # that transpiled then.
+                        warned = (callee, cs_idx, index)
+                        if warned not in self._global_history_typing_warned:
+                            self._global_history_typing_warned.add(warned)
+                            self._warn(
+                                "Untyped parameter '"
+                                + info.node.params[index]
+                                + "' of callable '"
+                                + callee
+                                + "' receives "
+                                + current[index].value
+                                + " and "
+                                + candidate.value
+                                + " through calls that share one written-call "
+                                + f"variant (cs{cs_idx}); PineForge types it "
+                                + current[index].value
+                                + ", so the other argument is converted. "
+                                + "Declare the parameter type to choose it.",
+                                call.loc,
+                            )
+                        continue
                     self._error(
                         "Cannot safely specialize untyped parameter '"
                         + info.node.params[index]
@@ -3223,16 +3630,18 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                         )
 
     # ------------------------------------------------------------------
-    # Mixed-callsite UDF timeframe-param security rejection.
+    # Per-call-site request.security contexts of a helper.
     #
-    # A ``request.security`` whose ``timeframe`` is a parameter of its
-    # containing UDF maps to ONE evaluator regardless of how many times the
-    # UDF is called. When the UDF is called from >= 2 sites with DISTINCT
-    # literal timeframes, a single evaluator cannot faithfully serve them
-    # all and the resolver would silently collapse onto the chart timeframe
-    # (``input_tf_``). Per-callsite evaluator specialization (cloning the
-    # evaluator + UDF) is the correct fix but is not wired in this iteration,
-    # so we reject deterministically instead of emitting wrong semantics.
+    # A ``request.security`` whose ``timeframe`` or ``symbol`` is a parameter
+    # of its containing UDF maps to ONE evaluator however often the UDF is
+    # called. When its call sites pass different contexts -- timeframes, or a
+    # Heikin-Ashi and a plain chart symbol -- one evaluator cannot serve them
+    # all: the request is cloned per call site (``callsite_idx``), each clone
+    # registered with its site's timeframe argument (a literal as a literal,
+    # anything else -- an input, a global -- as that expression, read at
+    # registration) and its site's symbol. A context reaching the helper
+    # through another helper's parameter or a local is resolved before the
+    # analyzer runs (``security_contexts``) and arrives here resolved.
     # ------------------------------------------------------------------
     def _check_mixed_callsite_security_tf(self) -> None:
         sec_calls = getattr(self, "_security_calls", None)
@@ -3248,16 +3657,19 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         cloned_any = False
         for sec in sec_calls:
             containing = getattr(sec, "containing_func", "") or ""
+            fdef = func_defs.get(containing) if containing else None
             tf_node = getattr(sec, "timeframe", None)
-            if not containing or not isinstance(tf_node, Identifier):
+            symbol_node = getattr(sec, "symbol", None)
+            if fdef is None or sec.context_resolved or sec.is_lower_tf_array:
                 new_calls.append(sec)
                 continue
-            param_name = tf_node.name
-            fdef = func_defs.get(containing)
-            if fdef is None or param_name not in fdef.params:
+            tf_param = (tf_node.name if isinstance(tf_node, Identifier)
+                        and tf_node.name in fdef.params else None)
+            symbol_param = (symbol_node.name if isinstance(symbol_node, Identifier)
+                            and symbol_node.name in fdef.params else None)
+            if tf_param is None and symbol_param is None:
                 new_calls.append(sec)
                 continue
-            pidx = fdef.params.index(param_name)
             calls = list(self._iter_user_func_calls(containing))
             if not calls:
                 new_calls.append(sec)  # dead code — evaluator result never read
@@ -3280,7 +3692,8 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             # naming (which keys purely off func_call_cs_map, not
             # has_ta/has_series) picks the right ``_cs{N}`` variant.
             already_tracked = self._func_call_site_count.get(containing, 0) > 0
-            per_cs: list[tuple[int, str | None]] = []
+            # (cs_idx, context key, registered timeframe, heikinashi)
+            per_cs: list[tuple[int, tuple, object, bool]] = []
             for i, call in enumerate(calls):
                 if already_tracked:
                     cs_info = self._func_call_cs_map.get(id(call))
@@ -3288,33 +3701,49 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                         continue  # shouldn't happen: has_ta/has_series tracks ALL call sites
                     cs_idx = cs_info[1]
                 else:
+                    # Numbered in func_call_cs_map only if the request is
+                    # cloned below: a call mapped to ``f_cs0`` while one
+                    # context left ``f`` uncloned named a function nothing
+                    # emits (``f(string sym) => request.security(sym, "60",
+                    # close[1])`` did not compile).
                     cs_idx = i
-                    self._func_call_cs_map.setdefault(id(call), (containing, cs_idx))
-                arg = call.args[pidx] if pidx < len(call.args) else None
-                lit = self._callsite_tf_literal_value(arg)
-                per_cs.append((cs_idx, lit))
+                key: list = []
+                timeframe = tf_node
+                if tf_param is not None:
+                    pidx = fdef.params.index(tf_param)
+                    arg = call.args[pidx] if pidx < len(call.args) else None
+                    lit = self._callsite_tf_literal_value(arg)
+                    if lit is not None:
+                        key.append(("lit", lit))
+                        timeframe = StringLiteral(value=lit, loc=tf_node.loc)
+                    else:
+                        key.append(("expr", self._security_context_key(arg)))
+                        timeframe = arg
+                heikinashi = sec.heikinashi
+                if symbol_param is not None:
+                    sidx = fdef.params.index(symbol_param)
+                    arg = call.args[sidx] if sidx < len(call.args) else None
+                    heikinashi = arg is not None and self._security_symbol_is_heikinashi(arg)
+                    key.append(heikinashi)
+                per_cs.append((cs_idx, tuple(key), timeframe, heikinashi))
             if not per_cs:
                 new_calls.append(sec)  # dead code — evaluator result never read
                 continue
-            distinct_literals = {lit for _, lit in per_cs if lit is not None}
-            if len(distinct_literals) < 2:
-                new_calls.append(sec)  # single TF (or unresolved) — no cloning needed
+            if len({key for _, key, _, _ in per_cs}) < 2:
+                # One context on every call site: the helper's own request.
+                sec.heikinashi = per_cs[0][3]
+                new_calls.append(sec)
                 continue
-            if any(lit is None for _, lit in per_cs):
-                # Some call site's tf isn't a compile-time literal — can't
-                # pin every clone to a concrete timeframe. Keep the original
-                # deterministic rejection rather than guess.
+            # With a timeframe parameter, a key's first part is its timeframe.
+            series = tf_param and next(
+                (name for _, key, timeframe, _ in per_cs
+                 if key[0][0] == "expr" and (name := reads_bar_series(timeframe))), None)
+            if series is not None:
                 self._error(
-                    "request.security timeframe parameter '"
-                    + param_name
-                    + "' of function '"
-                    + containing
-                    + "' is called with multiple distinct literal timeframes ("
-                    + ", ".join(sorted(distinct_literals))
-                    + "). A single request.security evaluator cannot serve "
-                    "them all and would silently collapse onto the chart "
-                    "timeframe. Pass a single timeframe, or inline a separate "
-                    "request.security call at each call site.",
+                    "request.security timeframe parameter '" + str(tf_param)
+                    + "' of function '" + containing + "' is passed a timeframe "
+                    "that reads the chart bar ('" + series + "'): PineForge "
+                    "registers each call site's timeframe before the first bar.",
                     tf_node.loc,
                 )
                 new_calls.append(sec)
@@ -3326,18 +3755,18 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 # func_security_clone_only) actually clones its body, with
                 # self._active_call_site_idx set to each of our cs_idx values
                 # in turn while it does.
+                for cs_idx, call in enumerate(calls):
+                    self._func_call_cs_map.setdefault(id(call), (containing, cs_idx))
                 self._func_call_site_count[containing] = len(calls)
                 self._func_security_clone_only.add(containing)
-            # Clone: one SecurityCallInfo per call site, each pinned to that
-            # site's literal timeframe via a synthetic StringLiteral (so the
-            # existing literal-timeframe resolution path needs no changes)
-            # and given a fresh, currently-unused sec_id.
+            # Clone: one SecurityCallInfo per call site, each registered with
+            # its site's context and given a fresh, currently-unused sec_id.
             next_sec_id = max((s.sec_id for s in sec_calls), default=-1) + 1
             next_sec_id = max(next_sec_id, len(sec_calls) + len(new_calls))
-            for cs_idx, lit in sorted(per_cs):
+            for cs_idx, _key, timeframe, heikinashi in sorted(per_cs, key=lambda c: c[0]):
                 clone = SecurityCallInfo(
                     sec_id=next_sec_id,
-                    timeframe=StringLiteral(value=lit, loc=tf_node.loc),
+                    timeframe=timeframe,
                     expression=sec.expression,
                     returns_tuple=sec.returns_tuple,
                     tuple_size=sec.tuple_size,
@@ -3345,11 +3774,16 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                     gaps=sec.gaps,
                     lookahead=sec.lookahead,
                     ta_range=sec.ta_range,
+                    heikinashi=heikinashi,
                     depends_on_mutable_globals=sec.depends_on_mutable_globals,
                     mutable_globals=sec.mutable_globals,
                     is_lower_tf_array=sec.is_lower_tf_array,
                     containing_func=sec.containing_func,
                     callsite_idx=cs_idx,
+                    string_result=sec.string_result,
+                    symbol=sec.symbol,
+                    foreign=sec.foreign,
+                    ignore_invalid=sec.ignore_invalid,
                 )
                 new_calls.append(clone)
                 next_sec_id += 1
@@ -3391,20 +3825,29 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         yield from _walk(self._ast)
 
     def _callsite_tf_literal_value(self, arg) -> str | None:
-        """Resolve a UDF call-site timeframe argument to a literal string
-        value when it is statically known: a string literal, or a known
-        constant / input-backed variable whose stored value is a string.
-        Returns None for anything that is not a compile-time string."""
+        """A UDF call-site timeframe argument's value when it is a string
+        literal, directly or through never-reassigned global aliases, else
+        None. An input's default is not its value: an override changes it."""
+        seen: set[str] = set()
+        while (isinstance(arg, Identifier) and arg.name not in seen
+               and arg.name not in self._global_reassigned_names):
+            seen.add(arg.name)
+            arg = self._global_expr_map.get(arg.name)
         if isinstance(arg, StringLiteral):
             return arg.value
-        if isinstance(arg, Identifier):
-            sym = self._symbols.resolve(arg.name)
-            if sym is not None and getattr(sym, "const_value", None) is not None:
-                val = sym.const_value
-                if isinstance(val, str):
-                    return val
         return None
 
+    def _security_context_key(self, arg):
+        """A call-site context argument, compared by what it spells after
+        following never-reassigned global aliases."""
+        seen: set[str] = set()
+        while (isinstance(arg, Identifier) and arg.name not in seen
+               and arg.name not in self._global_reassigned_names
+               and isinstance(self._global_expr_map.get(arg.name), Identifier)):
+            seen.add(arg.name)
+            arg = self._global_expr_map[arg.name]
+        return context_key(arg)
+
     def _is_static_expression(self, node: ASTNode | None) -> bool:
         if node is None:
             return True
@@ -3474,6 +3917,10 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         """Dispatch to the appropriate visitor and return the inferred type."""
         if node is None:
             return PineType.VOID
+        if self._budget is not None:
+            self._budget_visit_count += 1
+            if self._budget_visit_count % 128 == 0:
+                self._budget.check(node.loc, Phase.ANALYZER)
 
         method_name = f"_visit_{type(node).__name__}"
         # Convert CamelCase to snake_case for method lookup
@@ -3508,12 +3955,16 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         return PineType.VOID
 
     def _visit_ImportStmt(self, node: ImportStmt) -> PineType:
+        # Imported here: the support checker imports the analyzer package.
+        from ..support_checker import import_is_builtin_namespace_no_op, import_refusal
+        if import_is_builtin_namespace_no_op(self._ast, node):
+            return PineType.VOID
         loc = node.loc or SourceLocation(file=self._filename, line=1, col=1, end_col=1)
         diag = Diagnostic(
             level=Level.ERROR,
             phase=Phase.ANALYZER,
             location=loc,
-            message=f"Import is not supported: '{node.path}'",
+            message=import_refusal(node),
         )
         raise CompileError([diag])
 
@@ -4047,20 +4498,112 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                     if hasattr(sym, "is_static_series"):
                         delattr(sym, "is_static_series")
         else:
-            self._visit(node.target)
+            target_type = self._visit(node.target)
             base_name = self._get_target_base_name(node.target)
             if base_name:
                 self._static_vars.discard(base_name)
                 sym = self._symbols.resolve(base_name)
                 if sym and hasattr(sym, "is_static_series"):
                     delattr(sym, "is_static_series")
+            # The statement's value is the target's new value, typed as the
+            # target: ``o.v += 1`` on a float field is a float.
+            if (isinstance(node.target, MemberAccess)
+                    and target_type not in (None, PineType.UNKNOWN, PineType.VOID)):
+                return target_type
 
+        if isinstance(node.target, Identifier):
+            target_sym = self._symbols.resolve(node.target.name)
+            if (target_sym is not None and target_sym.pine_type
+                    not in (PineType.UNKNOWN, PineType.VOID)):
+                return target_sym.pine_type
         return val_type
 
+    def _selection_tuple_shape(
+        self, node
+    ) -> tuple[int, tuple[PineType, ...]] | None:
+        """``(size, element types)`` of an if/switch whose every arm yields a
+        tuple: a ``[a, b]`` literal, a call of a tuple-returning user function,
+        or a nested selection of those. Pine types the selection as that
+        tuple; arms must agree on its size. ``None`` for any other shape.
+
+        Element types are the arms' common type per position (int and float
+        make float); a position the arms disagree on is left untyped.
+        """
+        if isinstance(node, IfStmt):
+            arms = [node.body] + ([node.else_body] if node.else_body else [])
+        elif isinstance(node, SwitchStmt):
+            arms = [body for _case, body in node.cases]
+            if node.default_body:
+                arms.append(node.default_body)
+        else:
+            return None
+        shapes: list[tuple[int, tuple[PineType, ...]]] = []
+        for body in arms:
+            if not body:
+                return None
+            terminal = body[-1]
+            expr = terminal.expr if isinstance(terminal, ExprStmt) else terminal
+            if isinstance(expr, TupleLiteral):
+                shapes.append((
+                    len(expr.elements),
+                    self._tuple_element_types_by_node.get(id(expr), ()),
+                ))
+            elif (isinstance(expr, FuncCall)
+                    and isinstance(expr.callee, Identifier)
+                    and self._func_returns_tuple.get(expr.callee.name, False)):
+                shapes.append((
+                    self._func_tuple_element_count.get(expr.callee.name, 0),
+                    self._func_tuple_element_types.get(expr.callee.name, ()),
+                ))
+            elif isinstance(expr, (IfStmt, SwitchStmt)):
+                nested = self._selection_tuple_shape(expr)
+                if nested is None:
+                    return None
+                shapes.append(nested)
+            else:
+                return None
+        sizes = {size for size, _types in shapes}
+        if len(sizes) != 1:
+            return None
+        size = sizes.pop()
+        if size < 2:
+            return None
+        if any(len(types) != size for _size, types in shapes):
+            return size, ()
+        element_types: list[PineType] = []
+        for position in range(size):
+            known = {
+                types[position] for _size, types in shapes
+                if types[position] not in (PineType.NA, PineType.UNKNOWN)
+            }
+            if len(known) == 1:
+                element_types.append(known.pop())
+            elif known and known <= {PineType.INT, PineType.FLOAT}:
+                element_types.append(PineType.FLOAT)
+            else:
+                return size, ()
+        return size, tuple(element_types)
+
     def _visit_TupleAssign(self, node: TupleAssign) -> PineType:
         val_type = self._visit(node.value)
         loc = node.loc or SourceLocation(file=self._filename, line=1, col=1, end_col=1)
         element_types = self._tuple_element_types_by_node.get(id(node.value), ())
+        if not element_types and isinstance(node.value, (IfStmt, SwitchStmt)):
+            shape = self._selection_tuple_shape(node.value)
+            if shape is not None:
+                element_types = shape[1]
+        if (not element_types
+                and isinstance(node.value, FuncCall)
+                and isinstance(node.value.callee, Identifier)
+                and self._func_returns_tuple.get(node.value.callee.name, False)):
+            # A user function's string elements bind as strings. Its other
+            # families keep the historical double storage of a call tuple.
+            element_types = tuple(
+                PineType.STRING if item == PineType.STRING else PineType.FLOAT
+                for item in self._func_tuple_element_types.get(
+                    node.value.callee.name, ()
+                )
+            )
 
         is_val_static = self._is_static_expression(node.value)
 
@@ -4075,10 +4618,12 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             )
             # Tuple bindings historically use double storage for every
             # numeric element, including integer literals. Preserve that
-            # contract while retaining the newly-authoritative bool family.
+            # contract while retaining the bool and string families: a string
+            # element read as a double compared by value (``a == b``) through
+            # a static_cast of a std::string.
             element_type = (
-                PineType.BOOL
-                if inferred_element_type == PineType.BOOL
+                inferred_element_type
+                if inferred_element_type in (PineType.BOOL, PineType.STRING)
                 else PineType.FLOAT
             )
 
@@ -4134,6 +4679,32 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
     # Function definition
     # ------------------------------------------------------------------
 
+    def _returns_tuple_call(self, value) -> bool:
+        """A call to a tuple-returning user function or ``ta.*`` function."""
+        if not isinstance(value, FuncCall):
+            return False
+        callee = value.callee
+        if isinstance(callee, Identifier):
+            return self._func_returns_tuple.get(callee.name, False)
+        return (isinstance(callee, MemberAccess)
+                and isinstance(callee.object, Identifier)
+                and callee.object.name == "ta"
+                and callee.member in TA_TUPLE_RETURNS)
+
+    def _statement_value_type(self, stmt, fallback: PineType) -> PineType:
+        """Type of the value a function's last statement leaves.
+
+        A trailing declaration ``[T] x = e`` returns ``x``, typed as the
+        variable (``float y = 4`` is a float); a trailing assignment types
+        itself as its target in ``_visit_Assignment``.
+        """
+        if not isinstance(stmt, VarDecl) or not stmt.name:
+            return fallback
+        sym = self._symbols.resolve(stmt.name)
+        if sym is None or sym.pine_type in (PineType.UNKNOWN, PineType.VOID):
+            return fallback
+        return sym.pine_type
+
     def _visit_FuncDef(self, node: FuncDef) -> PineType:
         # Store the function def for later analysis
         self._func_defs[node.name] = node
@@ -4181,6 +4752,8 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         try:
             for stmt in node.body:
                 body_type = self._visit(stmt)
+            if node.body:
+                body_type = self._statement_value_type(node.body[-1], body_type)
         finally:
             self._global_scope = old_global
             self._collection_scope_stack.pop()
@@ -4251,6 +4824,18 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             terminal_direct_return_spec,
         )
 
+        # ``[p, q] = pair(v)`` last returns that tuple: its element types are
+        # the declared names', resolvable only inside the function scope.
+        tuple_decl_types = ()
+        if (node.body and isinstance(node.body[-1], TupleAssign)
+                and "_" not in node.body[-1].names
+                and self._returns_tuple_call(node.body[-1].value)):
+            tuple_decl_types = tuple(
+                sym.pine_type if sym is not None else PineType.FLOAT
+                for sym in (self._symbols.resolve(name)
+                            for name in node.body[-1].names)
+            )
+
         self._symbols.exit_scope()
 
         # Detect if function returns a tuple (last stmt is TupleLiteral)
@@ -4264,12 +4849,27 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 tuple_node = last_stmt.expr
             elif isinstance(last_stmt, TupleLiteral):
                 tuple_node = last_stmt
+            selection_shape = (
+                self._selection_tuple_shape(last_stmt)
+                if isinstance(last_stmt, (IfStmt, SwitchStmt))
+                else None
+            )
             if tuple_node is not None:
                 self._func_returns_tuple[node.name] = True
                 self._func_tuple_element_count[node.name] = len(tuple_node.elements)
                 self._func_tuple_element_types[node.name] = (
                     self._tuple_element_types_by_node.get(id(tuple_node), ())
                 )
+            elif tuple_decl_types:
+                self._func_returns_tuple[node.name] = True
+                self._func_tuple_element_count[node.name] = len(tuple_decl_types)
+                self._func_tuple_element_types[node.name] = tuple_decl_types
+            elif selection_shape is not None:
+                # ``f() => if c ... g() else [a, b]``: every arm yields a
+                # tuple of one size, so the function returns that tuple.
+                self._func_returns_tuple[node.name] = True
+                self._func_tuple_element_count[node.name] = selection_shape[0]
+                self._func_tuple_element_types[node.name] = selection_shape[1]
             elif (
                 isinstance(terminal_ret_expr, FuncCall)
                 and isinstance(terminal_ret_expr.callee, Identifier)
@@ -4289,6 +4889,20 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                     self._func_tuple_element_types[node.name] = (
                         self._func_tuple_element_types.get(terminal_callee, ())
                     )
+            elif (
+                isinstance(terminal_ret_expr, FuncCall)
+                and id(terminal_ret_expr) in self._security_tuple_shapes
+            ):
+                # ``htf(sym, tf) => request.security(sym, tf, pack())``
+                # returns the requested tuple: it was typed a double, which
+                # did not compile, and its callers destructure it.
+                self._func_returns_tuple[node.name] = True
+                self._func_tuple_element_count[node.name] = (
+                    self._security_tuple_shapes[id(terminal_ret_expr)]
+                )
+                self._func_tuple_element_types[node.name] = (
+                    self._tuple_element_types_by_node.get(id(terminal_ret_expr), ())
+                )
 
         # Re-run direct-wrapper propagation to a fixed point whenever a new
         # definition is analyzed. This makes ``outer()=>inner()`` source-order
@@ -4516,6 +5130,8 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         try:
             for stmt in node.body:
                 ret_type = self._visit(stmt)
+            if node.body:
+                ret_type = self._statement_value_type(node.body[-1], ret_type)
             if terminal_ret_expr is not None:
                 terminal_spec = self._type_spec_from_expr(terminal_ret_expr)
                 if terminal_spec is not None and terminal_spec.kind == "map":
@@ -5255,6 +5871,17 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                     self._visit(arg)
                 return PineType.COLOR
 
+            # string(x): Pine's cast to string, usually of na
+            # (``[string(na), string(na)]`` arms of a string tuple). It fell
+            # to the unknown-builtin default FLOAT, which untyped a selection
+            # tuple whose other arm carries strings.
+            if func_name == "string":
+                for arg in node.args:
+                    self._visit(arg)
+                for val in node.kwargs.values():
+                    self._visit(val)
+                return PineType.STRING
+
             # User-defined function call
             if func_name in self._func_defs:
                 return self._handle_user_func_call(func_name, node)
@@ -5521,6 +6148,18 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         """Re-run map-history safety after untyped callable args are known."""
         if owner in visiting:
             return
+        # The same owner, specs and path check the same nodes again, so a
+        # helper that a diamond of callers reaches (``f1(x) => f0(x) +
+        # f0(x)``, ...) is validated once, not once per path. A failed check
+        # raises, so only a passed validation is remembered.
+        key = (
+            owner, visiting, tuple(sorted(parameter_specs.items())),
+            len(self._deferred_param_history_refs.get(owner, [])),
+            len(self._deferred_param_call_edges.get(owner, [])),
+        )
+        validated = self.__dict__.setdefault("_deferred_param_history_validated", set())
+        if key in validated:
+            return
         next_visiting = visiting | {owner}
         for node, parameter_nodes in self._deferred_param_history_refs.get(
             owner, []
@@ -5569,6 +6208,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 callee_specs,
                 next_visiting,
             )
+        validated.add(key)
 
     def _propagate_deferred_map_callable_specs(
         self,
@@ -5866,9 +6506,40 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                             self._func_series_history_nodes.setdefault(
                                 (func_name, name), node
                             )
+                        self._note_function_global_history_read(node, name, sym)
 
         return obj_type
 
+    def _note_function_global_history_read(
+            self, node: Subscript, name: str, sym) -> None:
+        """Record ``x[k]`` in a plain UDF body on a script variable.
+
+        TradingView builds the history of a series used inside a function
+        through each successive call of it: in ``f() => gv[1]``, ``gv[1]`` is
+        ``gv`` as that call site saw it on its latest call at or before the
+        previous bar, whether ``gv`` is ``var`` or not, and ``bar_index`` reads
+        the same way; the chart built-ins keep the chart's history
+        (tests/fixtures/function_global_history). Codegen gives every emitted
+        body of the function its own buffer, so the function needs one body
+        per call site, like any other stateful function.
+        """
+        if not self._enclosing_func_names or sym.scope != "global":
+            return
+        owner = self._enclosing_func_names[-1]
+        if not isinstance(self._func_defs.get(owner), FuncDef):
+            return
+        # A built-in other than bar_index is chart history.
+        if name != "bar_index" and getattr(sym, "_pf_decl_node_id", None) is None:
+            return
+        spec = getattr(sym, "type_spec", None)
+        if (sym.pine_type not in (PineType.INT, PineType.FLOAT, PineType.BOOL)
+                or (spec is not None and spec.kind != "primitive")):
+            return
+        reads = self._func_global_history_reads.setdefault(owner, [])
+        if name not in reads:
+            reads.append(name)
+        self._func_global_history_nodes[id(node)] = (owner, name, node)
+
     def _visit_Identifier(self, node: Identifier) -> PineType:
         # Some identifiers are namespace prefixes handled elsewhere
         if node.name in ("strategy", "ta", "input", "math", "str", "color",
@@ -6020,9 +6691,11 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             if ns == "barstate":
                 return PineType.BOOL
 
-            # alert.* constants (freq_once_per_bar, freq_once_per_bar_close, etc.)
+            # alert.freq_* are const strings ("all", "once_per_bar",
+            # "once_per_bar_close"); any other alert.* member is refused by
+            # the support checker.
             if ns == "alert":
-                return PineType.INT
+                return PineType.STRING
 
             # position.* constants for tables (middle_right, top_left, etc.)
             if ns == "position":
@@ -6112,6 +6785,11 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 return PineType.FLOAT
 
             sym = self._symbols.resolve(ns)
+            # A field read's receiver is an identifier read like any other:
+            # codegen needs its binding scope (``_call_site_var_name``).
+            self._identifier_binding_scopes[id(node.object)] = (
+                getattr(sym, "scope", None) if sym is not None else None
+            )
             udt_name = None
             if sym is not None:
                 udt_name = sym.udt_type_name