@pineforge/codegen-pyodide 0.10.4 → 1.0.0

package/pineforge_codegen/analyzer/call_handlers.py

@@ -68,8 +68,11 @@ from typing import Any
 from ..ast_nodes import (
     ASTNode, Assignment, BinOp, BoolLiteral, ExprStmt, FuncCall, Identifier,
     IfStmt, MemberAccess, NumberLiteral, StringLiteral, Subscript, SwitchStmt,
-    Ternary, TupleLiteral, UnaryOp, VarDecl,
+    Ternary, TupleAssign, TupleLiteral, UnaryOp, VarDecl,
 )
+from ..method_binding import bind_function_defaults
+from ..external_requests import FEED_LOWERING, LOWERING_ANNOTATION
+from ..security_contexts import CONTEXT_ANNOTATION, DEAD_ANNOTATION
 from ..symbols import PineType
 from .. import signatures as sigs
 from .. import tv_input_choices as tv_in
@@ -77,9 +80,23 @@ from .contracts import FixnanCallSite, FuncInfo, SecurityCallInfo, TACallSite
 from .tables import (
     BAR_FIELDS, TA_CLASS_MAP, TA_MULTI_CTOR, TA_NO_CTOR, TA_PERIOD_ARG,
     TA_TUPLE_RETURNS, TA_TUPLE_ELEMENT_COUNTS, TA_COMPUTE_ARGS,
+    TA_LENGTH_ONLY_DEFAULT_SOURCE,
 )
 
 
+# Element types a request.security helper tuple may carry (see
+# ``_handle_request_call``); an ``na`` element is stored as a double like every
+# numeric one. An element the definition leaves untyped is typed at the call
+# (``_security_callsite_tuple_types``) or refused.
+_SECURITY_TUPLE_ELEMENT_TYPES = frozenset({
+    PineType.INT, PineType.FLOAT, PineType.BOOL, PineType.STRING, PineType.NA,
+})
+_HINT_TYPES = {
+    "int": PineType.INT, "float": PineType.FLOAT, "bool": PineType.BOOL,
+    "string": PineType.STRING,
+}
+
+
 class CallHandlers:
     """``_handle_*_call`` dispatch + bookkeeping for analyzer call-sites.
 
@@ -385,6 +402,57 @@ class CallHandlers:
             merged.pop()
         return merged
 
+    def _is_constant_bool_literal(self, node, value: bool, _seen=frozenset()) -> bool:
+        """Small analyzer-side counterpart of the support checker's constant
+        bool test. The analyzer already records global expression bindings and
+        global reassignments; use those records so a one-time alias of true or
+        false follows the same route as the literal spelling."""
+        if isinstance(node, BoolLiteral):
+            return node.value is value
+        if isinstance(node, Identifier) and node.name not in _seen:
+            if node.name in getattr(self, "_global_reassigned_names", set()):
+                return False
+            expr = self._global_expr_map.get(node.name)
+            return expr is not None and self._is_constant_bool_literal(
+                expr, value, _seen | {node.name}
+            )
+        return False
+
+    def _constant_string_literal(self, node, _seen=frozenset()) -> str | None:
+        """Resolve a never-reassigned global string literal for pivot routing."""
+        if isinstance(node, StringLiteral):
+            return node.value
+        if isinstance(node, Identifier) and node.name not in _seen:
+            if node.name in getattr(self, "_global_reassigned_names", set()):
+                return None
+            expr = self._global_expr_map.get(node.name)
+            if expr is not None:
+                return self._constant_string_literal(expr, _seen | {node.name})
+        return None
+
+    def _is_daily_vwap_anchor(self, node, _seen=frozenset()) -> bool:
+        """Recognize PineForge's established default VWAP anchor."""
+        if isinstance(node, FuncCall):
+            callee = node.callee
+            if (
+                isinstance(callee, MemberAccess)
+                and isinstance(callee.object, Identifier)
+                and callee.object.name == "timeframe"
+                and callee.member == "change"
+                and len(node.args) + len(node.kwargs) == 1
+            ):
+                tf = node.args[0] if node.args else node.kwargs.get("timeframe")
+                return isinstance(tf, StringLiteral) and tf.value in {"D", "1D"}
+            return False
+        if isinstance(node, Identifier) and node.name not in _seen:
+            if node.name in getattr(self, "_global_reassigned_names", set()):
+                return False
+            expr = self._global_expr_map.get(node.name)
+            return expr is not None and self._is_daily_vwap_anchor(
+                expr, _seen | {node.name}
+            )
+        return False
+
     def _handle_ta_call(self, func_name: str, node: FuncCall) -> PineType:
         """Handle ta.* function calls."""
         # Visit all args for side effects (series detection, etc.)
