pineforge-codegen 0.7.6__py3-none-any.whl → 0.8.1__py3-none-any.whl

pineforge_codegen/analyzer/base.py

@@ -127,6 +127,20 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         self._global_var_decls: list[tuple[str, PineType]] = []
         self._global_expr_map: dict[str, Any] = {}
         self._var_member_init_exprs: dict[str, Any] = {}
+        # Block-scoped ``var``/``varip`` name-collision disambiguation.
+        # Two same-named block-scoped vars in SIBLING non-global, non-function
+        # scopes (e.g. ``var bool valid`` declared inside ``if A`` and again
+        # inside ``if B``) would otherwise dedupe to ONE C++ member and
+        # cross-contaminate. ``_block_node_stack`` tracks the enclosing
+        # block AST nodes during analysis; ``_block_var_owner`` maps a raw
+        # block-var name to the id() of the FIRST block that declared it;
+        # ``_block_var_renames`` maps id(block_node) -> {raw_name: unique}
+        # for every later colliding block so codegen can activate the
+        # rename via ``_active_var_remap`` while emitting that block.
+        self._block_node_stack: list[Any] = []
+        self._block_var_owner: dict[str, int] = {}
+        self._block_var_renames: dict[int, dict[str, str]] = {}
+        self._block_var_seq = 0
         self._ta_counter = 0
         self._fixnan_counter = 0
         # Track user-defined function nodes for deferred analysis
@@ -141,6 +155,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         # expression (``=> Sample.new(...)`` or last stmt ``Sample.new(...)``).
         # 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"] = {}
         # 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]
@@ -148,6 +163,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).
+        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
+        # ``{orig}_cs{cs_idx}`` formula by default, but a TA site reached through
+        # MULTIPLE enclosing functions (e.g. a helper cloned both directly and via
+        # a range-widened outer function) can collide on that formula. When the
+        # analyzer must disambiguate a clone's member name, it records the actual
+        # chosen name here so the codegen consumes it verbatim instead of
+        # re-deriving a colliding name. Empty for the common (no-collision) case,
+        # keeping generated output byte-identical.
+        self._func_cs_ta_clone_names: dict[tuple[str, int], dict[str, str]] = {}
+        # All TA member names minted so far (base + clones), for O(1) collision
+        # detection when minting a new clone.
+        self._ta_member_names: set[str] = set()
         # UDT field definitions: type_name -> {field_name: PineType}
         self._udt_fields: dict[str, dict[str, PineType]] = {}
         # var_name -> UDT type for variables holding UDT instances
@@ -163,6 +195,14 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         self._current_top_level_stmt: ASTNode | None = None
         self._global_scope = True
         self._static_vars: set[str] = set()
+        # Stack of enclosing user-function param-name sets, pushed while visiting
+        # a FuncDef body. Lets a nested user-func call detect when it substitutes
+        # 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]] = []
+        # 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
 
         # Pre-populate builtins
         self._populate_builtins()
@@ -232,6 +272,11 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         # can call g_csK with isolated state.
         self._propagate_call_site_counts()
 
+        # Reject (loudly) a request.security whose timeframe is a UDF parameter
+        # called with multiple distinct literal timeframes — a single evaluator
+        # cannot serve them and per-callsite specialization is not yet wired.
+        self._check_mixed_callsite_security_tf()
+
         # Keep only truly pure global expressions for request.security rebinding.
         # Globals later reassigned with := become series/stateful variables and
         # must not be rebound to their declaration-time initializer.
@@ -266,6 +311,8 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             func_ta_ranges=self._func_ta_ranges,
             func_call_cs_map=self._func_call_cs_map,
             func_call_site_counts=self._func_call_site_count,
+            func_security_clone_only=self._func_security_clone_only,
+            func_cs_ta_clone_names=self._func_cs_ta_clone_names,
             udt_defs=self._udt_fields,
             enum_defs=self._enum_defs,
             enum_member_strings=self._enum_member_strings,
@@ -273,9 +320,11 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             global_mutable_infos=mutable_global_infos,
             func_var_members=self._func_var_members,
             func_series_vars=self._func_series_vars,
+            func_return_type_specs=dict(self._func_return_type_specs),
             udt_var_types=dict(self._udt_var_types),
             collection_types=dict(self._collection_types),
             udt_field_type_specs=dict(self._udt_field_type_specs),
