pineforge-codegen 0.8.1__tar.gz → 0.9.0__tar.gz

{pineforge_codegen-0.8.1 → pineforge_codegen-0.9.0}/CLAUDE.md

@@ -206,14 +206,15 @@ strategy. The taxonomy:
 | Bucket                           | What                                                                 |
 | -------------------------------- | -------------------------------------------------------------------- |
 | `HARD_REJECT_FUNC`               | Calls with no PineForge semantics at all (e.g. `request.financial`). |
-| `HARD_REJECT_NAMESPACE`          | Whole namespaces (e.g. `ticker.*`).                                  |
-| `DIVERGENT_VARS` (warning)       | Built-in variables whose value diverges from TV (e.g. `bar_index`).  |
+| `HARD_REJECT_NAMESPACE`          | Whole-namespace rejects — currently EMPTY (the old `ticker.*` blanket reject became per-function `HARD_REJECT_FUNC` entries: `ticker.{renko,kagi,linebreak,pointfigure,new,modify}`; `ticker.inherit`/`ticker.standard` pass through, `ticker.heikinashi` allowed for the chart's own symbol). |
+| `DIVERGENT_VARS` (warning) / `DIVERGENT_VARS_ERROR` (reject) | Built-in variables whose value diverges from TV (e.g. `bar_index` warns); the ERROR subset (`last_bar_index` — would silently mis-alias to the CURRENT bar index) is rejected because the backtest would be silently wrong. |
 | `BARSTATE_APPROX_VARS` (warning) | Barstate flags PineForge approximates in batch mode.                 |
 | `STRATEGY_UNSUPPORTED_PARAMS`    | Per-strategy.* call kwargs that codegen drops silently.              |
 | `NOT_YET_FUNC`                   | Implementable but currently no codegen — reject loudly.              |
 | `SUPPORTED_*` frozensets         | Per-namespace whitelist of names codegen knows how to emit.          |
 | `varip` VarDecl check            | `varip` declarations rejected outright — batch backtests have no realtime tick state. |
 | TF literal validation            | `request.security` / `request.security_lower_tf` `timeframe` string literals validated against Pine v6 format at parse time. |
+| syminfo na-gap warning           | `SUPPORTED_SYMINFO` = every `SYMINFO_MEMBER_MAP` key, but members whose emission is `na<T>()` or a `get_syminfo_metadata(...)` lookup (root/pricescale/minmove/mincontract/current_contract/expiration_date/isin/sector/industry + fundamentals/recommendations/target_price_*) form `_SYMINFO_SILENT_GAP_FIELDS` (derived from the emission table, so new na-accept fields can't drift out): every read WARNS that the value is na until a data feed injects it. |
 
 
 When extending codegen with a new Pine builtin: add to the corresponding
@@ -230,22 +231,23 @@ These bit us once and are now pinned by `test_compile_smoke.py`'s
 you delete or weaken the special case, the test will tell you.
 
 1. **`year(time)` / `month(time)` / `dayofmonth` / `dayofweek` /
-  `hour(time, tz)` / `minute` / `second` / `weekofyear` function-call
-   form** lowers to an inline lambda that mirrors the engine's
-   `BacktestEngine::_decompose_bar_time()`. The variable form uses
-   `_bar_year()` etc. via `BAR_BUILTINS` (still UTC-only — `_bar_*`
-   accessors call `gmtime_r` unconditionally; chart-tz wiring on the
-   variable side is a separate engine change). The function-call form
-   honors a tz argument: the two-arg form `hour(time, tz)` uses the
-   explicit tz; the one-arg form `hour(time)` defaults to
-   `syminfo_.timezone` (the engine's `SymInfo::timezone` field, "UTC"
-   by default). When the resolved tz is empty / "UTC" / "Etc/UTC" the
-   lambda takes the cheap `gmtime_r` fast path; otherwise it enters a
-   mutex-guarded `setenv("TZ", ...)` + `localtime_r` block that
-   mirrors `pine_tz::ScopedTimezone` (`src/timezone.cpp`, not exposed
-   via any public `<pineforge/...>` header). Harnesses validating
-   against TV exports for non-UTC symbols MUST set chart_tz to match
-   the chart's TZ at export time.
+  `hour(time, tz)` / `minute` / `second` / `weekofyear`** — BOTH the
+   function-call form and the bare variable form lower to the engine's
+   cached, timezone-aware `pine_<field>(ts_ms, tz)` helpers
+   (`session_time.hpp`): the variable form via `BAR_BUILTINS`
+   (`pine_year(current_bar_.timestamp, syminfo_.timezone)` …), the
+   function form via `visit_call.py` (`pine_hour((int64_t)(ts), tz)`),
+   so the two forms agree. The two-arg form uses the explicit tz; the
+   one-arg form defaults to `syminfo_.timezone` (engine
+   `SymInfo::timezone`, "UTC" by default). The old inline
+   `setenv("TZ")+localtime_r` lambda (`tz_time_field_lambda`,
+   codegen/tables.py) is no longer emitted — per-call tzset churn
+   caused a macOS notifyd IPC storm (KI-35) — and has zero call sites.
+   Chart display TZ is a separate engine slot (`chart_timezone_`,
+   `strategy_set_chart_timezone`) intentionally NOT consulted by these
+   builtins; harnesses validating metrics against TV exports for
+   non-UTC charts must still set chart_tz to match the chart's TZ at
+   export time.
 2. **Matrix-returning methods** (`inv` / `pinv` / `transpose` / `copy` /
   `submatrix` / `concat` / `diff` / `mult` / `pow` / `eigenvectors` /
    `kron`) live in `MATRIX_RETURNING_METHODS` (`codegen/tables.py`).
@@ -276,13 +278,21 @@ you delete or weaken the special case, the test will tell you.
    PREVIOUS bar's HLC (`_s_high[1]`, `_s_low[1]`, `_s_close[1]`) per
    Pine v6 semantics with `developing=false`.
 6. **`request.security` is strict.** Only `symbol`, `timeframe`,
-  `expression`, `gaps`, and `lookahead` are allowed. Symbol must resolve
-   to the current chart symbol (`syminfo.tickerid` or `syminfo.ticker`).
-   `gaps` and `lookahead` must be the literal `barmerge.gaps_*` /
+  `expression`, `gaps`, `lookahead`, and `ignore_invalid_symbol` are
+   allowed (`ignore_invalid_symbol` is accepted but inert — the symbol is
+   always the chart symbol, so no symbol can be invalid). Symbol must
+   resolve to the current chart symbol (`syminfo.tickerid` or
+   `syminfo.ticker`, incl. first-binding aliases and
+   `ticker.inherit/standard/heikinashi(<chart sym>)`). `gaps` and
+   `lookahead` must be the literal `barmerge.gaps_*` /
    `barmerge.lookahead_*` member access (codegen does not parse other
-   shapes). `barmerge.lookahead_on` is hard-rejected for backtest-honesty
-   reasons. The `timeframe` argument, when a string literal, is validated
-   against the Pine v6 TF format at parse time (PR #3).
+   shapes). `barmerge.lookahead_on` is ACCEPTED with a repaint WARNING —
+   engine-supported (first-intrabar publication; script-tf publish gating
+   for finer-than-chart targets): see `_check_request_security`'s lookahead
+   branch and `test_request_security_lookahead_on_kwarg_warns`. The old
+   "hard-rejected" wording here was verified stale against the code on
+   2026-07-07 — do not restore it. The `timeframe` argument, when a string
+   literal, is validated against the Pine v6 TF format at parse time (PR #3).
 7. `**SUPPORTED_LOG`** gates `log.{info,warning,error}`. Without it,
   typos like `log.foo("x")` previously emitted a dead empty-string
    statement. Don't remove the gate.

{pineforge_codegen-0.8.1 → pineforge_codegen-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pineforge-codegen
-Version: 0.8.1
+Version: 0.9.0
 Summary: PineScript v6 to C++ transpiler that targets the pineforge-engine runtime.
 Project-URL: Homepage, https://github.com/pineforge-4pass/pineforge-codegen-oss
 Project-URL: Issues, https://github.com/pineforge-4pass/pineforge-codegen-oss/issues

pineforge_codegen-0.9.0/VERSION

@@ -0,0 +1 @@
+0.9.0

{pineforge_codegen-0.8.1 → pineforge_codegen-0.9.0}/pineforge_codegen/analyzer/base.py

@@ -143,6 +143,13 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         self._block_var_seq = 0
         self._ta_counter = 0
         self._fixnan_counter = 0
+        # All fixnan member names minted so far (base + clones), for O(1)
+        # collision detection when minting a per-call-site fixnan clone.
+        self._fixnan_member_names: set[str] = set()
+        # Authoritative fixnan clone-name map for collisions: (func, cs_idx)
+        # -> {orig_member: cloned_member}. Consumed verbatim by the codegen
+        # when the default ``{base}_cs{cs_idx}`` formula would collide.
+        self._func_cs_fixnan_clone_names: dict[tuple[str, int], dict[str, str]] = {}
         # Track user-defined function nodes for deferred analysis
         self._func_defs: dict[str, FuncDef] = {}
         # Track user-defined function return types
@@ -156,6 +163,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         # Probe: data/validation/udt-method-probe-20-udt-return-from-func.
         self._func_udt_return_types: dict[str, str] = {}
         self._func_return_type_specs: dict[str, "TypeSpec"] = {}
+        self._func_param_type_specs: dict[str, list] = {}
         # Per-function var_members and series_vars (for call-site cloning)
         self._func_var_members: dict[str, list] = {}  # func_name -> [(name, PineType, init_str)]
         self._func_series_vars: dict[str, set] = {}   # func_name -> set[str]
@@ -163,9 +171,23 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         self._func_ta_ranges: dict[str, tuple[int, int]] = {}  # func_name -> (start, end) indices
         self._func_call_site_count: dict[str, int] = {}  # func_name -> count
         self._func_call_cs_map: dict[int, tuple[str, int]] = {}  # call_node_id -> (func_name, cs_idx)
-        # Functions whose ONLY reason for needing per-call-site body cloning
-        # is a security-tf-monomorphized request.security (no TA/series state
-        # of their own — see _check_mixed_callsite_security_tf).
+        # Textual nested calls whose identity is inherited from the active
+        # parent clone rather than assigned a fixed source-level cs index.
+        # Kept separately so a second propagation pass (security TF cloning)
+        # does not accidentally backfill them as a new cs{N} call site.
+        self._func_inherited_call_nodes: set[int] = set()
+        # Per-function fixnan site ownership: func_name -> list of fixnan site
+        # indices in self._fixnan_sites owned by that function. Mirrors the
+        # TA-range slicing but for fixnan state, so per-call-site cloning can
+        # mint fresh fixnan members per variant and the codegen dead-code pass
+        # can skip fixnan state owned by dead functions.
+        self._func_fixnan_indices: dict[str, list[int]] = {}
+        # Functions that need per-call-site BODY cloning despite owning no
+        # TA/series/var state.  The set originated for security-tf
+        # monomorphization; it is also the existing emitter contract used by
+        # pure wrappers around stateful callees and fixnan-only functions.
+        # Security evaluator identity remains independently tracked by each
+        # SecurityCallInfo.callsite_idx.
         self._func_security_clone_only: set[str] = set()
         # Authoritative clone-name map: (func_name, cs_idx) -> {orig_member_name:
         # cloned_member_name}. The codegen rebuilds its TA remap from the
@@ -200,6 +222,13 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         # a TA ctor length with one of the OUTER function's params, so the outer
         # call site can re-substitute (e.g. f_bbwp(_bbwLen) -> f_basisMa(_len)).
         self._enclosing_func_params: list[set[str]] = []
+        # Parallel stack of the function NAMES whose param-sets are in
+        # ``_enclosing_func_params``. The top of stack (or None at global
+        # scope) is the owner of any ORIGINAL ``ta.*`` site minted right now
+        # -- recorded on ``TACallSite.owner_func`` so the codegen dead-code
+        # pass can tell borrowed clones apart from a dead function's own
+        # sites (see contracts.TACallSite.owner_func).
+        self._enclosing_func_names: list[str] = []
         # Set of TA-site indices a nested user-func call rewrote in terms of the
         # current enclosing function's params (None when not inside a FuncDef body).
         self._nested_ta_touched: set | None = None
@@ -302,6 +331,8 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             var_members=self._var_members,
             func_infos=self._func_infos,
             fixnan_sites=self._fixnan_sites,
+            func_fixnan_indices=self._func_fixnan_indices,
+            func_cs_fixnan_clone_names=self._func_cs_fixnan_clone_names,
             strategy_params=self._strategy_params,
             diagnostics=self._diagnostics,
             filename=self._filename,
@@ -440,40 +471,274 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         return out
 
     def _propagate_call_site_counts(self) -> None:
-        """Propagate call-site counts from parent functions to sub-functions.
-
-        If function F has N call sites and calls sub-function G internally,
-        G also needs N variants so that F_csK can call G_csK with isolated state.
-        This ensures every stateful sub-function gets per-call-site isolation
-        inherited from its parent.
+        """Propagate stateful UDF identity through complete call paths.
+
+        A UDF is stateful when it owns series/``var`` state, TA state, or
+        ``fixnan`` state, and every pure wrapper that reaches such a UDF is
+        stateful transitively.  Give each wrapper's textual calls stable cs
+        identities, then inherit a multi-call-site parent's count down to its
+        stateful callees.  Any inherited TA/fixnan variants are materialized
+        immediately; exporting a count without the corresponding members would
+        make codegen reference undeclared or shared state.
         """
         from pineforge_codegen.ast_nodes import FuncCall, FuncDef, Identifier
 
-        # Collect all user function definitions from AST
         func_defs: dict[str, FuncDef] = {}
         for stmt in self._ast.body:
             if isinstance(stmt, FuncDef):
                 func_defs[stmt.name] = stmt
 
-        # Find which functions call which sub-functions (direct calls only)
-        def _find_calls(node, known_funcs: set[str]) -> set[str]:
-            calls: set[str] = set()
-            if isinstance(node, FuncCall) and isinstance(node.callee, Identifier):
-                if node.callee.name in known_funcs:
-                    calls.add(node.callee.name)
+        # UDT methods participate in the same stateful call graph as plain
+        # UDFs.  Their analyzer identity is ``Type.method`` while FuncInfo.node
+        # carries the synthetic FuncDef used by codegen.
+        func_info_by_name = {fi.name: fi for fi in self._func_infos}
+        for fi in self._func_infos:
+            if getattr(fi, "is_udt_method", False) and fi.node is not None:
+                func_defs.setdefault(fi.name, fi.node)
+
+        # Preserve call-node identity as well as the callee name: late clone
+        # materialization needs the textual call's argument mapping to resolve
+        # parameterized TA constructor lengths.
+        def _resolved_user_call_name(call: FuncCall, owner: str | None) -> str | None:
+            if isinstance(call.callee, Identifier):
+                return call.callee.name if call.callee.name in func_defs else None
+            if not isinstance(call.callee, MemberAccess):
+                return None
+
+            recv = call.callee.object
+            method = call.callee.member
+            udt_name: str | None = None
+            if isinstance(recv, Identifier):
+                udt_name = self._udt_var_types.get(recv.name)
+                owner_info = func_info_by_name.get(owner or "")
+                if udt_name is None and owner_info is not None \
+                        and owner_info.node is not None:
+                    if (getattr(owner_info, "is_udt_method", False)
+                            and owner_info.node.params
+                            and recv.name == owner_info.node.params[0]):
+                        udt_name = owner_info.udt_type_name
+                    elif recv.name in owner_info.node.params:
+                        param_idx = owner_info.node.params.index(recv.name)
+                        specs = getattr(owner_info, "param_type_specs", []) or []
+                        spec = specs[param_idx] if param_idx < len(specs) else None
+                        if spec is not None and spec.kind == "udt":
+                            udt_name = spec.name
+            if udt_name is None:
+                spec = self._type_spec_from_expr(recv)
+                if spec is not None and spec.kind == "udt":
+                    udt_name = spec.name
+            key = f"{udt_name}.{method}" if udt_name else ""
+            return key if key in func_defs else None
+
+        def _find_calls(node, known_funcs: set[str],
+                        owner: str | None = None,
+                        seen: set[int] | None = None) -> list[tuple[str, FuncCall]]:
+            calls: list[tuple[str, FuncCall]] = []
+            if node is None:
+                return calls
+            if seen is None:
+                seen = set()
+            if isinstance(node, (list, tuple, dict)) or hasattr(node, "__dict__"):
+                node_id = id(node)
+                if node_id in seen:
+                    return calls
+                seen.add(node_id)
+            if isinstance(node, (list, tuple)):
+                for item in node:
+                    calls.extend(_find_calls(item, known_funcs, owner, seen))
+                return calls
+            if isinstance(node, dict):
+                for item in node.values():
+                    calls.extend(_find_calls(item, known_funcs, owner, seen))
+                return calls
+            if not hasattr(node, "__dict__"):
+                return calls
+            if isinstance(node, FuncCall):
+                resolved = _resolved_user_call_name(node, owner)
+                if resolved in known_funcs:
+                    calls.append((resolved, node))
             for attr_val in vars(node).values():
-                if isinstance(attr_val, list):
-                    for item in attr_val:
-                        if hasattr(item, '__dict__'):
-                            calls |= _find_calls(item, known_funcs)
-                elif hasattr(attr_val, '__dict__'):
-                    calls |= _find_calls(attr_val, known_funcs)
+                calls.extend(_find_calls(attr_val, known_funcs, owner, seen))
             return calls
 
         known_func_names = set(func_defs.keys())
+        calls_by_parent = {
+            name: _find_calls(func_def, known_func_names, name)
+            for name, func_def in func_defs.items()
+        }
+        calls_by_callee: dict[str, list[FuncCall]] = {
+            name: [] for name in known_func_names
+        }
+        # Preserve source order across definitions and top-level statements.
+        # Method bodies use their ``Type.method`` owner so ``self.sibling()``
+        # resolves without relying on a now-exited symbol-table scope.
+        for stmt in self._ast.body:
+            if isinstance(stmt, FuncDef):
+                owner = stmt.name
+            elif isinstance(stmt, MethodDef):
+                owner = f"{stmt.type_name}.{stmt.name}"
+            else:
+                owner = None
+            for callee, call in _find_calls(stmt, known_func_names, owner):
+                calls_by_callee.setdefault(callee, []).append(call)
+
+        # Codegen synthesizes a Series buffer for two expression shapes that
+        # do not appear in ``_func_series_vars`` themselves:
+        #
+        #   * a call result read through history, e.g. ``f()[1]``;
+        #   * a scalar expression bridged into a UDF series parameter, e.g.
+        #     ``history(close + open)`` where ``history(src) => src[1]``.
+        #
+        # A buffer is mutable per-call-site state just like TA/fixnan.  Mark
+        # its lexical owner stateful before the normal call-path closure so a
+        # function invoked from two source sites receives two emitted bodies
+        # (and therefore two independent generated buffer members).  Without
+        # this, moving the old function-local static into a class member would
+        # accidentally merge both Pine call sites into one history stream.
+        def _actual_arg(call: FuncCall, param_name: str, param_idx: int):
+            if param_idx < len(call.args):
+                return call.args[param_idx]
+            return call.kwargs.get(param_name)
+
+        def _needs_scalar_series_bridge(call: FuncCall) -> bool:
+            if not isinstance(call.callee, Identifier):
+                return False
+            callee = call.callee.name
+            fi = func_info_by_name.get(callee)
+            if fi is None or fi.node is None:
+                return False
+            series_params = self._func_series_vars.get(callee, set())
+            if not series_params:
+                return False
+            direct_bar_series = {
+                "open", "high", "low", "close", "volume",
+                "hl2", "hlc3", "ohlc4",
+            }
+            for idx, param_name in enumerate(fi.node.params):
+                if param_name not in series_params:
+                    continue
+                arg = _actual_arg(call, param_name, idx)
+                if arg is None:
+                    continue
+                if isinstance(arg, Identifier) and (
+                    arg.name in direct_bar_series or arg.name in self._series_vars
+                ):
+                    continue
+                return True
+            return False
+
+        def _has_synthetic_history_state(
+                node, seen: set[int] | None = None) -> bool:
+            if node is None:
+                return False
+            if seen is None:
+                seen = set()
+            if isinstance(node, (list, tuple, dict)) or hasattr(node, "__dict__"):
+                node_id = id(node)
+                if node_id in seen:
+                    return False
+                seen.add(node_id)
+            if isinstance(node, (list, tuple)):
+                return any(
+                    _has_synthetic_history_state(item, seen) for item in node
+                )
+            if isinstance(node, dict):
+                return any(
+                    _has_synthetic_history_state(item, seen)
+                    for item in node.values()
+                )
+            if not hasattr(node, "__dict__"):
+                return False
+            if (isinstance(node, Subscript)
+                    and isinstance(node.object, FuncCall)):
+                return True
+            if isinstance(node, FuncCall) and _needs_scalar_series_bridge(node):
+                return True
+            return any(
+                _has_synthetic_history_state(value, seen)
+                for value in vars(node).values()
+            )
 
-        # For each multi-call-site function, propagate count to sub-functions
-        # that have stateful locals (series vars or var members)
+        synthetic_history_stateful = {
+            name for name, func_def in func_defs.items()
+            if _has_synthetic_history_state(func_def)
+        }
+
+        # request.security owns a separate evaluator context and already
+        # materializes/remaps its embedded TA state per SecurityCallInfo.  Do
+        # not thread ordinary UDF clone indices through a function used as a
+        # security expression (or through the containing wrapper); doing so
+        # would double-clone evaluator state and disturb expression identity.
+        security_boundary_funcs: set[str] = set()
+        for sec in getattr(self, "_security_calls", []) or []:
+            containing = getattr(sec, "containing_func", "") or ""
+            if containing:
+                security_boundary_funcs.add(containing)
+            expression = getattr(sec, "expression", None)
+            if expression is not None:
+                security_boundary_funcs.update(
+                    sub for sub, _ in _find_calls(
+                        expression, known_func_names, containing or None
+                    )
+                )
+
+        # Canonical direct-state predicate.  TA-only and fixnan-only helpers
+        # are just as stateful as functions carrying an explicit series/var.
+        stateful = (
+            set(self._func_series_vars)
+            | set(self._func_var_members)
+            | set(self._func_ta_ranges)
+            | set(self._func_fixnan_indices)
+            | synthetic_history_stateful
+        )
+
+        # Close upward over the call graph so a pure A -> B -> stateful C chain
+        # receives variants at every level.  The existing clone-only emitter
+        # marker is intentionally separate from request.security evaluator
+        # identity, so ordinary security calls remain shared unless the
+        # dedicated timeframe-monomorphization pass clones them.
+        changed = True
+        while changed:
+            changed = False
+            for fname, calls in calls_by_parent.items():
+                if fname in stateful:
+                    continue
+                if any(sub in stateful for sub, _ in calls):
+                    stateful.add(fname)
+                    changed = True
+
+        # Direct fixnan-only functions and pure transitive wrappers own no
+        # TA/series member that would trip the emitter's ordinary body-clone
+        # gate. Reuse its established body-only clone marker; this does not
+        # create or renumber any SecurityCallInfo.
+        for fname in sorted(stateful):
+            if (fname not in self._func_ta_ranges
+                    and fname not in self._func_series_vars
+                    and fname not in self._func_var_members):
+                self._func_security_clone_only.add(fname)
+
+        # The initial visitor only numbers directly-stateful callees. Backfill
+        # stable identities for newly discovered pure wrappers without
+        # disturbing any indices already assigned by the visitor or security
+        # monomorphization.
+        for fname in sorted(stateful):
+            calls = calls_by_callee.get(fname, [])
+            current = self._func_call_site_count.get(fname, 0)
+            next_idx = current
+            for call in calls:
+                if id(call) in self._func_inherited_call_nodes:
+                    continue
+                existing = self._func_call_cs_map.get(id(call))
+                if existing is not None and existing[0] == fname:
+                    next_idx = max(next_idx, existing[1] + 1)
+                    continue
+                self._func_call_cs_map[id(call)] = (fname, next_idx)
+                next_idx += 1
+            if next_idx > current:
+                self._func_call_site_count[fname] = next_idx
+
+        # Inherit each multi-call-site parent's index space down the full path.
+        # Re-run to a fixed point for A -> B -> C chains.
         changed = True
         while changed:
             changed = False
@@ -482,14 +747,32 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                     continue
                 if fname not in func_defs:
                     continue
-                sub_calls = _find_calls(func_defs[fname], known_func_names)
-                for sub in sub_calls:
-                    has_state = (sub in self._func_series_vars or
-                                 sub in self._func_var_members)
-                    if not has_state:
+                if fname in security_boundary_funcs:
+                    continue
+                for sub, call_node in calls_by_parent.get(fname, []):
+                    if sub not in stateful:
                         continue
                     current = self._func_call_site_count.get(sub, 0)
                     if current < count:
+                        # One textual nested call is not an independent cs0
+                        # path: it inherits the active parent clone index.
+                        # Remove the visitor's provisional cs0 map so codegen's
+                        # established active-index fallback dispatches
+                        # F_csK -> G_csK.  Keeping the map would make the
+                        # context-sensitive instance pre-pass pin every parent
+                        # clone to G_cs0 before that fallback can run.
+                        if current == 1:
+                            cs_info = self._func_call_cs_map.get(id(call_node))
+                            if cs_info == (sub, 0):
+                                self._func_call_cs_map.pop(id(call_node), None)
+                                self._func_inherited_call_nodes.add(id(call_node))
+                        for cs_idx in range(current, count):
+                            self._materialize_user_func_call_site_state(
+                                sub,
+                                cs_idx,
+                                call_node,
+                                reuse_existing_owner=fname,
+                            )
                         self._func_call_site_count[sub] = count
                         changed = True
 
@@ -1162,6 +1445,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         old_global = self._global_scope
         self._global_scope = False
         self._enclosing_func_params.append(set(node.params))
+        self._enclosing_func_names.append(node.name)
         self._nested_ta_touched = set()
         try:
             for stmt in node.body:
@@ -1169,6 +1453,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         finally:
             self._global_scope = old_global
             self._enclosing_func_params.pop()
+            self._enclosing_func_names.pop()
             nested_touched = self._nested_ta_touched
             self._nested_ta_touched = None
 
@@ -1184,6 +1469,16 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         if hi > lo:
             self._func_ta_ranges[node.name] = (lo, hi)
 
+        inferred_param_specs = self._param_type_specs_from_def(node)
+        for i, param in enumerate(node.params):
+            if i < len(inferred_param_specs) and inferred_param_specs[i] is not None:
+                continue
+            sym = self._symbols.resolve(param)
+            spec = getattr(sym, "type_spec", None) if sym is not None else None
+            if spec is not None and i < len(inferred_param_specs):
+                inferred_param_specs[i] = spec
+        self._func_param_type_specs[node.name] = inferred_param_specs
+
         self._symbols.exit_scope()
 
         # Detect if function returns a tuple (last stmt is TupleLiteral)
@@ -1511,6 +1806,20 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
 
         # String concatenation: if either side is STRING, result is STRING
         if left_type == PineType.STRING or right_type == PineType.STRING:
+            def _mark_string_param(expr) -> None:
+                if not isinstance(expr, Identifier):
+                    return
+                sym = self._symbols.resolve(expr.name)
+                if sym is None or not (sym.scope or "").startswith("func_"):
+                    return
+                if sym.pine_type == PineType.UNKNOWN:
+                    sym.pine_type = PineType.STRING
+                    sym.type_spec = TypeSpec.primitive("string")
+
+            if left_type == PineType.STRING:
+                _mark_string_param(node.right)
+            if right_type == PineType.STRING:
+                _mark_string_param(node.left)
             return PineType.STRING
 
         # Arithmetic: promote to FLOAT if either side is FLOAT
@@ -1583,11 +1892,14 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             if isinstance(obj, Identifier) and obj.name == "str":
                 for arg in node.args:
                     self._visit(arg)
-                # Most str.* return a string, but a few don't:
-                #   str.tonumber -> float, str.length -> int
+                # Most str.* return a string, but predicates and index helpers
+                # are scalar. Keep this aligned with signatures.py and the C++
+                # emitter's _infer_type path.
+                if member in ("contains", "startswith", "endswith"):
+                    return PineType.BOOL
                 if member == "tonumber":
                     return PineType.FLOAT
-                if member == "length":
+                if member in ("length", "pos"):
                     return PineType.INT
                 return PineType.STRING
 
@@ -1812,9 +2124,11 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
 
             # syminfo.*
             if ns == "syminfo":
-                if node.member == "mintick":
-                    return PineType.FLOAT
-                return PineType.STRING
+                from .. import signatures as _pf_sigs
+                return _pf_sigs.SYMINFO_VARIABLES.get(
+                    f"syminfo.{node.member}",
+                    PineType.STRING,
+                )
 
             # color.* constants
             if ns == "color":
@@ -1873,7 +2187,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
 
             # text.* constants (align_left, align_right, etc.)
             if ns == "text":
-                return PineType.INT
+                return PineType.STRING
 
             # extend.* constants (left, right, both, none)
             if ns == "extend":