@@ -393,22 +461,10 @@ class CallHandlers:
         for val in node.kwargs.values():
             self._visit(val)
 
-        # ta.pivot_point_levels is a free runtime function (not a stateful
-        # indicator), but its codegen lowers to use `_s_high[1]`, `_s_low[1]`,
-        # `_s_close[1]` so the pivot is calculated from the PREVIOUS bar's
-        # HLC (matching Pine v6 semantics where `developing` defaults to
-        # false). Register the bar-field history series here so that the
-        # codegen emits the corresponding `Series<double> _s_high/...` members
-        # and pushes them at the top of every on_bar tick.
-        if func_name == "pivot_point_levels":
-            self._series_bar_fields.add("high")
-            self._series_bar_fields.add("low")
-            self._series_bar_fields.add("close")
-            return PineType.FLOAT  # actual array<float> handled by type inference
-
         # ta.vwap(source, anchor, stdev_mult) → 3-arg bands form.
         # When called with 3 args (or anchor/stdev_mult kwargs), remap to the
         # internal "vwap_bands" key which maps to ta::VWAPBands (returns tuple).
+        merged_v = None
         if func_name == "vwap":
             param_names_v = ["source", "anchor", "stdev_mult"]
             merged_v = list(node.args)
@@ -421,11 +477,27 @@ class CallHandlers:
             if len(merged_v) >= 3:
                 func_name = "vwap_bands"
 
-        if func_name not in TA_CLASS_MAP:
+            # An explicit anchor, including timeframe.change("1D"/"D"), is a
+            # Pine series condition. TA1's anchored classes must see it on
+            # every bar; only the omitted-anchor spelling keeps the historical
+            # session-day VWAP class.
+            anchor = merged_v[1] if len(merged_v) > 1 else None
+            if anchor is not None:
+                func_name = (
+                    "vwap_anchored_bands"
+                    if len(merged_v) >= 3
+                    else "vwap_anchored"
+                )
+
+        if func_name not in TA_CLASS_MAP and func_name != "pivot_point_levels":
             return PineType.FLOAT
 
-        # Merge positional + kwargs into a unified arg list
-        all_args = self._merge_ta_args(func_name, node)
+        # Merge positional + kwargs into a unified arg list. The band form has
+        # no signature of its own: its arguments are ``ta.vwap``'s, merged above.
+        if func_name in ("vwap_bands", "vwap_anchored", "vwap_anchored_bands") and merged_v is not None:
+            all_args = merged_v
+        else:
+            all_args = self._merge_ta_args(func_name, node)
 
         # ta.tr(handle_na) — TV v6 default for handle_na is false. When the
         # caller omits the arg, inject the explicit ``false`` so the C++
@@ -448,15 +520,55 @@ class CallHandlers:
                 self._series_bar_fields.add(field)
             all_args = [default_src]
 