+            block_var_renames=dict(self._block_var_renames),
         )
 
     def _record_global_binding_stmt(self, name: str, pine_type: PineType,
@@ -299,6 +348,18 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         if top_stmt is not None and (not info.source_stmts or info.source_stmts[-1] is not top_stmt):
             info.source_stmts.append(top_stmt)
 
+    @staticmethod
+    def _is_input_func_call(node: FuncCall) -> bool:
+        """True for an ``input(...)`` or ``input.<member>(...)`` call."""
+        callee = node.callee
+        if isinstance(callee, Identifier) and callee.name == "input":
+            return True
+        return (
+            isinstance(callee, MemberAccess)
+            and isinstance(callee.object, Identifier)
+            and callee.object.name == "input"
+        )
+
     def _collect_security_mutable_globals(
         self, node: ASTNode | None, resolving: set[str] | None = None
     ) -> set[str]:
@@ -344,6 +405,20 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 resolving.remove(call_key)
                 return out
 
+        if isinstance(node, FuncCall) and self._is_input_func_call(node):
+            # An ``input.*()`` / ``input()`` initializer is a compile-time
+            # constant. Only its defval (first positional or ``defval=``) can
+            # carry a genuine data dependency; the cosmetic kwargs
+            # (group/tooltip/title/inline/display/confirm/minval/maxval/step)
+            # are presentation-only. Walking them would falsely pull a
+            # ``var string GROUP = "..."`` label into the security's
+            # mutable-globals set and trip the "TA ctor depends on rebound
+            # mutable globals" reject (parallax / higherTimeframeLength).
+            defval = node.args[0] if node.args else node.kwargs.get("defval")
+            if defval is not None:
+                out |= self._collect_security_mutable_globals(defval, resolving)
+            return out
+
         def walk(value: Any) -> None:
             nonlocal out
             if value is None:
@@ -418,6 +493,188 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                         self._func_call_site_count[sub] = count
                         changed = True
 
+    # ------------------------------------------------------------------
+    # Mixed-callsite UDF timeframe-param security rejection.
+    #
+    # A ``request.security`` whose ``timeframe`` is a parameter of its
+    # containing UDF maps to ONE evaluator regardless of how many times the
+    # UDF is called. When the UDF is called from >= 2 sites with DISTINCT
+    # literal timeframes, a single evaluator cannot faithfully serve them
+    # all and the resolver would silently collapse onto the chart timeframe
+    # (``input_tf_``). Per-callsite evaluator specialization (cloning the
+    # evaluator + UDF) is the correct fix but is not wired in this iteration,
+    # so we reject deterministically instead of emitting wrong semantics.
+    # ------------------------------------------------------------------
+    def _check_mixed_callsite_security_tf(self) -> None:
+        sec_calls = getattr(self, "_security_calls", None)
+        if not sec_calls:
+            return
+        # Build user-function definitions lookup once.
+        func_defs: dict[str, FuncDef] = {}
+        for stmt in self._ast.body:
+            if isinstance(stmt, FuncDef):
+                func_defs[stmt.name] = stmt
+
+        new_calls: list[SecurityCallInfo] = []
+        cloned_any = False
+        for sec in sec_calls:
+            containing = getattr(sec, "containing_func", "") or ""
+            tf_node = getattr(sec, "timeframe", None)
+            if not containing or not isinstance(tf_node, Identifier):
+                new_calls.append(sec)
+                continue
+            param_name = tf_node.name
+            fdef = func_defs.get(containing)
+            if fdef is None or param_name not in fdef.params:
+                new_calls.append(sec)
+                continue
+            pidx = fdef.params.index(param_name)
+            calls = list(self._iter_user_func_calls(containing))
+            if not calls:
+                new_calls.append(sec)  # dead code — evaluator result never read
+                continue
+            # Number call sites for THIS function. If ``containing`` already
+            # has TA call sites or series/var members, the per-call-site
+            # UDF-body-cloning mechanism already numbered its call sites in
+            # _func_call_cs_map (a request.security nested ta.* registers as
+            # part of the function-body walk, same as a top-level ta.* call)
+            # — reuse that authoritative numbering so this clone's
+            # callsite_idx stays aligned with self._active_call_site_idx.
+            # Otherwise (e.g. ``f(tf) => request.security(sym, tf, close)``
+            # with no nested ta.* call) that mechanism never fired for this
+            # function at all, since it gates on has_ta/has_series; assign
+            # fresh cs_idx ourselves in call-site order and BACKFILL
+            # func_call_cs_map / func_call_site_count / func_security_clone_only
+            # so the codegen actually clones this function's body too (the
+            # has_ta/has_series emission gate ORs in func_security_clone_only
+            # — see codegen/base.py) and the existing top-level call-site
+            # naming (which keys purely off func_call_cs_map, not
+            # has_ta/has_series) picks the right ``_cs{N}`` variant.
+            already_tracked = self._func_call_site_count.get(containing, 0) > 0
+            per_cs: list[tuple[int, str | None]] = []
+            for i, call in enumerate(calls):
+                if already_tracked:
+                    cs_info = self._func_call_cs_map.get(id(call))
+                    if cs_info is None or cs_info[0] != containing:
+                        continue  # shouldn't happen: has_ta/has_series tracks ALL call sites
+                    cs_idx = cs_info[1]
+                else:
+                    cs_idx = i
+                    self._func_call_cs_map.setdefault(id(call), (containing, cs_idx))
+                arg = call.args[pidx] if pidx < len(call.args) else None
+                lit = self._callsite_tf_literal_value(arg)
+                per_cs.append((cs_idx, lit))
+            if not per_cs:
+                new_calls.append(sec)  # dead code — evaluator result never read
+                continue
+            distinct_literals = {lit for _, lit in per_cs if lit is not None}
+            if len(distinct_literals) < 2:
+                new_calls.append(sec)  # single TF (or unresolved) — no cloning needed
+                continue
+            if any(lit is None for _, lit in per_cs):
+                # Some call site's tf isn't a compile-time literal — can't
+                # pin every clone to a concrete timeframe. Keep the original
+                # deterministic rejection rather than guess.
+                self._error(
+                    "request.security timeframe parameter '"
+                    + param_name
+                    + "' of function '"
+                    + containing
+                    + "' is called with multiple distinct literal timeframes ("
+                    + ", ".join(sorted(distinct_literals))
+                    + "). A single request.security evaluator cannot serve "
+                    "them all and would silently collapse onto the chart "
+                    "timeframe. Pass a single timeframe, or inline a separate "
+                    "request.security call at each call site.",
+                    tf_node.loc,
+                )
+                new_calls.append(sec)
+                continue
+            if not already_tracked:
+                # First thing establishing per-call-site identity for this
+                # function — make it authoritative so the codegen's
+                # function-emission gate (has_ta or has_series or
+                # func_security_clone_only) actually clones its body, with
+                # self._active_call_site_idx set to each of our cs_idx values
+                # in turn while it does.
+                self._func_call_site_count[containing] = len(calls)
+                self._func_security_clone_only.add(containing)
+            # Clone: one SecurityCallInfo per call site, each pinned to that
+            # site's literal timeframe via a synthetic StringLiteral (so the
+            # existing literal-timeframe resolution path needs no changes)
+            # and given a fresh, currently-unused sec_id.
+            next_sec_id = max((s.sec_id for s in sec_calls), default=-1) + 1
+            next_sec_id = max(next_sec_id, len(sec_calls) + len(new_calls))
+            for cs_idx, lit in sorted(per_cs):
+                clone = SecurityCallInfo(
+                    sec_id=next_sec_id,
+                    timeframe=StringLiteral(value=lit, loc=tf_node.loc),
+                    expression=sec.expression,
+                    returns_tuple=sec.returns_tuple,
+                    tuple_size=sec.tuple_size,
+                    gaps=sec.gaps,
+                    lookahead=sec.lookahead,
+                    ta_range=sec.ta_range,
+                    depends_on_mutable_globals=sec.depends_on_mutable_globals,
+                    mutable_globals=sec.mutable_globals,
+                    is_lower_tf_array=sec.is_lower_tf_array,
+                    containing_func=sec.containing_func,
+                    callsite_idx=cs_idx,
+                )
+                new_calls.append(clone)
+                next_sec_id += 1
+            cloned_any = True
+
+        if cloned_any:
+            # A freshly-backfilled func_call_site_count[containing] may need
+            # to cascade to a sub-function containing's body calls (the same
+            # propagation _propagate_call_site_counts() already did once
+            # before this method ran) — re-run it now that backfill exists.
+            self._propagate_call_site_counts()
+            # Renumber sec_id contiguously 0..N-1 in final list order — the
+            # codegen indexes _security_eval_info / register_security_eval /
+            # _eval_security_N by sec_id, all assumed dense from registration
+            # order. The provisional IDs assigned above only needed to be
+            # distinct from each other while building new_calls; this final
+            # pass is what callers (e.g. the codegen's expr_node identity
+            # lookup, which now also keys off callsite_idx) actually see.
+            for i, sec in enumerate(new_calls):
+                sec.sec_id = i
+            self._security_calls = new_calls
+
+    def _iter_user_func_calls(self, func_name: str):
+        """Yield every ``func_name(...)`` call anywhere in the AST (top-level
+        and nested inside function bodies)."""
+        def _walk(node):
+            if node is None:
+                return
+            if (isinstance(node, FuncCall) and isinstance(node.callee, Identifier)
+                    and node.callee.name == func_name):
+                yield node
+            for attr_val in vars(node).values():
+                if isinstance(attr_val, list):
+                    for item in attr_val:
+                        if hasattr(item, "__dict__"):
+                            yield from _walk(item)
+                elif attr_val is not None and hasattr(attr_val, "__dict__"):
+                    yield from _walk(attr_val)
+        yield from _walk(self._ast)
+
+    def _callsite_tf_literal_value(self, arg) -> str | None:
+        """Resolve a UDF call-site timeframe argument to a literal string
+        value when it is statically known: a string literal, or a known
+        constant / input-backed variable whose stored value is a string.
+        Returns None for anything that is not a compile-time string."""
+        if isinstance(arg, StringLiteral):
+            return arg.value
+        if isinstance(arg, Identifier):
+            sym = self._symbols.resolve(arg.name)
+            if sym is not None and getattr(sym, "const_value", None) is not None:
+                val = sym.const_value
+                if isinstance(val, str):
+                    return val
+        return None
+
     def _is_static_expression(self, node: ASTNode | None) -> bool:
         if node is None:
             return True
@@ -535,19 +792,105 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
     # ------------------------------------------------------------------
 
     def _udt_name_from_ctor(self, value: ASTNode) -> str | None:
-        """If value is ``TypeName.new(...)`` for a user-defined type, return TypeName."""
+        """If value is ``TypeName.new(...)`` for a user-defined type OR a
+        drawing handle (``label.new``/``line.new``/``box.new``/``linefill.new``),
+        return the type name."""
         if not isinstance(value, FuncCall):
             return None
         cal = value.callee
         if not isinstance(cal, MemberAccess) or not isinstance(cal.object, Identifier):
             return None
         owner = cal.object.name
-        if owner not in self._udt_fields:
-            return None
         m = cal.member
-        if m == "new" or (isinstance(m, str) and m.startswith("new")):
+        if not (m == "new" or (isinstance(m, str) and m.startswith("new"))):
+            return None
+        # Drawing-objects-as-data: label.new(...)/line.new(...)/... return a
+        # handle of the self-type. These are not in _udt_fields (they are not
+        # user UDTs) but must still be recognised so a function whose body ends
+        # in label.new(...) emits a ``Label`` (not ``double``) return type.
+        from .types import _DRAWING_TYPE_NAMES
+        if owner in _DRAWING_TYPE_NAMES:
             return owner
-        return None
+        if owner not in self._udt_fields:
+            return None
+        return owner
+
+    def _func_terminal_drawing_type(self, func_node: FuncDef) -> str | None:
+        """Resolve the drawing-handle / UDT type of a function's terminal
+        (return) expression for cases the direct ``_udt_name_from_ctor`` on the
+        last statement misses:
+
+          - the last statement is an ``IfStmt`` whose terminal branch yields a
+            drawing/UDT constructor (``makeEventLabel`` => ``if cond\\n
+            label.new(...)``); and
+          - the last statement is a bare ``Identifier`` bound to a
+            drawing-handle local (``setTradeLine`` => ``line result = ...`` then
+            a trailing ``result``).
+
+        Returns the drawing/UDT type name, or ``None``. Without this a function
+        that returns a ``line``/``label`` handle this way is mis-typed
+        ``double`` and clang rejects ``no viable conversion from Line to
+        double``.
+        """
+        from .types import _DRAWING_TYPE_NAMES
+
+        body = func_node.body
+        if not body:
+            return None
+
+        # Map a drawing-handle local var name -> drawing type. Seeded from
+        # declared drawing type hints (``line result``) and the function's own
+        # drawing-typed parameters, plus any local first bound to a drawing
+        # ``<ns>.new(...)`` constructor.
+        local_drawing: dict[str, str] = {}
+        param_hints = (func_node.annotations or {}).get("param_type_hints", [])
+        for i, p in enumerate(func_node.params):
+            hint = param_hints[i] if i < len(param_hints) else None
+            if hint in _DRAWING_TYPE_NAMES:
+                local_drawing[p] = hint
+
+        def _scan(stmts):
+            for st in stmts:
+                if isinstance(st, VarDecl):
+                    if st.type_hint in _DRAWING_TYPE_NAMES:
+                        local_drawing[st.name] = st.type_hint
+                    else:
+                        dt = self._udt_name_from_ctor(st.value)
+                        if dt in _DRAWING_TYPE_NAMES:
+                            local_drawing.setdefault(st.name, dt)
+                elif isinstance(st, Assignment) and isinstance(st.target, Identifier):
+                    dt = self._udt_name_from_ctor(st.value)
+                    if dt in _DRAWING_TYPE_NAMES:
+                        local_drawing.setdefault(st.target.name, dt)
+                elif isinstance(st, IfStmt):
+                    _scan(st.body)
+                    _scan(st.else_body)
+
+        _scan(body)
+
+        def _resolve_terminal(stmt):
+            # An if used as the function's return expression: the value is the
+            # terminal of the executed branch — recurse into the body's (then
+            # else's) terminal statement.
+            if isinstance(stmt, IfStmt):
+                for branch in (stmt.body, stmt.else_body):
+                    if branch:
+                        t = _resolve_terminal(branch[-1])
+                        if t is not None:
+                            return t
+                return None
+            expr = None
+            if isinstance(stmt, ExprStmt):
+                expr = stmt.expr
+            elif not isinstance(stmt, TupleLiteral) and hasattr(stmt, "loc"):
+                expr = stmt
+            if expr is None:
+                return None
+            if isinstance(expr, Identifier) and expr.name in local_drawing:
+                return local_drawing[expr.name]
+            return self._udt_name_from_ctor(expr)
+
+        return _resolve_terminal(body[-1])
 
     def _visit_VarDecl(self, node: VarDecl) -> PineType:
         # Infer type from the value expression
@@ -620,14 +963,41 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         # Track var members
         if node.is_var or node.is_varip:
             init_str = self._expr_to_str(node.value)
-            self._var_members.append((node.name, val_type, init_str))
+            scope_name = self._symbols.current_scope.name
+            # Block-scoped var name-collision disambiguation. A ``var``/``varip``
+            # declared inside a non-global, non-function block (an ``if`` / ``for``
+            # / ``while`` body at on_bar scope) is keyed by RAW name. Two sibling
+            # blocks declaring the same name would dedupe to ONE C++ member and
+            # cross-contaminate (proven: egoigor1976-1-trendline-strategy's
+            # ``var bool valid`` in the upper- and lower-trendline ``if`` blocks).
+            # When such a name already belongs to a DIFFERENT block, mint a
+            # scope-unique member name and record the rename so codegen activates
+            # it (via ``_active_var_remap``) while emitting that block.
+            member_name = node.name
+            is_block_scoped = (
+                not self._global_scope
+                and not scope_name.startswith("func_")
+                and not scope_name.startswith("method_")
+                and bool(self._block_node_stack)
+            )
+            if is_block_scoped:
+                block_id = id(self._block_node_stack[-1])
+                owner = self._block_var_owner.get(node.name)
+                if owner is None:
+                    # First block to claim this name keeps the raw member name.
+                    self._block_var_owner[node.name] = block_id
+                elif owner != block_id:
+                    # Sibling-scope collision: disambiguate this declaration.
+                    self._block_var_seq += 1
+                    member_name = f"{node.name}__blk{self._block_var_seq}"
+                    self._block_var_renames.setdefault(block_id, {})[node.name] = member_name
+            self._var_members.append((member_name, val_type, init_str))
             # Capture the init AST too so codegen can inspect the RHS callee
             # (used to detect int64-returning builtins like ``time()`` and
             # promote the symbol storage type to ``int64_t``).
             if node.value is not None:
-                self._var_member_init_exprs[node.name] = node.value
+                self._var_member_init_exprs[member_name] = node.value
             # Track function-scoped var members
-            scope_name = self._symbols.current_scope.name
             if scope_name.startswith("func_"):
                 func_name = scope_name[5:]  # strip "func_" prefix
                 if func_name not in self._func_var_members:
@@ -732,6 +1102,20 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 setattr(sym, "is_static_series", True)
             self._symbols.define(sym)
 
+            # Track global-scope tuple-assign targets (e.g.
+            # ``[pdH, pdL] = request.security(...)``) as class members so user
+            # functions / later references resolve — mirroring _visit_VarDecl.
+            # Without this the names are never declared and the C++ errors with
+            # "use of undeclared identifier".
+            if (self._global_scope
+                    and self._symbols.current_scope.name == "global"
+                    and name not in self._series_vars):
+                self._global_var_decls.append((name, PineType.FLOAT))
+                self._global_expr_map[name] = node.value
+                self._record_global_binding_stmt(
+                    name, PineType.FLOAT, False, decl_node=node,
+                )
+
         return val_type
 
     # ------------------------------------------------------------------
@@ -745,18 +1129,28 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         # Enter function scope
         self._symbols.enter_scope(f"func_{node.name}")
 
-        # Define parameters (type unknown until called)
+        # Define parameters. The type is UNKNOWN until inferred from a call
+        # site, BUT a declared type hint (``string tf``, ``pivot hi``, ``line[] arr``)
+        # is authoritative — record it as the symbol's ``type_spec`` / ``pine_type``
+        # so (a) the param emits with the right C++ type and (b) callers passing
+        # this param into another function can infer that function's param type
+        # (e.g. ``getLineStyle(styleStr)`` where ``styleStr`` is a ``string`` param).
         loc = node.loc or SourceLocation(file=self._filename, line=1, col=1, end_col=1)
-        for param in node.params:
+        param_hints = (node.annotations or {}).get("param_type_hints", [])
+        for i, param in enumerate(node.params):
+            hint = param_hints[i] if i < len(param_hints) else None
+            pspec = self._type_spec_from_hint(hint) if hint else None
+            ptype = self._type_hint_to_pine(hint) if hint else PineType.UNKNOWN
             sym = Symbol(
                 name=param,
-                pine_type=PineType.UNKNOWN,
+                pine_type=ptype,
                 is_series=False,
                 is_var=False,
                 is_const=False,
                 const_value=None,
                 scope=f"func_{node.name}",
                 loc=loc,
+                type_spec=pspec,
             )
             self._symbols.define(sym)
 
@@ -767,16 +1161,28 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         body_type = PineType.VOID
         old_global = self._global_scope
         self._global_scope = False
+        self._enclosing_func_params.append(set(node.params))
+        self._nested_ta_touched = set()
         try:
             for stmt in node.body:
                 body_type = self._visit(stmt)
         finally:
             self._global_scope = old_global
-
-        # Record TA range for this function
+            self._enclosing_func_params.pop()
+            nested_touched = self._nested_ta_touched
+            self._nested_ta_touched = None
+
+        # Record TA range for this function. Widen to cover any nested-callee TA
+        # sites whose ctor args were rewritten in terms of THIS function's params
+        # (e.g. f_basisMa's sites parameterized by f_bbwp's _bbwLen), so resolving
+        # this function at its call site re-substitutes those nested sites too.
         ta_end = len(self._ta_call_sites)
-        if ta_end > ta_start:
-            self._func_ta_ranges[node.name] = (ta_start, ta_end)
+        lo, hi = ta_start, ta_end
+        if nested_touched:
+            lo = min(lo, min(nested_touched))
+            hi = max(hi, max(nested_touched) + 1)
+        if hi > lo:
+            self._func_ta_ranges[node.name] = (lo, hi)
 
         self._symbols.exit_scope()
 
@@ -807,8 +1213,23 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 # last_stmt is itself an expression node (single-expr funcs)
                 ret_expr = last_stmt if hasattr(last_stmt, "loc") else None
             udt_ret = self._udt_name_from_ctor(ret_expr) if ret_expr is not None else None
+            if udt_ret is None:
+                # Drawing-handle returns wrapped in an if-statement terminal
+                # branch (``makeEventLabel``) or returned as a bare drawing-handle
+                # local (``setTradeLine``) are not direct ctors on the last
+                # expression — resolve them so the function emits the C++ handle
+                # type (Line/Label/...) instead of the ``double`` default.
+                udt_ret = self._func_terminal_drawing_type(node)
             if udt_ret is not None:
                 self._func_udt_return_types[node.name] = udt_ret
+            # Array-return inference: a function whose body ends in
+            # ``array.from(...)`` / ``array.new<T>(...)`` / a UDT method
+            # returning an array returns a ``std::vector<...>``. The coarse
+            # PineType return can't represent this, so carry the TypeSpec.
+            if ret_expr is not None:
+                ret_spec = self._type_spec_from_expr(ret_expr)
+                if ret_spec is not None and ret_spec.kind == "array":
+                    self._func_return_type_specs[node.name] = ret_spec
 
         # Store return type
         self._func_return_types[node.name] = body_type
@@ -880,12 +1301,14 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
         loc = node.loc or SourceLocation(file=self._filename, line=1, col=1, end_col=1)
         param_hints = (node.annotations or {}).get("param_type_hints", [])
         param_types: list[PineType] = []
+        param_specs: list = []
         for i, p in enumerate(node.params):
             udt_self = node.type_name if i == 0 else None
             hint = param_hints[i] if i < len(param_hints) else None
             ptype = self._type_hint_to_pine(hint) if hint else PineType.FLOAT
             pspec = self._type_spec_from_hint(hint) if hint else None
             param_types.append(ptype)
+            param_specs.append(pspec)
             self._symbols.define(Symbol(
                 name=p, pine_type=ptype, is_series=False,
                 is_var=False, is_const=False, const_value=None,
@@ -939,6 +1362,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             returns_tuple=returns_tuple,
             tuple_element_count=tuple_element_count,
             param_defaults=param_defaults,
+            param_type_specs=param_specs,
         )
         self._func_infos.append(fi)
         return PineType.VOID
@@ -950,6 +1374,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
     def _visit_IfStmt(self, node: IfStmt) -> PineType:
         old_global = self._global_scope
         self._global_scope = False
+        self._block_node_stack.append(node)
         try:
             self._visit(node.condition)
             body_type = PineType.VOID
@@ -958,6 +1383,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             for stmt in node.else_body:
                 self._visit(stmt)
         finally:
+            self._block_node_stack.pop()
             self._global_scope = old_global
         # If used as expression (x = if ...), return last expr type
         return body_type
@@ -981,6 +1407,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
 
         old_global = self._global_scope
         self._global_scope = False
+        self._block_node_stack.append(node)
         try:
             self._visit(node.start)
             self._visit(node.end)
@@ -989,6 +1416,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
             for stmt in node.body:
                 self._visit(stmt)
         finally:
+            self._block_node_stack.pop()
             self._global_scope = old_global
 
         self._symbols.exit_scope()
@@ -997,6 +1425,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
     def _visit_ForInStmt(self, node) -> PineType:
         old_global = self._global_scope
         self._global_scope = False
+        self._block_node_stack.append(node)
         try:
             self._visit(node.iterable)
             self._symbols.enter_scope("for_in")
@@ -1019,17 +1448,20 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                 self._visit(stmt)
             self._symbols.exit_scope()
         finally:
+            self._block_node_stack.pop()
             self._global_scope = old_global
         return PineType.VOID
 
     def _visit_WhileStmt(self, node: WhileStmt) -> PineType:
         old_global = self._global_scope
         self._global_scope = False
+        self._block_node_stack.append(node)
         try:
             self._visit(node.condition)
             for stmt in node.body:
                 self._visit(stmt)
         finally:
+            self._block_node_stack.pop()
             self._global_scope = old_global
         return PineType.VOID
 
@@ -1151,6 +1583,12 @@ 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
+                if member == "tonumber":
+                    return PineType.FLOAT
+                if member == "length":
+                    return PineType.INT
                 return PineType.STRING
 
             # request.* calls