@pineforge/codegen-pyodide 0.10.4 → 1.0.0

package/pineforge_codegen/support_checker.py

@@ -8,7 +8,11 @@ own analyzer/codegen/signatures modules so the checker cannot drift.
 Buckets:
 
 * HARD_REJECT_FUNC / HARD_REJECT_NAMESPACE - calls that have no PineForge
-  semantics at all (e.g. ``request.financial``, ``ticker.*``).
+  semantics at all (e.g. ``request.seed``, ``ticker.new``).
+* NO_DATA_REQUEST_FUNC - requests PineForge has no data for
+  (``request.financial``, ...): refused only when their value can reach a
+  trade; one that reaches display and alert sinks only is lowered to na
+  (``external_requests``). ``request.security`` on another symbol too.
 * DIVERGENT_VARS - built-in variables whose PineForge value diverges from
   TradingView. They are reported as WARNING (e.g. ``bar_index`` and
   ``last_bar_index`` depend on the fed data window, ``timenow`` is not
@@ -18,7 +22,8 @@ Buckets:
 * NOT_YET - calls the runtime could support but the transpiler does not yet
   emit (e.g. ``max_bars_back``, bare ``barssince``).
 * request.security - only ``symbol`` / ``timeframe`` / ``expression`` allowed,
-  symbol must be the current chart symbol.
+  symbol must be the current chart symbol (a helper parameter's through its
+  call sites), or the value must reach display and alert sinks only.
 * Declarations - only ``strategy(...)`` accepted; ``indicator(...)`` and
   ``library(...)`` rejected.
 * Unknown ``ta.X`` / ``math.X`` / ``str.X`` / ``input.X`` calls (codegen would
@@ -27,11 +32,12 @@ Buckets:
 
 from __future__ import annotations
 
+import re
 from typing import Callable
 
 from .ast_nodes import (
     ASTNode,
-    Program, StrategyDecl,
+    Program, StrategyDecl, ImportStmt, TypeField,
     VarDecl, Assignment, TupleAssign,
     IfStmt, ForStmt, ForInStmt, WhileStmt, SwitchStmt,
     FuncDef, ExprStmt,
@@ -42,6 +48,16 @@ from .ast_nodes import (
     TypeDecl, EnumDecl, MethodDef,
 )
 from .errors import SourceLocation, Diagnostic, CompileError, Level, Phase
+from .builtin_keywords import POSITIONAL_BUILTINS
+from .pine_spelling import expr_start
+from .external_requests import (
+    ABSENT_LOWERING, CHART_FALLBACK_ANNOTATION, FEED_LOWERING, FEED_WARNING_ANNOTATION,
+    FOOTPRINT_COLUMN_ANNOTATION, LOWERING_ANNOTATION, NO_DATA_REQUEST_FUNCS,
+    RECORDED_LOWERING, FootprintValues, TradeSlice, footprint_column, recorded_key,
+    spell_call,
+)
+from .external_requests import _nodes as _walk_nodes
+from .security_contexts import ticker_symbol_arg
 from . import signatures as sigs
 from .tv_input_choices import INPUT_SOURCE_SERIES_IDS
 from .analyzer import TA_CLASS_MAP
@@ -68,7 +84,9 @@ TA_PROPERTY_VARIABLES: frozenset[str] = frozenset(
     {"obv", "accdist", "nvi", "pvi", "pvt", "wad", "wvad", "iii"}
 )
 SUPPORTED_TA: frozenset[str] = frozenset(
-    set(TA_CLASS_MAP) - {"sum", "vwap_bands"} - set(TA_PROPERTY_VARIABLES) | {"tr", "pivot_point_levels"}
+    set(TA_CLASS_MAP) - {
+        "sum", "vwap_bands", "vwap_anchored", "vwap_anchored_bands"
+    } - set(TA_PROPERTY_VARIABLES) | {"tr", "pivot_point_levels"}
 )
 SUPPORTED_MATH: frozenset[str] = frozenset(
     set(MATH_FUNC_MAP) | set(sigs.MATH_CONSTANTS) | set(sigs.MATH_FUNCTIONS)
@@ -113,8 +131,9 @@ _VISUAL_CONTAINER_TYPES: frozenset[str] = _DRAWING_TYPE_NAMES | frozenset({"tabl
 SUPPORTED_COLOR_CONST: frozenset[str] = frozenset(COLOR_CONST_MAP)
 SUPPORTED_COLOR_FUNC: frozenset[str] = frozenset({"new", "rgb", "r", "g", "b", "t"})
 # Cosmetic color builders with no backtest-logic effect. Warned (not rejected);
-# codegen emits a benign default color (0 = na color). color.from_gradient is a
-# charting/plot helper that only tints visual output.
+# codegen evaluates the arguments (their side effects and history are
+# TradingView's) and emits a benign default color (0 = na color).
+# color.from_gradient is a charting/plot helper that only tints visual output.
 COSMETIC_COLOR_FUNC: frozenset[str] = frozenset({"from_gradient"})
 SUPPORTED_TIMEFRAME_FUNC: frozenset[str] = frozenset({"change", "in_seconds"})
 SUPPORTED_RUNTIME_FUNC: frozenset[str] = frozenset({"error"})
@@ -124,11 +143,21 @@ SUPPORTED_RUNTIME_FUNC: frozenset[str] = frozenset({"error"})
 # string statement that hides the typo from the strategy author.
 SUPPORTED_LOG: frozenset[str] = frozenset({"info", "warning", "error"})
 
-HARD_REJECT_FUNC: dict[str, str] = {
+# Requests PineForge has no data for (``external_requests``): refused only
+# when their value can reach a trade; one that reaches display and alert sinks
+# only is lowered to na with a warning. ``request.security`` on another
+# symbol follows the same rule when it reads no feed; ``request.footprint``
+# as its whole expression reads the feed's delta column.
+NO_DATA_REQUEST_FUNC: dict[str, str] = {
     "request.financial":         "External fundamentals data not available in PineForge.",
     "request.dividends":         "External corporate-action data not available in PineForge.",
     "request.earnings":          "External corporate-action data not available in PineForge.",
     "request.splits":            "External corporate-action data not available in PineForge.",
+    "request.footprint":         "Footprint (bid/ask volume) data not available in PineForge.",
+}
+assert set(NO_DATA_REQUEST_FUNC) == {f"request.{n}" for n in NO_DATA_REQUEST_FUNCS}
+
+HARD_REJECT_FUNC: dict[str, str] = {
     "request.seed":              "External seed data feeds not available in PineForge.",
     "request.quandl":            "External Quandl data not available in PineForge.",
     "request.currency_rate":     "Currency conversion data not available in PineForge.",
@@ -335,16 +364,29 @@ UNSUPPORTED_CONST_NAMESPACES: dict[str, str] = {
     "xloc":     _CONST_NS_VISUAL_MSG,
     "yloc":     _CONST_NS_VISUAL_MSG,
     "barmerge": (
-        "is only valid as the gaps/lookahead argument of "
-        "request.security(...); it has no runtime value as a free "
-        "expression in PineForge."
+        "is not a barmerge constant; only barmerge.gaps_on, "
+        "barmerge.gaps_off, barmerge.lookahead_on and barmerge.lookahead_off "
+        "exist."
     ),
     "alert": (
-        "is only valid as the freq argument of alert(...); it has no "
-        "runtime value as a free expression in PineForge."
+        "is not a Pine alert constant; only alert.freq_all, "
+        "alert.freq_once_per_bar and alert.freq_once_per_bar_close exist."
     ),
 }
 
+# ``barmerge.*`` are constants with a value: a script may hold one
+# (TradingView/Request/3: ``var gapStrategy = gaps ? barmerge.gaps_on :
+# barmerge.gaps_off``) and compare it. As a request's gaps or lookahead only
+# the constant itself is read (``_check_request_security``).
+BARMERGE_MEMBERS = frozenset({"gaps_on", "gaps_off", "lookahead_on", "lookahead_off"})
+
+# ``alert.freq_*`` are const strings with a runtime value ("all",
+# "once_per_bar", "once_per_bar_close" on TradingView's own tape), so they
+# are ordinary values wherever they appear.
+ALERT_FREQ_MEMBERS = frozenset({
+    "freq_all", "freq_once_per_bar", "freq_once_per_bar_close",
+})
+
 # Namespaces whose variable members have no batch-mode data source.
 # These reads currently emit `std::string("<member>")` via the
 # unknown-identifier fallthrough — which the analyzer-typed `double`
@@ -359,10 +401,10 @@ UNSUPPORTED_NAMESPACE_VARS: dict[str, str] = {
 # Codegen supports symbol/timeframe/expression plus gaps/lookahead (read in
 # _eval_security_* emission and forwarded to register_security_eval).
 # `currency` is still rejected loudly (it changes the returned values via FX
-# conversion, which codegen drops — silently wrong). `ignore_invalid_symbol` is
-# a guaranteed no-op here: codegen forces request.security onto the current
-# chart symbol (see the "symbol must reference current chart symbol" check),
-# which is always valid, so the flag can never change the result — accept+ignore.
+# conversion, which codegen drops — silently wrong). `ignore_invalid_symbol`
+# is registered with a request of another symbol that reads its pinned feed
+# (na for a symbol its facts say is invalid); the chart's own symbol is always
+# valid, where the flag changes nothing.
 SECURITY_ALLOWED_PARAMS: frozenset[str] = frozenset(
     {"symbol", "timeframe", "expression", "gaps", "lookahead",
      "ignore_invalid_symbol",
@@ -393,6 +435,77 @@ SECURITY_ADJUSTMENT_ALLOWED_VALUES: dict[str, frozenset[str]] = {
 # Identifiers/expressions that resolve to "this script's symbol".
 SECURITY_CURRENT_SYMBOL_NAMES: frozenset[str] = frozenset({"syminfo.tickerid", "syminfo.ticker"})
 
+# Built-in namespaces a library import may alias, with their built-in
+# members. TradingView's pine-facade compile of ``import TradingView/ta/7``
+# links no library (``metaInfo.usedLibs`` stays empty) when the script names
+# only built-in ``ta.*`` members, and links it for a library-only name such
+# as ``ta.dema`` (XSYM-DESIGN report 1.3): such an import is a no-op. Every
+# other import stays refused.
+BUILTIN_NAMESPACE_IMPORT_MEMBERS: dict[str, frozenset[str]] = {
+    "ta": frozenset(sigs.TA_FUNCTIONS) | TA_PROPERTY_VARIABLES,
+    "math": frozenset(sigs.MATH_FUNCTIONS) | frozenset(sigs.MATH_CONSTANTS),
+    "str": frozenset(sigs.STR_FUNCTIONS),
+}
+
+
+def import_spelling(node: ImportStmt) -> str:
+    """The import as the refusal names it: ``user/name/version [as alias]``."""
+    return f"{node.path} as {node.alias}" if node.alias else node.path
+
+
+def import_refusal(node: ImportStmt) -> str:
+    """The refusal of an import PineForge did not inline, with the reason the
+    library inliner recorded when library sources were configured but none
+    applies to the script (``pine_libraries``)."""
+    message = f"Import is not supported: '{import_spelling(node)}'"
+    reason = (node.annotations or {}).get("unresolved_reason")
+    return f"{message}: {reason}" if reason else message
+
+
+def import_is_builtin_namespace_no_op(program: Program, node: ImportStmt) -> bool:
+    """``node`` imports a library under the name of a built-in namespace
+    (its alias, else its own name) and every member the script names through
+    that alias -- in a call, a read or a type -- is one of the namespace's
+    built-ins, so the library is never linked."""
+    alias = node.alias or node.name
+    members = BUILTIN_NAMESPACE_IMPORT_MEMBERS.get(alias or "")
+    if node.version is None or members is None:
+        return False
+    named = re.compile(rf"(?<![\w.]){re.escape(alias)}\.(\w+)")
+
+    def type_names(value) -> list[str]:
+        if isinstance(value, str):
+            return [value]
+        if isinstance(value, (list, tuple)):
+            return [item for item in value if isinstance(item, str)]
+        return []
+
+    stack: list = [program]
+    while stack:
+        item = stack.pop()
+        if isinstance(item, (list, tuple)):
+            stack.extend(item)
+            continue
+        if isinstance(item, dict):
+            stack.extend(item.values())
+            continue
+        if not isinstance(item, (ASTNode, TypeField)):
+            continue
+        if (isinstance(item, MemberAccess) and isinstance(item.object, Identifier)
+                and item.object.name == alias and item.member not in members):
+            return False
+        hints = [getattr(item, "type_hint", None), getattr(item, "type_name", None)]
+        notes = getattr(item, "annotations", None) or {}
+        hints += [notes.get("param_type_hints"), notes.get("template_args")]
+        for hint in hints:
+            for text in type_names(hint):
+                if any(m not in members for m in named.findall(text)):
+                    return False
+        for key, value in vars(item).items():
+            if key not in ("loc", "annotations"):
+                stack.append(value)
+    return True
+
 
 # ---------------------------------------------------------------------------
 # Helpers
@@ -404,6 +517,18 @@ def _loc(node: ASTNode | None, fallback_file: str) -> SourceLocation:
     return SourceLocation(file=fallback_file, line=1, col=1, end_col=1)
 
 
+def _security_gaps_lookahead(node: FuncCall) -> tuple[ASTNode | None, ASTNode | None]:
+    """A ``request.security`` call's gaps and lookahead arguments, positional
+    or keyword (None where it leaves one out)."""
+    gaps = node.kwargs.get("gaps")
+    if gaps is None and len(node.args) > 3:
+        gaps = node.args[3]
+    lookahead = node.kwargs.get("lookahead")
+    if lookahead is None and len(node.args) > 4:
+        lookahead = node.args[4]
+    return gaps, lookahead
+
+
 def _qualified_name(callee: ASTNode) -> tuple[str | None, str | None]:
     """Return (namespace, function_name) for a call's callee, or (None, None)."""
     if isinstance(callee, Identifier):
@@ -457,6 +582,9 @@ class SupportChecker:
         for member, emission in SYMINFO_MEMBER_MAP.items()
         if "na<" in emission or "get_syminfo_metadata" in emission
     )
+    # Silent-gap fields a run declares as a symbol fact (a lane fact through
+    # the syminfo metadata channel): na only when the run declares none.
+    _SYMINFO_RUN_FACT_FIELDS: frozenset[str] = frozenset({"mincontract"})
 
     def __init__(self, ast: Program, filename: str = "<input>") -> None:
         self._ast = ast
@@ -498,12 +626,28 @@ class SupportChecker:
         self._func_tuple_drawing_returns: dict[str, list[bool]] = {}
         # Track whether we are inside an if/ternary condition expression.
         self._in_conditional_depth: int = 0
+        # Inside a switch's non-default arm, which the checker used to skip:
+        # its findings warn (``_err``).
+        self._switch_arm_depth: int = 0
         # Track whether we are inside an argument subtree that legitimately
         # consumes constant-namespace members: parse-and-skip visual calls
         # (plot, label.new, ...), the strategy() declaration, and
         # request.security (barmerge.* gaps/lookahead values). While > 0 the
         # UNSUPPORTED_CONST_NAMESPACES rejection is suppressed.
         self._const_arg_ctx_depth: int = 0
+        # Inside the arguments of a request PineForge has no data for, whose
+        # field constants (``earnings.actual``) name what it would read.
+        self._request_field_ctx_depth: int = 0
+        # request.footprint calls that are the whole expression of a request
+        # of another symbol reading its feed (_lower_foreign_request).
+        self._feed_footprints: set[int] = set()
+        # Inside a request.security call's arguments (its expression).
+        self._security_payload_depth: int = 0
+        self._footprints: FootprintValues | bool | None = None
+        # Built on the first request with no data: which values reach a trade.
+        self._trade_slice: TradeSlice | None = None
+        # The helpers a request expression calls (_in_request_expression).
+        self._payload_funcs: set[str] | None = None
         # id()s of Identifier/MemberAccess nodes that are the *callee* of a
         # FuncCall. A divergent built-in NAME used as a call target (e.g. the
         # session-aware ``time_close("D")`` function, which is distinct from the
@@ -524,12 +668,36 @@ class SupportChecker:
         # (below) as well as during the visit, so a rebind that lexically
         # FOLLOWS the request.security call cannot slip past.
         self._scalar_rebinds: dict[str, list[ASTNode]] = {}
+        self._scalar_rebind_ids: set[int] = set()
+        # request.security needs lexical bindings rather than bare names: a
+        # function-local `sym := ...` cannot change an unrelated global `sym`.
+        # Indexed before the visit so rebinds after a security call count too.
+        self._security_symbol_refs: dict[int, object] = {}
+        self._security_symbol_defs: dict[object, ASTNode] = {}
+        self._security_symbol_rebinds: dict[object, list[ASTNode]] = {}
+        # Names declared ``var`` / ``varip`` anywhere: their declaration value
+        # is the first bar's only, so it does not describe later bars.
+        self._persistent_decl_names: set[str] = set()
+        # How many times each name is bound anywhere in the script -- a
+        # declaration, a callable parameter, a loop variable, a tuple element
+        # -- so a constant argument read through a name is trusted only when
+        # that name has exactly one binding and no scope can shadow it.
+        self._binding_counts: dict[str, int] = {}
+        # User functions by node id, and every call of each by name, so a
+        # request.security symbol that is a helper parameter resolves through
+        # the arguments of the helper's calls.
+        self._user_func_defs: dict[int, FuncDef] = {}
+        self._user_func_calls: dict[str, list[FuncCall]] = {}
+        self._overloaded_user_funcs: set[str] = set()
 
     # -- Public API --
 
     def check(self) -> list[Diagnostic]:
         self._collect_user_definitions(self._ast)
+        self._collect_user_calls()
         self._collect_scalar_rebinds(self._ast)
+        self._index_security_symbol_bindings()
+        self._count_bindings(self._ast)
         for stmt in self._ast.body:
             self._visit(stmt)
         return self._diagnostics
@@ -552,9 +720,11 @@ class SupportChecker:
         target = node.target
         if not isinstance(target, Identifier) or node.value is None:
             return
-        recorded = self._scalar_rebinds.setdefault(target.name, [])
-        if not any(value is node.value for value in recorded):
-            recorded.append(node.value)
+        # A set, not a scan of the list: a name reassigned k times would
+        # otherwise cost k**2.
+        if id(node.value) not in self._scalar_rebind_ids:
+            self._scalar_rebind_ids.add(id(node.value))
+            self._scalar_rebinds.setdefault(target.name, []).append(node.value)
 
     def _collect_scalar_rebinds(self, node: ASTNode) -> None:
         """Pre-pass: collect every scalar rebind anywhere in the AST.
@@ -578,6 +748,155 @@ class SupportChecker:
                     if isinstance(item, ASTNode):
                         self._collect_scalar_rebinds(item)
 
+    def _collect_user_calls(self) -> None:
+        """Index the user functions and every call of each, anywhere."""
+        names: dict[str, int] = {}
+        for stmt in self._ast.body:
+            if isinstance(stmt, FuncDef):
+                self._user_func_defs[id(stmt)] = stmt
+                names[stmt.name] = names.get(stmt.name, 0) + 1
+        self._overloaded_user_funcs = {n for n, count in names.items() if count > 1}
+        stack: list = [self._ast]
+        while stack:
+            item = stack.pop()
+            if isinstance(item, (list, tuple)):
+                stack.extend(item)
+                continue
+            if isinstance(item, dict):
+                stack.extend(item.values())
+                continue
+            if not isinstance(item, ASTNode):
+                continue
+            if (isinstance(item, FuncCall) and isinstance(item.callee, Identifier)
+                    and item.callee.name in names):
+                self._user_func_calls.setdefault(item.callee.name, []).append(item)
+            stack.extend(value for key, value in vars(item).items()
+                         if key not in ("loc", "annotations"))
+
+    def _index_security_symbol_bindings(self) -> None:
+        """Bind symbol reads and every ``:=`` to their lexical declaration.
+
+        Declarations in a function, branch or loop body shadow outer names;
+        reassignments without a local declaration resolve outwards. The
+        whole-block index keeps later rebinds visible to an earlier security
+        call, matching the existing conservative check.
+        """
+        def resolve(name: str, scopes: tuple[dict[str, object], ...]) -> object | None:
+            for scope in reversed(scopes):
+                if name in scope:
+                    return scope[name]
+            return None
+
+        def walk_value(value: object, scopes: tuple[dict[str, object], ...]) -> None:
+            if isinstance(value, ASTNode):
+                walk(value, scopes)
+            elif isinstance(value, (list, tuple)):
+                for item in value:
+                    walk_value(item, scopes)
+            elif isinstance(value, dict):
+                for item in value.values():
+                    walk_value(item, scopes)
+
+        def block(statements: list, scopes: tuple[dict[str, object], ...],
+                  binders: dict[str, object] | None = None) -> None:
+            scope = dict(binders or {})
+            for stmt in statements:
+                if isinstance(stmt, VarDecl) and stmt.name:
+                    binding = id(stmt)
+                    scope.setdefault(stmt.name, binding)
+                    if stmt.value is not None:
+                        self._security_symbol_defs[binding] = stmt.value
+                elif isinstance(stmt, TupleAssign):
+                    for name in stmt.names:
+                        scope.setdefault(name, ("tuple", id(stmt), name))
+            nested = (*scopes, scope)
+            for stmt in statements:
+                walk_value(stmt, nested)
+
+        def walk(node: ASTNode, scopes: tuple[dict[str, object], ...]) -> None:
+            if isinstance(node, Identifier):
+                binding = resolve(node.name, scopes)
+                if binding is not None:
+                    self._security_symbol_refs[id(node)] = binding
+                return
+            if isinstance(node, Assignment):
+                if isinstance(node.target, Identifier) and node.value is not None:
+                    binding = resolve(node.target.name, scopes)
+                    if binding is not None:
+                        self._security_symbol_rebinds.setdefault(binding, []).append(node.value)
+                walk_value(node.target, scopes)
+                walk_value(node.value, scopes)
+                return
+            if isinstance(node, (FuncDef, MethodDef)):
+                params = {name: ("param", id(node), name) for name in node.params}
+                block(node.body, scopes, params)
+                return
+            if isinstance(node, IfStmt):
+                walk_value(node.condition, scopes)
+                block(node.body, scopes)
+                block(node.else_body, scopes)
+                return
+            if isinstance(node, ForStmt):
+                for value in (node.start, node.end, node.step):
+                    walk_value(value, scopes)
+                block(node.body, scopes, {node.var: ("loop", id(node), node.var)})
+                return
+            if isinstance(node, ForInStmt):
+                walk_value(node.iterable, scopes)
+                names = [node.var] if node.var else list(node.vars or ())
+                block(node.body, scopes, {
+                    name: ("loop", id(node), name) for name in names
+                })
+                return
+            if isinstance(node, WhileStmt):
+                walk_value(node.condition, scopes)
+                block(node.body, scopes)
+                return
+            if isinstance(node, SwitchStmt):
+                walk_value(node.expr, scopes)
+                for case_expr, body in node.cases:
+                    walk_value(case_expr, scopes)
+                    block(body, scopes)
+                block(node.default_body, scopes)
+                return
+            for value in vars(node).values():
+                walk_value(value, scopes)
+
+        block(self._ast.body, ())
+
+    def _count_bindings(self, node) -> None:
+        """Pre-pass: count every binding of every name (``_binding_counts``)."""
+        if isinstance(node, list):
+            for item in node:
+                self._count_bindings(item)
+            return
+        if not isinstance(node, ASTNode):
+            return
+        names: list = []
+        if isinstance(node, VarDecl):
+            names = [node.name]
+        elif isinstance(node, (FuncDef, MethodDef)):
+            names = list(node.params)
+        elif isinstance(node, ForStmt):
+            names = [node.var]
+        elif isinstance(node, ForInStmt):
+            names = [node.var] if node.var else list(node.vars or ())
+        elif isinstance(node, TupleAssign):
+            names = list(node.names)
+        for name in names:
+            name = name if isinstance(name, str) else getattr(name, "name", None)
+            if name:
+                self._binding_counts[name] = self._binding_counts.get(name, 0) + 1
+        for key, value in vars(node).items():
+            if key in ("loc", "annotations"):
+                continue
+            if key == "cases":
+                value = [item for case in value for item in case]
+            elif isinstance(value, dict):
+                value = list(value.values())
+            if isinstance(value, (ASTNode, list)):
+                self._count_bindings(value)
+
     def _collect_user_definitions(self, ast: Program) -> None:
         for stmt in ast.body:
             if isinstance(stmt, TypeDecl):
@@ -825,7 +1144,10 @@ class SupportChecker:
 
     def _err(self, node: ASTNode | None, message: str, hint: str | None = None) -> None:
         self._diagnostics.append(Diagnostic(
-            level=Level.ERROR,
+            # The checker never visited a switch's non-default arms: what it
+            # finds there warns, and the arm keeps the lowering it compiled
+            # to (``_visit_SwitchStmt``).
+            level=Level.WARNING if self._switch_arm_depth else Level.ERROR,
             phase=Phase.ANALYZER,
             location=_loc(node, self._filename),
             message=message,
@@ -1006,9 +1328,16 @@ class SupportChecker:
         # (e.g. scale=scale.right, format=format.price).
         self._visit_children_const_ok(node)
 
+    def _visit_ImportStmt(self, node: ImportStmt) -> None:
+        if not import_is_builtin_namespace_no_op(self._ast, node):
+            self._err(node, import_refusal(node))
+
     def _visit_VarDecl(self, node: VarDecl) -> None:
+        self._check_tuple_literal_value(node.value)
         if node.name and node.value is not None:
             self._scalar_defs.setdefault(node.name, node.value)
+        if node.name and (node.is_var or node.is_varip):
+            self._persistent_decl_names.add(node.name)
         if node.type_hint in self._user_types:
             self._var_udt_types[node.name] = node.type_hint
         elif isinstance(node.value, FuncCall):
@@ -1031,22 +1360,28 @@ class SupportChecker:
             vns, vname = _qualified_name(node.value.callee)
             if vname == "new" and vns in _VISUAL_CONTAINER_TYPES:
                 self._visual_container_vars.add(node.name)
-        if node.is_varip:
-            self._err(
-                node,
-                "varip is not supported in PineForge batch backtests — there "
-                "are no intrabar ticks. Codegen would silently demote varip "
-                "to var, producing incorrect state accumulation for any "
-                "script that relies on tick-level updates.",
-                hint=(
-                    "Replace 'varip' with 'var' if the strategy logic does "
-                    "not depend on tick-level updates, or run the strategy "
-                    "in hosted TradingView Studio."
-                ),
-            )
+        # ``varip`` is supported: a historical bar executes once, so it keeps
+        # its value like ``var``, and codegen leaves it out of the
+        # calc_on_order_fills rollback (``_varip_state_member_names``).
         self._visit_children(node)
 
     def _visit_Assignment(self, node: Assignment) -> None:
+        if isinstance(node.target, TupleLiteral):
+            # ``[p, q] := f()`` reached the C++ as an assignment to a
+            # temporary tuple, a silent no-op. TradingView rejects it
+            # ("Syntax error at input ':='", CE10156): a tuple is declared
+            # with ``=`` only.
+            self._err(
+                node,
+                f"Tuple reassignment [..] {node.op} is not Pine syntax: "
+                "TradingView declares a tuple with '=' and has no tuple "
+                "reassignment.",
+                hint="Declare new names with [a, b] = f(), then reassign "
+                     "each variable on its own line.",
+            )
+            self._visit_children(node)
+            return
+        self._check_tuple_literal_value(node.value)
         # ``_scalar_defs`` records only the DECLARATION, so a later ``:=``
         # rebind used to be invisible to the request.security symbol check.
         # (``check`` also pre-collects these; recording here keeps the visit
@@ -1054,7 +1389,50 @@ class SupportChecker:
         self._record_scalar_rebind(node)
         self._visit_children(node)
 
+    def _check_tuple_literal_value(self, value) -> None:
+        """Refuse a tuple literal or a ternary of tuples as a declaration's
+        or reassignment's value.
+
+        TradingView takes a tuple literal only as a function's or an
+        if/switch arm's value and as a request.security expression:
+        ``[a, b] = [close, open]`` and ``t = [close, open]`` are "Syntax
+        error at input '['" (CE10156), ``[a, b] = c ? [x, y] : [y, x]`` is
+        "Ternary operations cannot return tuples" (lab tv --no-note). The
+        tuple declarations reached the C++ as a dropped statement ("/*
+        unsupported tuple assignment */", their names left at 0), the plain
+        declaration a tuple assigned to a double.
+        """
+        if isinstance(value, TupleLiteral):
+            self._err(
+                value,
+                "A tuple literal [..] cannot be a variable's value: TradingView "
+                "rejects it here (Syntax error at input '[', CE10156). A tuple "
+                "is only a function's or an if/switch arm's value or a "
+                "request.security expression.",
+                hint="Declare each variable on its own line (a = x, b = y), or "
+                     "return the tuple from a function: f() => [x, y], then "
+                     "[a, b] = f().",
+            )
+        elif isinstance(value, Ternary) and self._ternary_yields_tuple(value):
+            self._err(
+                value,
+                "A ternary cannot return a tuple: TradingView rejects "
+                "[a, b] = c ? [..] : [..] (\"Ternary operations cannot return "
+                "tuples\").",
+                hint="Select the tuple with an if or switch: [a, b] = if c, "
+                     "each arm ending in its tuple.",
+            )
+
+    @classmethod
+    def _ternary_yields_tuple(cls, node) -> bool:
+        return any(
+            isinstance(arm, TupleLiteral)
+            or (isinstance(arm, Ternary) and cls._ternary_yields_tuple(arm))
+            for arm in (node.true_val, node.false_val)
+        )
+
     def _visit_TupleAssign(self, node: TupleAssign) -> None:
+        self._check_tuple_literal_value(node.value)
         drawing_mask = self._tuple_assign_drawing_mask(node.value)
         if drawing_mask:
             for idx, name in enumerate(node.names):
@@ -1119,6 +1497,42 @@ class SupportChecker:
 
         full = f"{ns}.{name}" if ns else name
 
+        # The footprint another symbol's feed carries: the column of the
+        # request.security whose whole expression this is.
+        if id(node) in self._feed_footprints:
+            node.annotations = {**(node.annotations or {}),
+                                FOOTPRINT_COLUMN_ANNOTATION: footprint_column(node)}
+            self._visit_request_arguments(node)
+            return
+
+        # A request PineForge has no data for: na when its value reaches
+        # display sinks only, else its recorded series, or a deferred
+        # refusal when no key names it.
+        if ns == "request" and name in NO_DATA_REQUEST_FUNCS:
+            if name == "footprint":
+                self._lower_no_data_request(node, node, NO_DATA_REQUEST_FUNC[full])
+            else:
+                self._lower_recorded_request(node, NO_DATA_REQUEST_FUNC[full])
+            self._visit_request_arguments(node)
+            return
+
+        # A footprint value is its delta (external_requests.read_footprint_deltas):
+        # every other member is refused by name.
+        footprint = self._footprint_member(node)
+        if footprint is not None:
+            if footprint != "delta":
+                self._err(
+                    node, f"footprint.{footprint}(...) is not supported.",
+                    hint=("PineForge reads a footprint's delta() only: the "
+                          "fp_delta_<ticks>_<va> column of the feed a requests manifest pins "
+                          "for the symbol requested."))
+            receiver = node.callee.object
+            if not (isinstance(receiver, Identifier) and receiver.name == "footprint"):
+                self._visit(receiver)
+            for arg in (*node.args, *node.kwargs.values()):
+                self._visit(arg)
+            return
+
         # Hard rejects by full name.
         if full in HARD_REJECT_FUNC:
             self._err(node, f"{full}(...) is not supported.", hint=HARD_REJECT_FUNC[full])
@@ -1164,6 +1578,10 @@ class SupportChecker:
             self._err(node, f"{name}(...) is not implemented yet.", hint=NOT_YET_FUNC[name])
             self._visit_children(node)
             return
+        if (ns is None and name in POSITIONAL_BUILTINS
+                and not self._check_builtin_arguments(node, name)):
+            self._visit_children(node)
+            return
 
         # Bare cosmetic casts (e.g. `color(na)` -> default color). No backtest
         # effect; warn and let codegen emit a benign default color.
@@ -1271,13 +1689,18 @@ class SupportChecker:
         # validated above by _check_request_security and consumed by codegen.
         if full == "request.security":
             self._check_request_security(node)
-            self._visit_children_const_ok(node)
+            self._security_payload_depth += 1
+            try:
+                self._visit_children_const_ok(node)
+            finally:
+                self._security_payload_depth -= 1
             return
         # request.security_lower_tf — analyzer/codegen handle parameter validation
         # and element-type rejection (UDT/color/string). Still validate the
         # timeframe literal here so codegen catches malformed TF strings early.
         if full == "request.security_lower_tf":
             self._check_request_security_lower_tf_tf(node)
+            self._check_request_security_lower_tf_symbol(node)
             self._visit_children_const_ok(node)
             return
         if ns == "request":
@@ -1315,6 +1738,18 @@ class SupportChecker:
             self._err(node, f"ta.{name}(...) is not implemented in PineForge runtime.")
             self._visit_children(node)
             return
+        if ns == "ta":
+            self._check_ta_call(node, name)
+            if name == "ema":
+                self._warn(
+                    node,
+                    "ta.ema initial warmup is approximated: PineForge may "
+                    "return a finite value before TradingView does.",
+                    hint="A covered length-20 TradingView tape first returns "
+                         "a finite EMA at bar 19; standalone PineForge EMA "
+                         "is finite at bar 0. Its established lowering stays "
+                         "in place pending per-call-site population parity.",
+                )
         if ns == "math" and name not in SUPPORTED_MATH:
             self._err(node, f"math.{name}(...) is not implemented in PineForge runtime.")
             self._visit_children(node)
@@ -1350,7 +1785,8 @@ class SupportChecker:
             self._warn(
                 node,
                 f"color.{name}(...) has no effect in PineForge backtests "
-                f"(visual only); it emits a default color.",
+                f"(visual only); it evaluates its arguments and emits a "
+                f"default color.",
             )
             self._visit_children(node)
             return
@@ -1507,6 +1943,30 @@ class SupportChecker:
         for stmt in node.else_body:
             self._visit(stmt)
 
+    def _visit_SwitchStmt(self, node: SwitchStmt) -> None:
+        """Visit a switch: its selector, every arm's condition and block, and
+        its default block. ``cases`` holds ``(condition, block)`` tuples,
+        which the generic child walk does not enter, so every arm but the
+        default went unchecked: a request of another symbol in one kept no
+        lowering (``TradingView/Request/3``'s ``cryptoDerivativeMetric``).
+        Such an arm gets its lowerings now; what the checker would refuse
+        there warns instead, so a script that compiled keeps compiling."""
+        self._visit(node.expr)
+        self._switch_arm_depth += 1
+        try:
+            for case_expr, body in node.cases:
+                if node.expr is None:
+                    self._in_conditional_depth += 1
+                self._visit(case_expr)
+                if node.expr is None:
+                    self._in_conditional_depth -= 1
+                for stmt in body:
+                    self._visit(stmt)
+        finally:
+            self._switch_arm_depth -= 1
+        for stmt in node.default_body:
+            self._visit(stmt)
+
     def _visit_Ternary(self, node: Ternary) -> None:
         """Visit ternary; mark the condition expression as conditional context."""
         self._in_conditional_depth += 1
@@ -1564,13 +2024,15 @@ class SupportChecker:
             lambda k, v: f"{k[0]}.{k[1]}: {v}",
         ):
             return
-        # Namespace-wide variable rejections (e.g. dividends.*, earnings.*).
-        if isinstance(node.object, Identifier) and self._reject_if_in(
-            UNSUPPORTED_NAMESPACE_VARS,
-            node.object.name,
-            node,
-            lambda k, v: f"{k}.{node.member}: {v}",
-        ):
+        # Namespace-wide variable rejections (e.g. dividends.*, earnings.*),
+        # but for the field argument of the request that reads them.
+        if (isinstance(node.object, Identifier) and self._request_field_ctx_depth == 0
+                and self._reject_if_in(
+                    UNSUPPORTED_NAMESPACE_VARS,
+                    node.object.name,
+                    node,
+                    lambda k, v: f"{k}.{node.member}: {v}",
+                )):
             return
         # Constant-only namespace members (plot.style_*, text.align_*,
         # barmerge.*, alert.freq_*, ...) used as FREE EXPRESSIONS. Inside
@@ -1579,6 +2041,10 @@ class SupportChecker:
         if (
             self._const_arg_ctx_depth == 0
             and isinstance(node.object, Identifier)
+            and not (node.object.name == "alert"
+                     and node.member in ALERT_FREQ_MEMBERS)
+            and not (node.object.name == "barmerge"
+                     and node.member in BARMERGE_MEMBERS)
             and self._reject_if_in(
                 UNSUPPORTED_CONST_NAMESPACES,
                 node.object.name,
@@ -1595,6 +2061,14 @@ class SupportChecker:
         if isinstance(node.object, Identifier) and node.object.name == "syminfo":
             if node.member not in SUPPORTED_SYMINFO:
                 self._err(node, f"syminfo.{node.member} is not implemented in PineForge runtime.")
+            elif node.member in self._SYMINFO_RUN_FACT_FIELDS:
+                # Read from the symbol fact the run declares; na without one.
+                self._warn(
+                    node,
+                    f"syminfo.{node.member} is na unless the run declares the "
+                    f"symbol's {node.member} (syminfo metadata "
+                    f"\"{node.member}\", a lane fact).",
+                )
             elif node.member in self._SYMINFO_SILENT_GAP_FIELDS:
                 # These fields silently return na in current PineForge. Warn on
                 # EVERY read — not just inside an if/ternary condition — because
@@ -1653,12 +2127,22 @@ class SupportChecker:
         elif "symbol" in node.kwargs:
             symbol_node = node.kwargs["symbol"]
 
-        if symbol_node is not None and not self._is_current_symbol_expr(symbol_node):
-            self._err(
-                symbol_node,
-                "request.security symbol must reference the current chart symbol.",
-                hint="Use syminfo.tickerid or syminfo.ticker; PineForge backtests do not load alternate symbols.",
-            )
+        if symbol_node is not None:
+            scoped_safe = self._is_current_symbol_expr(symbol_node)
+            legacy_safe = self._is_current_symbol_expr(symbol_node, legacy_names=True)
+            if not scoped_safe and not legacy_safe:
+                # Another symbol: its pinned feed, when one can be read.
+                self._lower_foreign_request(node, symbol_node)
+            elif not scoped_safe or not self._is_current_symbol_expr(
+                symbol_node, require_all_paths=True
+            ):
+                if not self._lower_alternate_symbol(node, symbol_node):
+                    self._warn(
+                        symbol_node,
+                        "request.security symbol can select an alternate symbol, but "
+                        "PineForge always loads the current chart symbol.",
+                        hint="Every reachable symbol value must resolve to syminfo.tickerid or syminfo.ticker for exact results.",
+                    )
 
         # timeframe literal-format check (positional [1] or kwarg).
         tf_node = node.kwargs.get("timeframe")
@@ -1666,21 +2150,20 @@ class SupportChecker:
             tf_node = node.args[1]
         self._check_tf_literal(tf_node, "request.security")
 
-        # gaps / lookahead value-shape check (positional or kwarg).
-        gaps_node = node.kwargs.get("gaps")
-        if gaps_node is None and len(node.args) > 3:
-            gaps_node = node.args[3]
-        if gaps_node is not None and not self._is_barmerge_member(gaps_node, "gaps_on", "gaps_off"):
+        # gaps / lookahead value-shape check (positional or kwarg). A request
+        # that reads no data (lowered above) never reads them.
+        reads_data = (node.annotations or {}).get(LOWERING_ANNOTATION) not in (
+            "inert", "unpinned")
+        gaps_node, lookahead_node = _security_gaps_lookahead(node)
+        if (reads_data and gaps_node is not None
+                and not self._is_barmerge_member(gaps_node, "gaps_on", "gaps_off")):
             self._err(
                 gaps_node,
                 "request.security gaps must be barmerge.gaps_on or barmerge.gaps_off.",
                 hint="Codegen only recognizes the barmerge.gaps_* literal; other values are silently treated as gaps_off.",
             )
 
-        lookahead_node = node.kwargs.get("lookahead")
-        if lookahead_node is None and len(node.args) > 4:
-            lookahead_node = node.args[4]
-        if lookahead_node is not None and not self._is_barmerge_member(
+        if reads_data and lookahead_node is not None and not self._is_barmerge_member(
             lookahead_node, "lookahead_on", "lookahead_off"
         ):
             self._err(
@@ -1716,6 +2199,260 @@ class SupportChecker:
         # wrong-result bug. See SECURITY_ADJUSTMENT_ALLOWED_VALUES.
         self._check_security_adjustment_kwargs(node)
 
+    def _lower_no_data_request(self, node: FuncCall, at: ASTNode, why: str,
+                               reason: str | None | object = ...) -> None:
+        """A request PineForge has no data for: lowered to na, with a
+        warning, when its value reaches display and alert sinks only; else a
+        deferred refusal whose first read stops the run
+        (``external_requests``). ``reason`` is the trade slice's, when the
+        caller has it."""
+        if self._trade_slice is None:
+            self._trade_slice = TradeSlice(self._ast)
+        if reason is ...:
+            reason = self._trade_slice.reason(node)
+        lowering = "inert" if reason is None else "unpinned"
+        node.annotations = {**(node.annotations or {}), LOWERING_ANNOTATION: lowering}
+        if reason is None:
+            self._warn(
+                at,
+                f"{spell_call(node)}: value reaches only display/alert sinks; "
+                "lowered to na; trades are unaffected.",
+                hint=f"{why} The value it lowers to reaches alerts, plots and tables only.",
+            )
+        else:
+            self._warn(
+                at,
+                f"{spell_call(node)}: no data is pinned for this request; the run "
+                "stops with an error where its value is read.",
+                hint=f"{why} Its value can reach a trade: {reason}.",
+            )
+
+    def _lower_foreign_request(self, node: FuncCall, symbol_node: ASTNode) -> None:
+        """``request.security`` of another symbol. Its value reaches display
+        and alert sinks only: na, as before. Otherwise it reads the feed the
+        probe's requests manifest pins for the symbol (``FEED_LOWERING``),
+        with its first read stopping the run when none is installed; a shape
+        registration cannot key keeps the deferred refusal."""
+        if self._trade_slice is None:
+            self._trade_slice = TradeSlice(self._ast)
+        reason = self._trade_slice.reason(node)
+        blocker = None if reason is None else self._foreign_feed_blocker(node, symbol_node)
+        if reason is None or blocker is not None:
+            self._lower_no_data_request(
+                node, symbol_node,
+                "PineForge backtests load the chart's symbol only "
+                "(syminfo.tickerid, syminfo.ticker)"
+                + (f", and reads another symbol's feed only when {blocker}." if blocker
+                   else "."),
+                reason=reason)
+            return
+        self._mark_feed(node)
+        self._feed_warning(
+            node, symbol_node,
+            f"{spell_call(node)}: another symbol's bars, read from the feed the requests "
+            "manifest pins for it; with none installed, the run stops with an error where "
+            "its value is read.",
+            hint=("PineForge runs the expression on that symbol's own bars (history, ta.* "
+                  "and syminfo.* in its context) and merges them by time as TradingView "
+                  "does; a symbol equal to the chart's reads the chart."),
+        )
+
+    def _feed_warning(self, node: FuncCall, at: ASTNode, message: str, hint: str) -> None:
+        """Warn that ``node`` reads a feed -- or, when its symbol or
+        timeframe reaches it through a helper's parameters, leave the warning
+        to ``security_contexts``, which keys it on every call path or keeps
+        its earlier lowering (``FEED_WARNING_ANNOTATION``)."""
+        index = self._trade_slice.index
+        symbol, tf = node.args[:2] if len(node.args) >= 2 else (
+            node.args[0] if node.args else node.kwargs.get("symbol"),
+            node.kwargs.get("timeframe"))
+        if index.depends_on_scope(symbol) or index.depends_on_scope(tf):
+            node.annotations = {**node.annotations,
+                                FEED_WARNING_ANNOTATION: (message, hint,
+                                                          _loc(at, self._filename))}
+            return
+        self._warn(at, message, hint=hint)
+
+    def _mark_feed(self, node: FuncCall) -> None:
+        node.annotations = {**(node.annotations or {}), LOWERING_ANNOTATION: FEED_LOWERING}
+        payload = node.args[2] if len(node.args) > 2 else node.kwargs.get("expression")
+        if footprint_column(payload) is not None:
+            self._feed_footprints.add(id(payload))
+
+    def _lower_alternate_symbol(self, node: FuncCall, symbol_node: ASTNode) -> bool:
+        """A symbol that can select the chart's or another symbol's, and
+        whose value can reach a trade: registered by the string the run
+        computes, the chart's reading the chart and another's its pinned feed
+        (never the chart's bars in its place). False, keeping the chart's
+        lowering with its warning, for one whose value reaches display sinks
+        only or that registration cannot key."""
+        if self._trade_slice is None:
+            self._trade_slice = TradeSlice(self._ast)
+        if (self._trade_slice.reason(node) is None
+                or self._foreign_feed_blocker(node, symbol_node) is not None):
+            return False
+        self._mark_feed(node)
+        node.annotations = {**node.annotations, CHART_FALLBACK_ANNOTATION: True}
+        payload = node.args[2] if len(node.args) > 2 else node.kwargs.get("expression")
+        reads = ("a footprint reads the feed the requests manifest pins for each symbol, the "
+                 "chart's too (the chart's bars carry no footprint)"
+                 if footprint_column(payload) is not None else
+                 "the chart's reads the chart and another symbol's the feed the requests "
+                 "manifest pins for it")
+        self._feed_warning(
+            node, symbol_node,
+            f"{spell_call(node)}: its symbol can select another symbol: registered by the "
+            f"string the run computes, {reads}; with none installed, the run stops with an "
+            "error where its value is read.",
+            hint=("It read the chart's bars for every symbol: another symbol's value never "
+                  "comes from the chart."),
+        )
+        return True
+
+    def _lower_recorded_request(self, node: FuncCall, why: str) -> None:
+        """``request.earnings`` / ``dividends`` / ``splits`` / ``financial``.
+        Its value reaches display and alert sinks only: na, as before.
+        Otherwise it reads the series TradingView returned per chart bar,
+        which the probe's requests manifest records under the request's key
+        (``RECORDED_LOWERING``), its reads stopping the run when no series
+        is installed; a spelling no key names keeps the deferred refusal."""
+        if self._trade_slice is None:
+            self._trade_slice = TradeSlice(self._ast)
+        reason = self._trade_slice.reason(node)
+        parts, blocker = recorded_key(node) if reason is not None else (None, None)
+        if reason is not None and blocker is None and self._in_request_expression(node):
+            blocker = "it is read outside a request.security expression"
+        if reason is None or blocker is not None:
+            self._lower_no_data_request(
+                node, node, why + (f" A recorded series is read when {blocker}." if blocker
+                                   else ""),
+                reason=reason)
+            return
+        node.annotations = {**(node.annotations or {}), LOWERING_ANNOTATION: RECORDED_LOWERING}
+        key = (f"{parts['fn']}|<its symbol>|{parts['field']}|{parts['period']}|"
+               f"gaps_{parts['gaps']}|lookahead_{parts['lookahead']}")
+        self._warn(
+            node,
+            f"{spell_call(node)}: TradingView's values per chart bar, read from the series the "
+            f"requests manifest records under {key}; with none installed, the run stops "
+            "with an error where its value is read.",
+            hint=("PineForge replays the values TradingView returned on the chart's own bars "
+                  "(chart_open_ms,value): a bar the tape has no row for reads na."),
+        )
+
+    def _footprint_member(self, node: FuncCall) -> str | None:
+        """The member ``node`` calls on a footprint value (``fp.delta()``,
+        ``footprint.poc(fp)``), else None."""
+        if not isinstance(node.callee, MemberAccess):
+            return None
+        if self._footprints is None:
+            # Most scripts name no footprint: index none for them.
+            mentions = any(
+                (isinstance(n, Identifier) and n.name == "footprint")
+                or (isinstance(n, MemberAccess) and n.member == "footprint")
+                or (isinstance(n, VarDecl) and str(n.type_hint or "").strip() == "footprint")
+                for n in _walk_nodes(self._ast))
+            if not mentions:
+                self._footprints = False
+            else:
+                if self._trade_slice is None:
+                    self._trade_slice = TradeSlice(self._ast)
+                self._footprints = FootprintValues(self._trade_slice.index)
+        if self._footprints is False:
+            return None
+        read = self._footprints.member(node)
+        return read[0] if read is not None else None
+
+    def _foreign_feed_blocker(self, node: FuncCall, symbol_node: ASTNode) -> str | None:
+        """Why ``node`` cannot read another symbol's feed, or None: the
+        engine registers a feed site for ``request.security`` alone, keyed by
+        the symbol string and ``ignore_invalid_symbol`` as registration
+        computes them before the first bar (a symbol reaching the request
+        through a helper's parameters is resolved per call path, and falls
+        back there), with no other request in its expression."""
+        if _qualified_name(node.callee) != ("request", "security"):
+            return "it is request.security"
+        if self._in_request_expression(node):
+            return "it is outside another request's expression"
+        index = self._trade_slice.index
+        if index.depends_on_scope(symbol_node):
+            owner = index.owner.get(id(node))
+            if owner not in index.funcs or owner in index.overloaded:
+                # A method's parameter, a block's local: no call path to
+                # resolve it through (``security_contexts``).
+                return "registration computes its symbol before the first bar"
+        elif not index.registration_value(symbol_node):
+            return "registration computes its symbol before the first bar"
+        tf = node.args[1] if len(node.args) > 1 else node.kwargs.get("timeframe")
+        if (tf is not None and not index.depends_on_scope(tf)
+                and not index.registers_timeframe(tf)):
+            return "registration computes its timeframe before the first bar"
+        ignore = node.kwargs.get("ignore_invalid_symbol")
+        if ignore is not None and not index.registration_value(ignore):
+            return "registration computes its ignore_invalid_symbol before the first bar"
+        gaps, lookahead = _security_gaps_lookahead(node)
+        if not (gaps is None or self._is_barmerge_member(gaps, "gaps_on", "gaps_off")) or not (
+                lookahead is None
+                or self._is_barmerge_member(lookahead, "lookahead_on", "lookahead_off")):
+            # Registration reads them as the constants they are written as.
+            return "its gaps and lookahead are barmerge constants"
+        payload = node.args[2] if len(node.args) > 2 else node.kwargs.get("expression")
+        if isinstance(payload, FuncCall) and _qualified_name(payload.callee) == (
+                "request", "footprint"):
+            # The feed's footprint column: its name spells the literal ticks
+            # per row and value-area percent.
+            if footprint_column(payload) is None:
+                return ("its request.footprint states ticks_per_row and va_percent as "
+                        "literal whole numbers")
+            return None
+        helpers = self._helpers_called(payload)
+        for inner in _walk_nodes([payload, *(index.funcs[name] for name in helpers)]):
+            if isinstance(inner, FuncCall) and _qualified_name(inner.callee)[0] == "request":
+                return "its expression holds no request of its own"
+        return None
+
+    def _helpers_called(self, value) -> set[str]:
+        """The helpers ``value`` calls, directly or through further helpers."""
+        index = self._trade_slice.index
+
+        def callees(item) -> set[str]:
+            return {n.callee.name for n in _walk_nodes(item)
+                    if isinstance(n, FuncCall) and id(n) in index.call_ids}
+
+        found: set[str] = set()
+        pending = callees(value)
+        while pending:
+            name = pending.pop()
+            if name not in found:
+                found.add(name)
+                pending |= callees(index.funcs[name]) - found
+        return found
+
+    def _in_request_expression(self, node: FuncCall) -> bool:
+        """``node`` is evaluated inside a request's expression: written in it
+        (a request's arguments are its only children the checker visits
+        under ``_security_payload_depth``), or in a helper that expression
+        calls, whose body runs inside the request's evaluator."""
+        if self._security_payload_depth:
+            return True
+        if self._trade_slice is None:
+            self._trade_slice = TradeSlice(self._ast)
+        index = self._trade_slice.index
+        if self._payload_funcs is None:
+            self._payload_funcs = self._helpers_called([
+                request.args[2] if len(request.args) > 2 else request.kwargs.get("expression")
+                for requests in index.requests.values() for request in requests])
+        return index.owner.get(id(node)) in self._payload_funcs
+
+    def _visit_request_arguments(self, node: FuncCall) -> None:
+        """A no-data request's arguments: ``barmerge.*`` and its field
+        constants (``earnings.actual``) are what it reads."""
+        self._request_field_ctx_depth += 1
+        try:
+            self._visit_children_const_ok(node)
+        finally:
+            self._request_field_ctx_depth -= 1
+
     def _check_security_adjustment_kwargs(self, node: FuncCall) -> None:
         """Reject request.security adjustment kwargs that the engine drops."""
         for kw_name, allowed in SECURITY_ADJUSTMENT_ALLOWED_VALUES.items():
@@ -1741,6 +2478,195 @@ class SupportChecker:
                     hint=f"Allowed values: {sorted(allowed)}.",
                 )
 
+    # -- ta.* call arguments --
+
+    def _check_ta_call(self, node: FuncCall, name: str) -> None:
+        """Bind the call's arguments to TradingView's signature, then flag (or,
+        for a spelling that never compiled, refuse) a parameter value the
+        engine's class cannot compute."""
+        if not self._check_ta_arguments(node, name):
+            return
+        if name == "vwap":
+            self._check_ta_vwap_anchor(node)
+        elif name == "alma":
+            self._check_ta_alma_floor(node)
+        elif name in ("kc", "kcw"):
+            self._check_ta_keltner_true_range(node, name)
+        elif name == "pivot_point_levels":
+            self._check_ta_pivot_point_levels(node)
+
+    @staticmethod
+    def _ta_signature_text(name: str) -> str:
+        """TradingView's signature(s) of ``ta.<name>``, optional parameters
+        with their defaults."""
+        def spell(sig) -> str:
+            parts = []
+            for p in sig.params:
+                if p.default is None:
+                    parts.append(p.name)
+                elif isinstance(p.default, bool):
+                    parts.append(f"{p.name} = {'true' if p.default else 'false'}")
+                else:
+                    parts.append(f"{p.name} = {p.default}")
+            return f"ta.{name}({', '.join(parts)})"
+        return " or ".join(spell(sig) for sig in sigs.TA_FUNCTIONS[name].signatures)
+
+    @staticmethod
+    def _ta_binding_problem(sig, node: FuncCall):
+        """Why ``node``'s arguments do not bind to ``sig``, as ``(rank, message,
+        node to point at)``, or None when they bind. A lower rank is the more
+        useful report when no overload binds."""
+        names = [p.name for p in sig.params]
+        if len(node.args) > len(names):
+            return ((2, 0), f"takes at most {len(names)} arguments, got {len(node.args)}",
+                    node.args[len(names)])
+        for key, value in node.kwargs.items():
+            if key not in names:
+                return (3, 0), f"has no parameter '{key}'", value
+            if names.index(key) < len(node.args):
+                return (1, 0), f"got '{key}' twice, by position and by keyword", value
+        bound = set(names[:len(node.args)]) | set(node.kwargs)
+        missing = [p.name for p in sig.params if p.default is None and p.name not in bound]
+        if missing:
+            listed = ", ".join(f"'{m}'" for m in missing)
+            noun = "arguments" if len(missing) > 1 else "argument"
+            return (0, len(missing)), f"is missing its {noun} {listed}", None
+        return None
+
+    def _check_builtin_arguments(self, node: FuncCall, name: str) -> bool:
+        """Refuse an ``nz`` / ``fixnan`` call whose arguments bind to none of
+        TradingView's signatures -- ``nz(source)``, ``nz(source,
+        replacement)``, ``fixnan(source)`` -- as TradingView does ("The nz
+        function does not have an argument with the name x"). A call that
+        binds is rewritten positionally by ``builtin_keywords``; before, a
+        keyword crashed the codegen (IndexError) or was dropped. Returns True
+        when the arguments bind.
+        """
+        func = sigs.BUILTIN_FUNCTIONS[name]
+        problems = []
+        for sig in func.signatures:
+            problem = self._ta_binding_problem(sig, node)
+            if problem is None:
+                return True
+            problems.append((problem[0], -len(sig.params), problem[1], problem[2]))
+        _rank, _width, message, at = min(problems, key=lambda p: (p[0], p[1]))
+        spelled = " or ".join(
+            f"{name}({', '.join(p.name for p in sig.params)})" for sig in func.signatures)
+        self._err(
+            expr_start(at if at is not None else node),
+            f"{name} {message} (TradingView: {spelled}).",
+            hint="Use the parameters of TradingView's signature.",
+        )
+        return False
+
+    def _check_ta_arguments(self, node: FuncCall, name: str) -> bool:
+        """Refuse a ``ta.*`` call whose arguments bind to none of TradingView's
+        signatures (``signatures.TA_FUNCTIONS``), as TradingView does.
+
+        The analyzer routes the arguments by position, each to a constructor or
+        ``compute()`` slot. An argument that binds to no parameter used to be
+        dropped (a misspelt or foreign keyword, a keyword given after the same
+        positional), shifted into the next constructor slot (a keyword skipping
+        a required parameter: ``ta.alma(close, 9, sigma=4)`` built
+        ``ALMA(9, 4)``) or passed to a ``compute()`` overload that does not
+        exist (one too many, or a missing required one): a silently wrong
+        indicator or a C++ compile failure. Returns True when they bind.
+        """
+        func = sigs.TA_FUNCTIONS.get(name)
+        if func is None:
+            return True
+        if name == "vwap" and not node.args and not node.kwargs:
+            # ``ta.vwap()`` reads like the bare ``ta.vwap`` property (the VWAP
+            # of hlc3), which is what it has always compiled to.
+            return True
+        problems = []
+        for sig in func.signatures:
+            problem = self._ta_binding_problem(sig, node)
+            if problem is None:
+                return True
+            problems.append((problem[0], -len(sig.params), problem[1], problem[2]))
+        _rank, _width, message, at = min(problems, key=lambda p: (p[0], p[1]))
+        self._err(
+            expr_start(at if at is not None else node),
+            f"ta.{name} {message} (TradingView: {self._ta_signature_text(name)}).",
+            hint="Use the parameters of TradingView's signature.",
+        )
+        return False
+
+    def _ta_argument(self, node: FuncCall, name: str, param: str):
+        """The argument bound to ``param`` (the call's arguments bind to the
+        widest signature naming it), or None when it is omitted."""
+        if param in node.kwargs:
+            return node.kwargs[param]
+        for sig in sorted(sigs.TA_FUNCTIONS[name].signatures, key=lambda s: -len(s.params)):
+            names = [p.name for p in sig.params]
+            if param in names:
+                index = names.index(param)
+                return node.args[index] if index < len(node.args) else None
+        return None
+
+    def _is_constant_bool(self, node, value: bool, _seen: frozenset = frozenset()) -> bool:
+        """``node`` is the literal ``value``, directly or through a name bound
+        exactly once in the script -- never reassigned, not ``var`` -- to it."""
+        if isinstance(node, BoolLiteral):
+            return node.value is value
+        if isinstance(node, Identifier) and node.name not in _seen:
+            if (self._binding_counts.get(node.name) != 1
+                    or node.name in self._scalar_rebinds
+                    or node.name in self._persistent_decl_names):
+                return False
+            definition = self._scalar_defs.get(node.name)
+            return definition is not None and self._is_constant_bool(
+                definition, value, _seen | {node.name})
+        return False
+
+    def _check_ta_alma_floor(self, node: FuncCall) -> None:
+        """TA1's ``ta::ALMA`` accepts the Pine ``floor`` input exactly.
+
+        The generated compatibility shim keeps the same source compilable
+        against an older engine and drops the argument there.
+        """
+        return
+
+    def _check_ta_keltner_true_range(self, node: FuncCall, name: str) -> None:
+        """TA1's KC/KCW classes accept ``useTrueRange`` exactly."""
+        return
+
+    def _check_ta_pivot_point_levels(self, node: FuncCall) -> None:
+        """TA1's ``PivotPointLevels`` accepts anchor and developing exactly."""
+        return
+
+    # -- ta.vwap anchor --
+
+    # Timeframe strings naming the symbol's daily bar: ``ta.vwap``'s default
+    # anchor is ``timeframe.change("1D")``.
+    _VWAP_DAILY_ANCHOR_TFS = frozenset({"D", "1D"})
+
+    def _check_ta_vwap_anchor(self, node: FuncCall) -> None:
+        """TA1's anchored VWAP classes accept every Pine anchor expression.
+
+        The code generator keeps the historical class for the default daily
+        anchor and emits the compatibility shim for every other anchor.
+        """
+        return
+
+    def _is_daily_timeframe_change(self, node: ASTNode, _seen: frozenset = frozenset()) -> bool:
+        """``timeframe.change("1D")`` / ``("D")``, directly or through a
+        never-reassigned, non-``var`` binding of it."""
+        if isinstance(node, FuncCall):
+            ns, fname = _qualified_name(node.callee)
+            if (ns, fname) != ("timeframe", "change") or len(node.args) + len(node.kwargs) != 1:
+                return False
+            tf = node.args[0] if node.args else node.kwargs.get("timeframe")
+            return isinstance(tf, StringLiteral) and tf.value in self._VWAP_DAILY_ANCHOR_TFS
+        if isinstance(node, Identifier) and node.name not in _seen:
+            if node.name in self._scalar_rebinds or node.name in self._persistent_decl_names:
+                return False
+            definition = self._scalar_defs.get(node.name)
+            return definition is not None and self._is_daily_timeframe_change(
+                definition, _seen | {node.name})
+        return False
+
     def _is_barmerge_member(self, node: ASTNode, *allowed: str) -> bool:
         if not isinstance(node, MemberAccess):
             return False
@@ -1748,51 +2674,113 @@ class SupportChecker:
             return False
         return node.member in allowed
 
-    def _is_current_symbol_expr(self, node: ASTNode, _seen: set[str] | None = None) -> bool:
-        if _seen is None:
-            _seen = set()
+    def _is_current_symbol_expr(
+        self, node: ASTNode, _seen: frozenset[object] = frozenset(),
+        *, require_all_paths: bool = False, legacy_names: bool = False,
+    ) -> bool:
         chain = _resolve_member_chain(node)
         if chain in SECURITY_CURRENT_SYMBOL_NAMES:
             return True
-        # ticker.inherit(symbol, ...) / ticker.standard(symbol) are passthrough,
-        # and ticker.heikinashi(symbol) is the chart's OWN symbol with a causal
-        # Heikin-Ashi candle transform (the engine applies it inside the security
-        # eval via register_security_eval's heikinashi flag — no alternate symbol
-        # is loaded). All allow a current-symbol first argument; a non-current
-        # arg is genuine cross-symbol construction and still falls through.
+        # ticker.inherit(from_tickerid, symbol) / ticker.standard(symbol) are
+        # passthrough of their symbol (ticker_symbol_arg: inherit names it
+        # second), and ticker.heikinashi(symbol) is the chart's OWN symbol with
+        # a causal Heikin-Ashi candle transform (the engine applies it inside
+        # the security eval via register_security_eval's heikinashi flag — no
+        # alternate symbol is loaded). All allow a current-symbol symbol
+        # argument; a non-current one is genuine cross-symbol construction and
+        # still falls through.
         if isinstance(node, FuncCall):
             ns, fname = _qualified_name(node.callee)
             if ns == "ticker" and fname in ("inherit", "standard", "heikinashi"):
-                if node.args and self._is_current_symbol_expr(node.args[0], _seen):
-                    return True
-                if "symbol" in node.kwargs and self._is_current_symbol_expr(node.kwargs["symbol"], _seen):
+                symbol = ticker_symbol_arg(node)
+                if symbol is not None and self._is_current_symbol_expr(
+                    symbol, _seen, require_all_paths=require_all_paths,
+                    legacy_names=legacy_names,
+                ):
                     return True
-        # A ternary symbol (``cond ? other : syminfo.tickerid``) resolves to the
-        # chart symbol whenever EITHER branch does. PineForge only ever loads the
-        # chart symbol, so this is exact at any config where the chosen branch is
-        # the chart symbol; an unconditional cross-symbol expression still errors.
+        # Preserve admission for a working script with an unreachable alternate
+        # branch; the all-paths pass diagnoses a possibly wrong feed.
         if isinstance(node, Ternary):
-            return (self._is_current_symbol_expr(node.true_val, _seen)
-                    or self._is_current_symbol_expr(node.false_val, _seen))
+            true_safe = self._is_current_symbol_expr(
+                node.true_val, _seen, require_all_paths=require_all_paths,
+                legacy_names=legacy_names,
+            )
+            false_safe = self._is_current_symbol_expr(
+                node.false_val, _seen, require_all_paths=require_all_paths,
+                legacy_names=legacy_names,
+            )
+            return true_safe and false_safe if require_all_paths else true_safe or false_safe
         # Def-use: resolve a bare identifier through its declaration value so an
         # aliased symbol is accepted (``haTicker = ticker.heikinashi(...)`` then
         # ``request.security(haTicker, ...)``). Every ``:=`` rebind of the name
         # must resolve to the chart symbol too: the declaration alone does not
-        # pin the value the call actually receives. Name-cycle-guarded.
-        if isinstance(node, Identifier) and node.name not in _seen:
-            definition = self._scalar_defs.get(node.name)
-            rebinds = self._scalar_rebinds.get(node.name)
-            if definition is not None or rebinds:
-                _seen.add(node.name)
-                if rebinds and not all(
-                    self._is_current_symbol_expr(value, _seen) for value in rebinds
-                ):
+        # pin the value the call actually receives. Binding-cycle-guarded.
+        if isinstance(node, Identifier):
+            if legacy_names:
+                binding = ("legacy", node.name)
+                if binding in _seen:
                     return False
+                definition = self._scalar_defs.get(node.name)
                 if definition is None:
                     return False
-                return self._is_current_symbol_expr(definition, _seen)
+                seen = _seen | {binding}
+                return self._is_current_symbol_expr(
+                    definition, seen, require_all_paths=require_all_paths,
+                    legacy_names=True,
+                ) and all(
+                    self._is_current_symbol_expr(
+                        value, seen, require_all_paths=require_all_paths,
+                        legacy_names=True,
+                    )
+                    for value in self._scalar_rebinds.get(node.name, ())
+                )
+            binding = self._security_symbol_refs.get(id(node))
+            if (isinstance(binding, tuple) and binding[0] == "param"
+                    and binding not in _seen):
+                return self._param_is_current_symbol(
+                    binding, _seen | {binding}, require_all_paths)
+            if binding is not None and binding not in _seen:
+                definition = self._security_symbol_defs.get(binding)
+                if definition is None:
+                    return False
+                seen = _seen | {binding}
+                if not self._is_current_symbol_expr(
+                    definition, seen, require_all_paths=require_all_paths
+                ):
+                    return False
+                return all(
+                    self._is_current_symbol_expr(
+                        value, seen, require_all_paths=require_all_paths
+                    )
+                    for value in self._security_symbol_rebinds.get(binding, ())
+                )
         return False
 
+    def _param_is_current_symbol(
+        self, binding: tuple, seen: frozenset, require_all_paths: bool,
+    ) -> bool:
+        """A helper parameter is the chart's symbol when the argument every
+        call of the helper binds to it is, read in the caller's scope --
+        through further helpers' parameters too. A helper nothing calls
+        never runs. A method's parameter, or an overloaded helper's, keeps
+        the refusal."""
+        _, func_id, name = binding
+        fdef = self._user_func_defs.get(func_id)
+        if fdef is None or fdef.name in self._overloaded_user_funcs:
+            return False
+        index = fdef.params.index(name)
+        defaults = (fdef.annotations or {}).get("param_defaults") or []
+        for call in self._user_func_calls.get(fdef.name, ()):
+            arg = call.kwargs.get(name)
+            if arg is None and index < len(call.args):
+                arg = call.args[index]
+            if arg is None and index < len(defaults):
+                arg = defaults[index]
+            if arg is None or not self._is_current_symbol_expr(
+                    arg, seen, require_all_paths=require_all_paths):
+                return False
+        return True
+
     # -- Pine timeframe-literal validation --
 
     @staticmethod
@@ -1844,6 +2832,39 @@ class SupportChecker:
             hint=err,
         )
 
+    def _check_request_security_lower_tf_symbol(self, node: FuncCall) -> None:
+        """``request.security_lower_tf`` reads the chart's intrabars: the
+        engine loads no other symbol's. For another symbol whose value can
+        reach a trade, evaluating the request stops the run with it named
+        (``ABSENT_LOWERING``), never reading the chart's bars in its place;
+        one reaching display and alert sinks only, or that can select the
+        chart's symbol, keeps its lowering and warns."""
+        symbol_node = node.args[0] if node.args else node.kwargs.get("symbol")
+        if symbol_node is None or self._is_current_symbol_expr(
+                symbol_node, require_all_paths=True):
+            return
+        if self._trade_slice is None:
+            self._trade_slice = TradeSlice(self._ast)
+        reason = self._trade_slice.reason(node)
+        hint = "PineForge loads no other symbol's lower-timeframe bars."
+        if (reason is not None and not self._is_current_symbol_expr(symbol_node)
+                and not self._is_current_symbol_expr(symbol_node, legacy_names=True)):
+            node.annotations = {**(node.annotations or {}), LOWERING_ANNOTATION: ABSENT_LOWERING}
+            self._warn(
+                symbol_node,
+                f"{spell_call(node)}: no data is pinned for this request; the run stops with "
+                "an error where it is evaluated.",
+                hint=f"{hint} Its value can reach a trade: {reason}.")
+            return
+        self._warn(
+            symbol_node,
+            f"{spell_call(node)}: its symbol can be another symbol's, whose lower-timeframe "
+            "bars PineForge reads from the chart"
+            + ("; its value reaches only display/alert sinks, so trades are unaffected."
+               if reason is None else "."),
+            hint=hint + " Every reachable symbol value must resolve to syminfo.tickerid or "
+                        "syminfo.ticker for exact results.")
+
     def _check_request_security_lower_tf_tf(self, node: FuncCall) -> None:
         """Validate the ``timeframe`` argument literal for
         ``request.security_lower_tf``. All other parameter validation lives in