-        # Handle ta.highest(length) / ta.lowest(length) with 1 arg:
-        # single arg is the length, source defaults to high/low respectively.
-        # Remap so all_args = [default_source, length_arg].
-        _DEFAULT_SOURCE = {"highest": "high", "lowest": "low"}
-        if func_name in _DEFAULT_SOURCE and len(all_args) == 1:
-            default_src = Identifier(name=_DEFAULT_SOURCE[func_name])
+        # ``pivot_point_levels(type, anchor, developing)`` retains the
+        # historical free-function lowering only for the exact spelling the
+        # free function computes: anchor=true on every bar and
+        # developing=false for the Fibonacci, Classic, and Camarilla types.
+        # The public TradingView pivot tape pins Traditional, Woodie, and DM
+        # to the TA1 formulas, including the high Traditional levels.
+        if func_name == "pivot_point_levels":
+            self._series_bar_fields.update(("high", "low", "close"))
+            all_args = self._merge_ta_args(func_name, node)
+            if len(all_args) >= 2 and len(all_args) < 3:
+                all_args.append(BoolLiteral(value=False))
+            exact = (
+                len(all_args) >= 3
+                and self._is_constant_bool_literal(all_args[1], True)
+                and self._is_constant_bool_literal(all_args[2], False)
+                and self._constant_string_literal(all_args[0]) in {
+                    "Fibonacci", "Classic", "Camarilla"
+                }
+            )
+            if exact:
+                return PineType.FLOAT
+            self._ta_counter += 1
+            site = TACallSite(
+                member_name=f"_ta_pivot_point_levels_{self._ta_counter}",
+                class_name="_PFPivotPointLevels",
+                ctor_args=[],
+                compute_args=all_args[:3],
+                returns_tuple=False,
+                node=node,
+                is_static=False,
+                owner_func=(self._enclosing_func_names[-1]
+                            if self._enclosing_func_names else None),
+            )
+            self._ta_call_sites.append(site)
+            self._ta_member_names.add(site.member_name)
+            return PineType.FLOAT  # actual array<float> handled by type inference
+
+        # The one-arg forms ta.highest(length) / ta.lowest(length) /
+        # ta.highestbars(length) / ta.lowestbars(length), positional or
+        # ``length=``: the source defaults to high / low. Remap so all_args =
+        # [default_source, length_arg]; highestbars / lowestbars used to send
+        # the length to compute() as the source.
+        default_source = TA_LENGTH_ONLY_DEFAULT_SOURCE.get(func_name)
+        if default_source is not None and (
+                len(all_args) == 1 or (len(all_args) == 2 and all_args[0] is None)):
+            default_src = Identifier(name=default_source)
             self._visit(default_src)
-            self._series_bar_fields.add(_DEFAULT_SOURCE[func_name])
-            all_args = [default_src, all_args[0]]
+            self._series_bar_fields.add(default_source)
+            all_args = [default_src, all_args[-1]]
 
         self._ta_counter += 1
         class_name = TA_CLASS_MAP[func_name]
@@ -466,8 +578,8 @@ class CallHandlers:
         # vwap_bands special dispatch: ta.vwap(source, anchor, stdev_mult)
         # ctor receives stdev_mult only; compute receives source only.
         # The anchor arg (index 1) is the Pine-level "when to reset" series;
-        # our VWAPBands wrapper uses UTC-day boundaries matching the daily
-        # anchor default, so anchor is intentionally ignored in codegen.
+        # our VWAPBands wrapper resets on the symbol's session day, the
+        # default anchor, which is the only one the support checker admits.
         if func_name == "vwap_bands":
             ctor_args: list[str] = []
             if len(all_args) >= 3 and all_args[2] is not None:
@@ -492,6 +604,7 @@ class CallHandlers:
 
         # Determine constructor args
         ctor_args: list[str] = []
+        ctor_nodes: list = []
         effective_multi_ctor = TA_MULTI_CTOR.copy()
         if func_name in ("pivothigh", "pivotlow") and len(all_args) == 3:
             effective_multi_ctor[func_name] = [1, 2]
@@ -502,10 +615,12 @@ class CallHandlers:
             for idx in effective_multi_ctor[func_name]:
                 if idx < len(all_args) and all_args[idx] is not None:
                     ctor_args.append(self._expr_to_str(all_args[idx]))
+                    ctor_nodes.append(all_args[idx])
         elif func_name in TA_PERIOD_ARG:
             idx = TA_PERIOD_ARG[func_name]
             if idx < len(all_args) and all_args[idx] is not None:
                 ctor_args.append(self._expr_to_str(all_args[idx]))
+                ctor_nodes.append(all_args[idx])
 
         # Determine compute args (all args that aren't ctor args)
         compute_args: list = []
@@ -534,6 +649,7 @@ class CallHandlers:
             node=node,
             is_static=is_static,
             owner_func=(self._enclosing_func_names[-1] if self._enclosing_func_names else None),
+            ctor_nodes=ctor_nodes,
         )
         self._ta_call_sites.append(site)
         self._ta_member_names.add(site.member_name)
@@ -559,6 +675,59 @@ class CallHandlers:
             return self._security_symbol_is_heikinashi(self._global_expr_map[node.name], _seen)
         return False
 
+    def _security_callsite_tuple_types(
+        self,
+        func_name: str,
+        call: FuncCall,
+        element_types: tuple[PineType, ...],
+    ) -> tuple[PineType, ...]:
+        """Type the elements a helper's definition leaves untyped from this
+        request.security call's arguments (``f(high, 10)``: ``src[k]`` is a
+        float), following the helper's top-level declarations. An element
+        still untyped keeps ``UNKNOWN`` and is refused."""
+        fdef = self._func_defs.get(func_name)
+        if fdef is None or not fdef.body:
+            return element_types
+        final = fdef.body[-1]
+        final = final.expr if isinstance(final, ExprStmt) else final
+        if not isinstance(final, TupleLiteral) or len(final.elements) != len(element_types):
+            return element_types
+
+        def arg_type(arg) -> PineType:
+            if isinstance(arg, Identifier):
+                if arg.name in BAR_FIELDS:
+                    return PineType.FLOAT
+                if arg.name == "time":
+                    return PineType.INT
+                sym = self._symbols.resolve(arg.name)
+                if sym is not None and sym.pine_type in _SECURITY_TUPLE_ELEMENT_TYPES:
+                    return sym.pine_type
+            return self._callsite_primitive_expr_type(arg, {})
+
+        env: dict[str, PineType] = {}
+        for index, param in enumerate(fdef.params):
+            arg = call.kwargs.get(param)
+            if arg is None and index < len(call.args):
+                arg = call.args[index]
+            env[param] = arg_type(arg) if arg is not None else PineType.UNKNOWN
+        for stmt in fdef.body[:-1]:
+            if isinstance(stmt, VarDecl):
+                env[stmt.name] = (
+                    _HINT_TYPES.get(stmt.type_hint, PineType.UNKNOWN)
+                    if stmt.type_hint
+                    else self._callsite_primitive_expr_type(stmt.value, env)
+                )
+            elif isinstance(stmt, TupleAssign):
+                env.update((name, PineType.UNKNOWN) for name in stmt.names)
+        refined = []
+        for known, element in zip(element_types, final.elements):
+            if known == PineType.UNKNOWN:
+                typed = self._callsite_primitive_expr_type(element, env)
+                if typed in (PineType.INT, PineType.FLOAT, PineType.BOOL, PineType.STRING):
+                    known = typed
+            refined.append(known)
+        return tuple(refined)
+
     def _handle_request_call(self, func_name: str, node: FuncCall) -> PineType:
         """Handle request.* function calls."""
         if func_name == "security":
@@ -584,8 +753,9 @@ class CallHandlers:
 
             # Track TA sites created by the expression
             ta_start = len(self._ta_call_sites)
+            expr_type = None
             if expr_node is not None:
-                self._visit(expr_node)
+                expr_type = self._visit(expr_node)
             ta_end = len(self._ta_call_sites)
             security_ta_range = (ta_start, ta_end) if ta_end > ta_start else None
 
@@ -612,26 +782,30 @@ class CallHandlers:
                     if self._func_returns_tuple.get(expr_func, False):
                         tuple_size = self._func_tuple_element_count.get(expr_func, 0)
                         tuple_types = self._func_tuple_element_types.get(expr_func, ())
-                        numeric_tuple = (
+                        if PineType.UNKNOWN in tuple_types:
+                            tuple_types = self._security_callsite_tuple_types(
+                                expr_func, expr_node, tuple_types
+                            )
+                        # TradingView returns a tuple of any mix of scalars. A
+                        # bool element keeps a bool slot, a string element a
+                        # string slot; every numeric element, and one whose type
+                        # is not inferred (``src[k]`` of a parameter), keeps the
+                        # double storage of the numeric family.
+                        scalar_tuple = (
                             tuple_size >= 2
                             and len(tuple_types) == tuple_size
                             and all(
-                                item in (PineType.INT, PineType.FLOAT)
+                                item in _SECURITY_TUPLE_ELEMENT_TYPES
                                 for item in tuple_types
                             )
                         )
-                        bool_tuple = (
-                            tuple_size >= 2
-                            and len(tuple_types) == tuple_size
-                            and all(item == PineType.BOOL for item in tuple_types)
-                        )
-                        if not (numeric_tuple or bool_tuple):
+                        if not scalar_tuple:
                             inferred_types = ", ".join(
                                 item.value for item in tuple_types
                             ) or "unknown"
                             self._error(
                                 "request.security tuple-return helpers support two or more "
-                                "numeric int/float elements or homogeneous bool elements; inferred "
+                                "int, float, bool or string elements; inferred "
                                 f"{tuple_size} element(s) [{inferred_types}]",
                                 expr_node.loc,
                             )
@@ -657,10 +831,16 @@ class CallHandlers:
             lookahead_node = all_args[4] if len(all_args) > 4 else None
 
             mutable_globals = tuple(sorted(self._collect_security_mutable_globals(expr_node)))
+            # A helper request's symbol and timeframe, resolved through its
+            # call paths (``security_contexts``), register in its place.
+            notes = node.annotations or {}
+            context = notes.get(CONTEXT_ANNOTATION)
+            symbol_node = all_args[0] if all_args else None
+            if context is not None:
+                symbol_node, tf_node = context["symbol"], context["timeframe"]
             # Heikin-Ashi same-symbol read: request.security(ticker.heikinashi(
             # syminfo.tickerid), ...) (directly or via a global alias). The engine
             # applies the HA candle transform inside the security eval.
-            symbol_node = all_args[0] if all_args else None
             heikinashi = self._security_symbol_is_heikinashi(symbol_node)
             # Capture the user function (if any) whose body contains this call,
             # so the codegen can resolve a parameter ``tf`` via the call sites.
@@ -668,6 +848,14 @@ class CallHandlers:
             containing_func = scope_name[5:] if scope_name.startswith("func_") else ""
             if returns_tuple and tuple_element_types:
                 self._tuple_element_types_by_node[id(node)] = tuple_element_types
+            # A helper whose value is this request returns its tuple
+            # (``htf(sym, tf) => request.security(sym, tf, pack())``); a TA
+            # tuple's result struct is not one.
+            if returns_tuple and (isinstance(expr_node, TupleLiteral) or tuple_element_types):
+                self._security_tuple_shapes[id(node)] = tuple_size
+            # A string payload returns a string (TradingView's na string reads
+            # empty); every other scalar keeps the historical float result.
+            string_result = not returns_tuple and expr_type == PineType.STRING
             self._security_calls.append(SecurityCallInfo(
                 sec_id=sec_id,
                 timeframe=tf_node,
@@ -682,9 +870,15 @@ class CallHandlers:
                 depends_on_mutable_globals=bool(mutable_globals),
                 mutable_globals=mutable_globals,
                 containing_func=containing_func,
+                string_result=string_result,
+                symbol=symbol_node,
+                context_resolved=context is not None,
+                dead=bool(notes.get(DEAD_ANNOTATION)),
+                foreign=notes.get(LOWERING_ANNOTATION) == FEED_LOWERING,
+                ignore_invalid=node.kwargs.get("ignore_invalid_symbol"),
             ))
 
-            return PineType.FLOAT
+            return PineType.STRING if string_result else PineType.FLOAT
 
         if func_name == "security_lower_tf":
             return self._handle_request_security_lower_tf(node)
@@ -788,9 +982,11 @@ class CallHandlers:
         sec_id = len(self._security_calls)
 
         mutable_globals = tuple(sorted(self._collect_security_mutable_globals(expr_node)))
+        notes = node.annotations or {}
+        context = notes.get(CONTEXT_ANNOTATION)
         self._security_calls.append(SecurityCallInfo(
             sec_id=sec_id,
-            timeframe=tf_node,
+            timeframe=context["timeframe"] if context is not None else tf_node,
             expression=expr_node,
             returns_tuple=False,
             tuple_size=0,
@@ -800,6 +996,8 @@ class CallHandlers:
             depends_on_mutable_globals=bool(mutable_globals),
             mutable_globals=mutable_globals,
             is_lower_tf_array=True,
+            context_resolved=context is not None,
+            dead=bool(notes.get(DEAD_ANNOTATION)),
         ))
 
         # ``request.security_lower_tf`` returns an array; the value-level
@@ -1282,6 +1480,9 @@ class CallHandlers:
                 and isinstance(node.callee, MemberAccess)
             ):
                 positional_args.insert(0, node.callee.object)
+        param_defaults = list(
+            (func_def.annotations or {}).get("param_defaults", ())
+        )
         for p_idx, param_name in enumerate(func_def.params):
             if p_idx < len(positional_args):
                 param_arg_map[param_name] = self._expr_to_str(
@@ -1291,6 +1492,13 @@ class CallHandlers:
                 param_arg_map[param_name] = self._expr_to_str(
                     node.kwargs[param_name]
                 )
+            elif (method_info is None
+                    and p_idx < len(param_defaults)
+                    and param_defaults[p_idx] is not None):
+                # An omitted parameter reads its declared default.
+                param_arg_map[param_name] = self._expr_to_str(
+                    param_defaults[p_idx]
+                )
 
         if func_name in self._func_ta_ranges:
             start, end = self._func_ta_ranges[func_name]
@@ -1457,6 +1665,7 @@ class CallHandlers:
                         node=orig.node,
                         is_static=orig.is_static,
                         owner_func=func_name,
+                        ctor_nodes=orig.ctor_nodes[:],
                     )
                     selected_ta_indices[i] = len(self._ta_call_sites)
                     self._ta_call_sites.append(cloned)
@@ -1535,6 +1744,17 @@ class CallHandlers:
             visited_types[id(arg)] = self._visit(arg)
         for arg in node.kwargs.values():
             visited_types[id(arg)] = self._visit(arg)
+        # An omitted parameter binds its declared default, as codegen passes it.
+        defaulted = bind_function_defaults(
+            func_def.params,
+            (func_def.annotations or {}).get("param_defaults", ()),
+            node,
+        )
+        if defaulted is not None:
+            bound_args = list(defaulted)
+            for arg in bound_args:
+                if id(arg) not in visited_types:
+                    visited_types[id(arg)] = self._visit(arg)
 
         param_types = [
             visited_types.get(id(arg), PineType.UNKNOWN)

package/pineforge_codegen/analyzer/contracts.py

@@ -51,6 +51,12 @@ class TACallSite:
     # owning callee's emitted clone body referencing undeclared members
     # (regression: quantbyboji-nq-hma-midday ``_ta_change_*_cs1``).
     owner_func: str | None = None
+    # The AST nodes ``ctor_args`` were spelled from, in the same order (the
+    # nodes of the textual call: a clone keeps its template's). Empty for the
+    # shim sites that build their ctor args another way. The series- and
+    # simple-length lowering renders a length the constructor cannot take
+    # from these at the call site.
+    ctor_nodes: list = field(default_factory=list)
 
 
 @dataclass
@@ -174,6 +180,22 @@ class SecurityCallInfo:
     # body (``self._active_call_site_idx``). None for an ordinary
     # (non-cloned) security call.
     callsite_idx: int | None = None
+    # A scalar payload of string type: the result is a ``std::string``
+    # holding na (empty) until the first requested value.
+    string_result: bool = False
+    # The call's symbol argument (None when omitted).
+    symbol: Any = None
+    # ``timeframe`` and ``symbol`` hold the context
+    # ``security_contexts.specialize_security_contexts`` resolved through the
+    # helper call paths: expressions of globals, inputs and built-ins.
+    context_resolved: bool = False
+    # The call sits in a helper no top-level statement reaches: it never runs.
+    dead: bool = False
+    # Another symbol's request that reads the feed a requests manifest pins
+    # for it (``external_requests.FEED_LOWERING``): registered with the
+    # ``symbol`` string and ``ignore_invalid_symbol`` (the node, or None).
+    foreign: bool = False
+    ignore_invalid: Any = None
 
 
 @dataclass
@@ -268,6 +290,15 @@ class AnalyzerContext:
     # emits each call site's body — required for the per-clone
     # SecurityCallInfo.callsite_idx disambiguation in visit_call.py to work.
     func_security_clone_only: set = field(default_factory=set)
+    # Functions and methods that cannot keep a session.* flag's history per
+    # call site (name -> why): every method, and the functions a method, a
+    # request.security expression or a UDT field default reaches. Codegen
+    # refuses a session.<flag>[k] it emits in one of them.
+    session_history_unsafe: dict = field(default_factory=dict)
+    # Functions that read a flag at an offset this analysis did not clone:
+    # no per-call Series. A read of theirs the C++ holds asks
+    # pineforge_codegen._generate to clone them.
+    session_uncloned: frozenset = frozenset()
     # (func_name, cs_idx) -> {orig_member_name: cloned_member_name}. Populated by
     # the analyzer ONLY for clones whose default ``{base}_cs{cs_idx}`` name would
     # collide with a clone minted through another enclosing function; lets codegen
@@ -301,6 +332,12 @@ class AnalyzerContext:
     # global read remains lexical Pine, not the future local).
     func_var_storage_names: dict = field(default_factory=dict)
     func_series_vars: dict = field(default_factory=dict)
+    # Plain UDF -> script variables (and ``bar_index``) its body reads through
+    # history, in source order, and id(Subscript) -> (UDF, name, Subscript)
+    # per read. TradingView keeps that history per call site, so codegen gives
+    # each emitted body its own chart-clocked buffer of the variable.
+    func_global_history_reads: dict = field(default_factory=dict)
+    func_global_history_nodes: dict = field(default_factory=dict)
     # FuncDef owner -> declaration-bound non-persistent history-local names.
     # Parameters are deliberately excluded so a same-named qualified
     # persistent member does not manufacture a bogus raw/clone Series.

package/pineforge_codegen/analyzer/diagnostics.py

@@ -27,9 +27,11 @@ from __future__ import annotations
 
 from ..ast_nodes import (
     ASTNode, BinOp, BoolLiteral, FuncCall, Identifier, MemberAccess,
-    NaLiteral, NumberLiteral, StringLiteral, Subscript, Ternary, UnaryOp,
+    NaLiteral, NumberLiteral, StringLiteral, Subscript, Ternary, TupleLiteral,
+    UnaryOp,
 )
 from ..errors import CompileError, Diagnostic, Level, Phase, SourceLocation
+from ..pine_spelling import input_binding_names, is_input_call, pine_string_literal
 from .. import tv_input_choices as tv_in
 from .tables import BAR_FIELDS
 
@@ -96,6 +98,18 @@ class DiagnosticsHelper:
     # would otherwise silently reassociate under C++ precedence.
     _NONATOMIC_EXPR_NODES = (BinOp, UnaryOp, Ternary)
 
+    def _input_binding_name(self, node: FuncCall) -> str | None:
+        """The declared name an untitled global-scope input call is keyed by
+        (``pine_spelling.input_binding_names``), or None. Every input takes its
+        title as argument #2 or ``title=``."""
+        if len(node.args) > 1 or "title" in node.kwargs:
+            return None
+        names = getattr(self, "_input_binding_names_cache", None)
+        if names is None:
+            names = input_binding_names(self._ast.body)
+            self._input_binding_names_cache = names
+        return names.get(id(node))
+
     def _operand_to_str(self, node: ASTNode) -> str:
         s = self._expr_to_str(node)
         if isinstance(node, self._NONATOMIC_EXPR_NODES):
@@ -108,7 +122,7 @@ class DiagnosticsHelper:
         if isinstance(node, NumberLiteral):
             return str(node.value)
         if isinstance(node, StringLiteral):
-            return f'"{node.value}"'
+            return pine_string_literal(node.value)
         if isinstance(node, BoolLiteral):
             return "true" if node.value else "false"
         if isinstance(node, NaLiteral):
@@ -122,9 +136,21 @@ class DiagnosticsHelper:
         if isinstance(node, UnaryOp):
             return f"{node.op}{self._operand_to_str(node.operand)}"
         if isinstance(node, FuncCall):
-            args = ", ".join(self._expr_to_str(a) for a in node.args)
+            args = [self._expr_to_str(a) for a in node.args]
+            if is_input_call(node):
+                # The codegen reads an inline input's title, defval and bounds
+                # back from this spelling; without its keyword arguments
+                # ``input.int(defval=9, title="fast")`` would become
+                # ``input.int()``. An untitled call a declaration names (a
+                # ``var`` initializer's) is keyed by that name, spelled title=.
+                args += [f"{k}={self._expr_to_str(v)}" for k, v in node.kwargs.items()]
+                bound = self._input_binding_name(node)
+                if bound is not None:
+                    args.append(f"title={pine_string_literal(bound)}")
             callee_str = self._expr_to_str(node.callee)
-            return f"{callee_str}({args})"
+            return f"{callee_str}({', '.join(args)})"
+        if isinstance(node, TupleLiteral):
+            return "[" + ", ".join(self._expr_to_str(e) for e in node.elements) + "]"
         if isinstance(node, Subscript):
             return f"{self._expr_to_str(node.object)}[{self._expr_to_str(node.index)}]"
         if isinstance(node, Ternary):