@pineforge/codegen-pyodide 0.7.6 → 0.8.1

package/pineforge_codegen/codegen/emit_top.py

@@ -90,6 +90,7 @@ from ..analyzer import FuncInfo
 from ..symbols import TypeSpec
 from .tables import (
     BAR_SERIES_PUSH,
+    DRAWING_TYPE_TO_CPP,
     PINE_TYPE_TO_CPP,
     RUNTIME_REGISTER_SECURITY_EVAL_FN,
     RUNTIME_REGISTER_SECURITY_LOWER_TF_EVAL_FN,
@@ -136,6 +137,11 @@ class TopLevelEmitter:
             float_spec = TypeSpec.primitive("float")
             if any(spec.element != float_spec for spec in self._matrix_specs.values()):
                 lines.append('#include <pineforge/generic_matrix.hpp>')
+        # Drawing-objects-as-data runtime (line/box/label/linefill arenas +
+        # ChartPoint). Gated on _uses_drawing so non-drawing strategies stay
+        # byte-identical — mirrors the matrix.hpp gating above.
+        if getattr(self, "_uses_drawing", False):
+            lines.append('#include <pineforge/drawing.hpp>')
         lines.append("")
         # Compatibility shim for the namespace-wrap refactor: unqualified
         # references to BacktestEngine / Bar / na<T>() / ta::* / etc. resolve
@@ -182,19 +188,55 @@ class TopLevelEmitter:
         for node in self._walk_ast(self.ctx.ast):
             if not isinstance(node, FuncCall):
                 continue
-            func_name, namespace = self._resolve_callee(node.callee)
-            if namespace == "input" and func_name == "source":
+            if self._is_source_input(node):
                 return True
         return False
 
+    def _typed_na_init(self, cpp_val: str, name: str, ptype) -> str:
+        """Re-type a bare ``na<double>()`` initializer to match a non-double
+        member's C++ type. A ``var int x = na`` resolves its RHS to
+        ``na<double>()`` (a quiet NaN); constructing/pushing that into an int or
+        bool member is a NaN->int conversion (UB) that yields garbage and defeats
+        ``is_na<T>()`` (which checks the type sentinel, e.g. INT_MIN). Returns the
+        value unchanged unless it is exactly ``na<double>()`` and the member type
+        is non-double."""
+        if cpp_val != "na<double>()":
+            return cpp_val
+        cpp_type = PINE_TYPE_TO_CPP.get(ptype, "double")
+        if cpp_type == "int" and self._is_int64_builtin_init(name):
+            cpp_type = "int64_t"
+        if cpp_type == "double":
+            return cpp_val
+        return f"na<{cpp_type}>()"
+
     def _emit_constructor(self, lines: list[str]) -> None:
         init_parts: list[str] = []
         # TA members with ctor args
         for site in self.ctx.ta_call_sites:
             if site.ctor_args:
+                # If a ctor arg is neither a compile-time literal nor expandable
+                # to an input-backed runtime expression, the old code silently
+                # emitted period 1 with no overwriting reset — a wrong indicator
+                # masquerading as a working one. Refuse loudly instead. Args that
+                # DO expand to a runtime expr (input-backed / arithmetic-over-input,
+                # incl. function-derived lengths) are safe: the `!_ta_initialized_`
+                # reset overwrites the placeholder before the first compute.
+                for a in site.ctor_args:
+                    r = self._resolve_known(a)
+                    if (not self._is_compile_time_value(r)
+                            and self._runtime_ctor_arg_for_reset(a) is None):
+                        self._codegen_error(
+                            getattr(site, "node", None),
+                            f"Unsupported TA constructor length '{a}' for "
+                            f"{site.class_name}: it is neither a compile-time "
+                            f"constant nor derived from an input, so PineForge "
+                            f"cannot size the indicator buffer.",
+                            hint=("Use a literal, an input.*() value, or "
+                                  "arithmetic over those for TA lengths."),
+                        )
                 resolved = [self._resolve_known(a) for a in site.ctor_args]
-                # If any ctor arg isn't a compile-time value, use default 1
-                # (TA in user functions with runtime params)
+                # Compile-time placeholder for the init list; the runtime reset
+                # (when the arg is input-derived) overwrites it on the first bar.
                 safe_resolved = []
                 for r in resolved:
                     if self._is_compile_time_value(r):
@@ -224,8 +266,27 @@ class TopLevelEmitter:
             safe = self._safe_name(name)
             if name in self._array_vars or name in self._map_vars:
                 continue
+            # Function-scoped ``var`` members are initialized once-per-variant
+            # on first call (see _emit_func_var_init_block); exclude them from
+            # the constructor so they are not double-initialized and so their
+            # (possibly bar-dependent) initializer is lowered in the function's
+            # own scope (with its active var remap for clones).
+            if name in getattr(self, "_func_local_var_names", ()):
+                continue
+            # UDT-typed var members (``var SDZone z = na``) default-construct to
+            # na via the struct's in-class ``__pf_na = true``; a ctor init like
+            # ``z(na<double>())`` would not type-match the struct member.
+            if name in self._udt_var_types and self._udt_var_types[name] in self._udt_defs:
+                continue
+            # Drawing handle var member (L-N3): ``var line x`` / ``var box b``
+            # default-construct to {-1} (na). A ``b(na<double>())`` ctor init
+            # would not type-match the handle struct — skip it (the in-class
+            # member default is the once-only persistent na init).
+            if name in self._udt_var_types and self._udt_var_types[name] in DRAWING_TYPE_TO_CPP:
+                continue
             if name not in self.ctx.series_vars:
                 cpp_val = self._resolve_known(init_expr)
+                cpp_val = self._typed_na_init(cpp_val, name, ptype)
                 if self._is_compile_time_value(cpp_val):
                     init_parts.append(f"{safe}({cpp_val})")
         # Strategy params that map to engine members
@@ -340,20 +401,22 @@ class TopLevelEmitter:
             lines.append("        security_eval_states_.clear();")
             for info in self._security_eval_info:
                 tf = info.get("tf")
-                tf_expr = None
+                tf_expr = info.get("tf_expr")
                 if tf:
                     tf_expr = f'"{tf}"'
-                else:
-                    tf_node = info.get("tf_node")
-                    if tf_node is not None:
-                        if isinstance(tf_node, Identifier) and tf_node.name in self._timeframe_period_vars:
-                            tf_expr = "script_tf_"
-                        else:
-                            raw_tf_expr = self._visit_expr(tf_node)
-                            tf_expr = self._runtime_ctor_arg_for_reset(raw_tf_expr) or raw_tf_expr
+                elif not tf_expr:
+                    # No static tf and no resolvable runtime expression — fall
+                    # back to the chart timeframe so registration still compiles
+                    # (e.g. a request.security inside a dead-code UDF, or one
+                    # whose tf is a function param called with mixed timeframes).
+                    tf_expr = "input_tf_"
                 if tf_expr:
                     la = "true" if info["lookahead_on"] else "false"
                     go = "true" if info.get("gaps_on") else "false"
+                    # Heikin-Ashi same-symbol read: emit the 6th arg only when set
+                    # so every non-HA strategy's generated code stays byte-identical
+                    # (the engine param defaults to false).
+                    ha_arg = ", true" if info.get("heikinashi") else ""
                     sec_id = info["sec_id"]
                     # The runtime registration function is named in tables.py
                     # to keep a single source of truth and to avoid embedding
@@ -369,7 +432,7 @@ class TopLevelEmitter:
                         lines.append(
                             f"        {RUNTIME_REGISTER_SECURITY_EVAL_FN}"
                             f"({sec_id}, {tf_expr}, "
-                            f"input_tf_, {la}, {go});")
+                            f"input_tf_, {la}, {go}{ha_arg});")
             lines.append("    }")
 
     # Map strategy series member name to push expression
@@ -394,6 +457,25 @@ class TopLevelEmitter:
             lines.append(f"        if (is_first_tick_) _s_{field_name}.push({push_expr});")
             lines.append(f"        else _s_{field_name}.update({push_expr});")
 
+        # a1. Push history-referenced scalar bar builtins (time[n], bar_index[n],
+        #     hl2[n], …). They land in ``series_vars`` and are declared as Series
+        #     members (base.py section 6) but — unlike user series vars (pushed at
+        #     their assignment) and bar fields (pushed above) — have no push site,
+        #     so ``[n]`` would read an unfed buffer (the na sentinel) on every bar.
+        #     Push each from its scalar lowering. A builtin whose lowering is a
+        #     self-referential call (e.g. ``time_close`` -> ``time_close()``) is
+        #     skipped — the call would resolve to the shadowing Series member.
+        from .tables import BAR_BUILTINS
+        for _bname in sorted(self.ctx.series_vars):
+            if _bname in self._var_names:
+                continue
+            _bexpr = BAR_BUILTINS.get(_bname)
+            if _bexpr is None or f"{_bname}(" in _bexpr:
+                continue
+            _bsafe = self._safe_name(_bname)
+            lines.append(f"        if (is_first_tick_) {_bsafe}.push({_bexpr});")
+            lines.append(f"        else {_bsafe}.update({_bexpr});")
+
         # a2. Push strategy series
         for svar in sorted(self._strategy_series_vars):
             member = svar.replace("_strat_", "")
@@ -404,6 +486,10 @@ class TopLevelEmitter:
         if self.ctx.var_members:
             lines.append("        if (!_var_initialized) {")
             for name, ptype, init_expr in self.ctx.var_members:
+                # Function-scoped ``var`` members are init'd once-per-variant
+                # on first call (see _emit_func_var_init_block), not here.
+                if name in getattr(self, "_func_local_var_names", ()):
+                    continue
                 safe = self._safe_name(name)
                 if name in self._array_vars:
                     for stmt in self.ctx.ast.body:
@@ -447,6 +533,7 @@ class TopLevelEmitter:
                     continue
                 if name in self.ctx.series_vars:
                     cpp_val = self._resolve_known(init_expr)
+                    cpp_val = self._typed_na_init(cpp_val, name, ptype)
                     lines.append(f"            {safe}.push({cpp_val});")
                     # Also init cloned copies for per-call-site function variants
                     init_emitted: set[str] = set()
@@ -490,7 +577,7 @@ class TopLevelEmitter:
                     func_name_i, namespace_i = self._resolve_callee(stmt.value.callee)
                     is_static_global_input = (
                         stmt.name in self._global_member_vars
-                        and func_name_i != "source"
+                        and not self._is_source_input(stmt.value)
                         and stmt.name not in self._array_vars
                         and stmt.name not in getattr(self, "_matrix_specs", {})
                         and stmt.name not in getattr(self, "_map_vars", {})
@@ -503,6 +590,7 @@ class TopLevelEmitter:
                         default_cpp = self._visit_expr(default) if default is not None else "0"
                         title = self._get_input_title(stmt.value, var_name=stmt.name)
                         getter = self._input_type_to_getter(func_name_i, namespace_i)
+                        default_cpp = self._coerce_string_input_default(getter, default_cpp)
                         cpp_val = f'{getter}("{title}", {default_cpp})'
                         static_vars.append(f"{safe} = {cpp_val};")
 
@@ -667,11 +755,17 @@ class TopLevelEmitter:
         base = fi.node.name if fi.node else ""
         return self._func_safe_name(f"_udt_{udt}_{base}")
 
-    def _emit_func_def(self, fi: FuncInfo, lines: list[str], call_site_idx: int | None = None) -> None:
+    def _emit_func_def(self, fi: FuncInfo, lines: list[str], call_site_idx: int | None = None,
+                       instance: dict | None = None) -> None:
         """Emit a user-defined function as a class method.
 
         If call_site_idx is not None, emit a per-call-site variant with
         TA member names remapped to call-site-specific copies.
+
+        If ``instance`` is provided (a fresh context-sensitive instance minted by
+        ``_build_func_instances``), emit a uniquely-named clone whose TA/var
+        members come from the instance's composed remaps instead of the flat
+        ``_func_cs_*_remap`` tables.
         """
         node = fi.node
         if node is None:
@@ -687,7 +781,12 @@ class TopLevelEmitter:
         func_sv = self.ctx.func_series_vars.get(fi.name, set())
         for i, p in enumerate(node.params):
             if is_udt and i == 0 and fi.udt_type_name:
-                cpp_t = f"{fi.udt_type_name}&"
+                # A method receiver whose type is a drawing primitive
+                # (egoigor's ``method slope(line ln)``) must emit ``Line&`` not
+                # the unknown ``line&``. Register _udt_param_udt so the body's
+                # getters dispatch through the §4.3 drawing path (L.6d / U.5).
+                recv_cpp = DRAWING_TYPE_TO_CPP.get(fi.udt_type_name, fi.udt_type_name)
+                cpp_t = f"{recv_cpp}&"
                 safe_p = self._safe_name(p)
                 self._udt_param_udt[safe_p] = fi.udt_type_name
                 self._udt_param_udt[p] = fi.udt_type_name
@@ -697,6 +796,24 @@ class TopLevelEmitter:
                 # This param uses history access (e.g. src[1]) — pass as Series
                 cpp_t = "const Series<double>&"
                 self._current_func_series_params.add(p)
+            elif i < len(getattr(fi, "param_type_specs", [])) and fi.param_type_specs[i] is not None:
+                # Precise per-param TypeSpec (declared hint or call-site inference):
+                # ``pivot hi`` -> ``pivot&``, ``line ln`` -> ``Line&``, an untyped
+                # ``s`` used as a string -> ``std::string``. UDT / collection
+                # params pass by reference (Pine UDTs/arrays are reference types,
+                # so mutations propagate and member access compiles).
+                spec = fi.param_type_specs[i]
+                cpp_t = self._type_spec_to_cpp(spec)
+                if spec.kind == "udt":
+                    self._udt_param_udt[p] = spec.name
+                    self._udt_param_udt[self._safe_name(p)] = spec.name
+                    cpp_t = f"{cpp_t}&"
+                elif spec.kind in ("array", "map"):
+                    elem = spec.element if spec.kind == "array" else spec.value
+                    if elem is not None and elem.kind == "udt":
+                        self._udt_param_udt[p] = elem.name
+                        self._udt_param_udt[self._safe_name(p)] = elem.name
+                    cpp_t = f"{cpp_t}&"
             elif i < len(fi.param_types):
                 pt = fi.param_types[i]
                 cpp_t = PINE_TYPE_TO_CPP.get(pt, "double")
@@ -715,13 +832,31 @@ class TopLevelEmitter:
             tuple_types_list = self._infer_tuple_types(node, fi.tuple_element_count)
             ret_type = f"std::tuple<{', '.join(tuple_types_list)}>"
         elif getattr(fi, "udt_return_type", None):
-            ret_type = fi.udt_return_type
+            # A function returning a drawing handle must emit the C++ handle
+            # struct (Line/Box/Label/Linefill), not the unknown lowercase name.
+            ret_type = DRAWING_TYPE_TO_CPP.get(fi.udt_return_type, fi.udt_return_type)
+        elif getattr(fi, "return_type_spec", None) is not None:
+            # Array-returning function (``f() => array.from(...)``) — emit the
+            # vector type from the inferred element TypeSpec.
+            ret_type = self._type_spec_to_cpp(fi.return_type_spec)
         else:
             ret_type = PINE_TYPE_TO_CPP.get(fi.return_type, "double")
 
         # For per-call-site variants, suffix the function name and activate TA + var remapping
         func_name = self._emit_udt_method_cpp_name(fi) if is_udt else self._func_safe_name(fi.name)
-        if call_site_idx is not None:
+        var_init_flag: str | None = None
+        if instance is not None:
+            # Fresh context-sensitive instance: name + composed remaps come from
+            # the instance record. No textual cs index (dispatch is via the
+            # instance map), but it IS a state-isolated variant.
+            func_name = instance["name"]
+            self._active_ta_remap = instance["ta_remap"]
+            self._active_var_remap = instance["var_remap"]
+            self._in_ta_func_variant = True
+            self._active_call_site_idx = None
+            self._current_instance_name = instance["name"]
+            var_init_flag = f"_fvinit_{instance['name']}"
+        elif call_site_idx is not None:
             func_name = f"{func_name}_cs{call_site_idx}"
             remap = self._func_cs_ta_remap.get((fi.name, call_site_idx), {})
             self._active_ta_remap = remap
@@ -729,13 +864,27 @@ class TopLevelEmitter:
             self._active_var_remap = var_remap
             self._in_ta_func_variant = True
             self._active_call_site_idx = call_site_idx
+            self._current_instance_name = f"{self._func_safe_name(fi.name)}_cs{call_site_idx}"
         else:
             self._active_ta_remap = {}
             self._active_var_remap = {}
             self._in_ta_func_variant = False
             self._active_call_site_idx = None
+            self._current_instance_name = None
 
         prev_func_locals = self._current_func_locals
+        prev_func_body = getattr(self, "_current_func_body", None)
+        prev_func_name = getattr(self, "_active_func_name", None)
+        # The function body is the lexical scope used by the UDT-alias analysis
+        # (BUG C): a local initialised from a var/global UDT lvalue and later
+        # mutated through must alias, not value-copy.
+        self._current_func_body = node.body
+        self._active_func_name = fi.name
+        # Pointer-aliased UDT locals are function-scoped: a name like ``p_ivot``
+        # may be a rebinding pointer alias in one function and a ``pivot&``
+        # parameter in another, so reset per function to avoid cross-contamination.
+        prev_ptr_alias = self._udt_ptr_alias_locals
+        self._udt_ptr_alias_locals = set()
         self._current_func_locals = {n for n, _, _ in self.ctx.func_var_members.get(fi.name, [])}
         # Plain (non-persistent) scalar locals are emitted inline and live in
         # no other set; collect them so the unknown-identifier guard in
@@ -744,24 +893,47 @@ class TopLevelEmitter:
 
         lines.append(f"    {ret_type} {func_name}({', '.join(param_strs)}) {{")
 
+        # Function-scoped ``var`` one-shot initializer: Pine ``var`` inside a
+        # function is a function-local static — its initializer runs exactly
+        # once, on the first call to THIS variant, with the first bar's values
+        # the function actually sees. Each clone (cs0/cs1/…) is independent.
+        self._emit_func_var_init_block(fi, call_site_idx, lines, flag_override=var_init_flag)
+
         emitted_return = False
         if node.is_single_expr and node.body:
             expr = node.body[0].expr if isinstance(node.body[0], ExprStmt) else None
-            if expr:
+            if expr and self._call_is_void(expr):
+                # void setter as the sole body expr — emit as statement, fall
+                # through to the default return.
+                self._visit_stmt(node.body[0], lines, indent=2)
+            elif expr:
                 lines.append(f"        return {self._visit_expr(expr)};")
                 emitted_return = True
         else:
             for i, s in enumerate(node.body):
                 if i == len(node.body) - 1 and isinstance(s, ExprStmt):
-                    lines.append(f"        return {self._visit_expr(s.expr)};")
-                    emitted_return = True
+                    # A void drawing setter / delete / visual-noop, or a dropped
+                    # table/polyline method call (``panel.cell(...)``), used as
+                    # the last statement cannot be the return value (it lowers to
+                    # a void / no-op C++ call). Emit it as a plain statement
+                    # (which ``_is_skip_expr`` drops) and let the default-return
+                    # path below supply the function's result.
+                    if self._call_is_void(s.expr) or self._is_skip_expr(s.expr):
+                        self._visit_stmt(s, lines, indent=2)
+                    else:
+                        lines.append(f"        return {self._visit_expr(s.expr)};")
+                        emitted_return = True
                 elif i == len(node.body) - 1 and isinstance(s, (SwitchStmt, IfStmt)):
                     # Switch/if as last statement = return expression in PineScript
                     # Emit as: double _ret = 0; if/switch assigns _ret; return _ret;
-                    default_ret = (
-                        f"{ret_type}{{}}" if ret_type in self._udt_defs
-                        else self._default_for_type(ret_type)
-                    )
+                    # A drawing-handle / UDT return type must brace-init its
+                    # default (``Label _func_ret = Label{};``) — falling through
+                    # to ``_default_for_type`` would emit ``0.0`` and clang would
+                    # reject ``Label _func_ret = 0.0;``.
+                    if ret_type in self._udt_defs or ret_type in DRAWING_TYPE_TO_CPP.values():
+                        default_ret = f"{ret_type}{{}}"
+                    else:
+                        default_ret = self._default_for_type(ret_type)
                     lines.append(f"        {ret_type} _func_ret = {default_ret};")
                     self._visit_if_switch_expr(s, "_func_ret", lines, indent=2)
                     lines.append(f"        return _func_ret;")
@@ -776,10 +948,10 @@ class TopLevelEmitter:
                 default_vals = ", ".join(["0.0"] * fi.tuple_element_count)
                 lines.append(f"        return std::make_tuple({default_vals});")
             else:
-                default_ret = (
-                    f"{ret_type}{{}}" if ret_type in self._udt_defs
-                    else self._default_for_type(ret_type)
-                )
+                if ret_type in self._udt_defs or ret_type in DRAWING_TYPE_TO_CPP.values():
+                    default_ret = f"{ret_type}{{}}"
+                else:
+                    default_ret = self._default_for_type(ret_type)
                 lines.append(f"        return {default_ret};")
 
         lines.append("    }")
@@ -787,10 +959,76 @@ class TopLevelEmitter:
         self._current_func_series_params = set()
         self._udt_param_udt = {}
         self._current_func_locals = prev_func_locals
+        self._current_func_body = prev_func_body
+        self._active_func_name = prev_func_name
+        self._udt_ptr_alias_locals = prev_ptr_alias
         self._active_ta_remap = {}
         self._active_var_remap = {}
         self._in_ta_func_variant = False
         self._active_call_site_idx = None
+        self._current_instance_name = None
+
+    def _func_var_init_flag_name(self, fname: str, call_site_idx: int | None) -> str:
+        suffix = f"_cs{call_site_idx}" if call_site_idx is not None else ""
+        return f"_fvinit_{self._func_safe_name(fname)}{suffix}"
+
+    def _emit_func_var_init_block(self, fi: FuncInfo, call_site_idx: int | None,
+                                  lines: list[str], flag_override: str | None = None) -> None:
+        """Emit the one-shot initializer block for a function's ``var`` members.
+
+        Pine ``var`` declared inside a function is a function-local static:
+        the initializer runs exactly once on the FIRST call to this variant
+        (using the first bar's values the function actually sees) and the
+        result persists for the strategy's lifetime. Each per-call-site clone
+        is an independent instance with its own flag and its own set of
+        (remapped) members.
+
+        This closes the gap where a function-scoped ``var line x = line.new(...)``
+        (or any non-compile-time initializer — drawing handles, UDT ctors,
+        arrays, runtime expressions) was declared as a default-constructed
+        class member but its initializer was dropped, leaving the member ``na``
+        / uninitialised and causing "drawing access on na handle" at runtime.
+        """
+        members = self.ctx.func_var_members.get(fi.name)
+        if not members:
+            return
+        flag = flag_override or self._func_var_init_flag_name(fi.name, call_site_idx)
+        # ``_active_var_remap`` is already set for this variant by the caller,
+        # so lowering each init expression here correctly resolves references
+        # to sibling var members (which are themselves remapped for clones).
+        init_lines: list[str] = []
+        for name, ptype, _init_str in members:
+            init_ast = self.ctx.var_member_init_exprs.get(name)
+            safe = self._safe_name(name)
+            target = self._active_var_remap.get(safe, safe)
+            if name in self.ctx.series_vars:
+                if init_ast is None:
+                    continue
+                init_cpp = self._visit_expr(init_ast)
+                init_cpp = self._typed_na_init(init_cpp, name, ptype)
+                init_lines.append(f"        {target}.push({init_cpp});")
+                continue
+            if init_ast is None:
+                # No initializer to lower (e.g. bare ``var box b``); leave the
+                # member at its default-constructed value.
+                continue
+            # Skip a plain ``na`` initializer for drawing handles / UDTs whose
+            # default-constructed member is already the na sentinel; assigning
+            # ``na<double>()`` would not type-match the handle / struct.
+            udt_t = self._udt_var_types.get(name)
+            is_drawing = udt_t in DRAWING_TYPE_TO_CPP if udt_t else False
+            is_udt = udt_t in self._udt_defs if udt_t else False
+            from ..ast_nodes import NaLiteral
+            if (is_drawing or is_udt) and isinstance(init_ast, NaLiteral):
+                continue
+            init_cpp = self._visit_expr(init_ast)
+            init_lines.append(f"        {target} = {init_cpp};")
+        if not init_lines:
+            return
+        lines.append(f"        if (!{flag}) {{")
+        lines.extend(init_lines)
+        lines.append(f"            {flag} = true;")
+        lines.append("        }")
 
     def _emit_precalculate_and_run(self, lines: list[str]) -> None:
         has_static_ta = any(getattr(site, "is_static", False) for site in self.ctx.ta_call_sites)
@@ -832,6 +1070,69 @@ class TopLevelEmitter:
             push_expr_bars = push_expr.replace("current_bar_.", "bars[i].")
             lines.append(f"            _s_{field_name}.push({push_expr_bars});")
 
+        # Advance the native input.source() backing series (_src_open_ etc.)
+        # from bars[i] too. A static TA site's compute args can reference an
+        # input.source()-derived member (e.g. ``ta.stdev(bbSourceInput, 20)``)
+        # which resolves at runtime to ``get_input_source(...)`` reading one
+        # of these series — normally advanced once per real bar by
+        # ``_push_source_series()`` inside ``dispatch_bar()``, which this
+        # standalone precalc loop never calls. Without this, every static TA
+        # site fed by an input.source() reads an empty series (0.0) for the
+        # entire precalculation, silently corrupting its precalculated
+        # values (e.g. a Bollinger Band's stdev collapsing to 0). Gated on
+        # ``_src_series_active_`` to stay a no-op for scripts with no
+        # input.source() usage; cleared again before the real run begins
+        # (BacktestEngine::run() clears every _src_*_ series unconditionally).
+        lines.append("            if (_src_series_active_) {")
+        lines.append("                const double _pc_o = bars[i].open;")
+        lines.append("                const double _pc_h = bars[i].high;")
+        lines.append("                const double _pc_l = bars[i].low;")
+        lines.append("                const double _pc_c = bars[i].close;")
+        lines.append("                const double _pc_v = bars[i].volume;")
+        lines.append("                _src_open_.push(_pc_o);   _src_high_.push(_pc_h);   _src_low_.push(_pc_l);")
+        lines.append("                _src_close_.push(_pc_c);  _src_volume_.push(_pc_v);")
+        lines.append("                _src_hl2_.push((_pc_h + _pc_l) / 2.0);")
+        lines.append("                _src_hlc3_.push((_pc_h + _pc_l + _pc_c) / 3.0);")
+        lines.append("                _src_ohlc4_.push((_pc_o + _pc_h + _pc_l + _pc_c) / 4.0);")
+        lines.append("                _src_hlcc4_.push((_pc_h + _pc_l + _pc_c + _pc_c) / 4.0);")
+        lines.append("            }")
+
+        # Replay every top-level ``X = input.source(...)`` (or bare
+        # ``X = input(close)``) assignment. A static TA site's compute args
+        # often don't reference ``get_input_source(...)`` inline — they
+        # reference the top-level variable the script bound it to (e.g.
+        # ``bbSourceInput = input.source(close, "BB Source")`` then
+        # ``ta.stdev(bbSourceInput, 20)``). That variable is deliberately
+        # NOT covered by the ``_inputs_initialized_`` once-only static-input
+        # block above (see ``is_static_global_input``'s ``_is_source_input``
+        # exclusion) because it tracks a live per-bar series, not a frozen
+        # config value — under normal per-bar dispatch it is reassigned every
+        # real bar. This precalc loop has no other path that reassigns it, so
+        # without this replay every is_static site downstream of it would
+        # keep reading its ctor-initialized 0.0 for the whole precalculation
+        # even with the ``_src_*_`` fix above.
+        for stmt in self.ctx.ast.body:
+            if not isinstance(stmt, VarDecl):
+                continue
+            if stmt.name not in self._global_member_vars:
+                continue
+            if not (isinstance(stmt.value, FuncCall) and self._is_source_input(stmt.value)):
+                continue
+            safe = self._safe_name(stmt.name)
+            default = self._get_input_default(stmt.value)
+            base = self._source_defval_to_base_series(default)
+            title = self._get_input_title(stmt.value, var_name=stmt.name)
+            cpp_val = f'get_input_source("{title}", {base})[0]'
+            # A source var subscripted elsewhere in the script (e.g. ``src[1]``)
+            # is declared ``Series<double>``, not a scalar double, mirroring
+            # the normal per-bar path's ``{safe}.push({cpp_val})`` (see
+            # ``_visit_var_decl``'s ``node.name in self.ctx.series_vars``
+            # branch) — a plain ``=`` there is a compile error.
+            if stmt.name in self.ctx.series_vars:
+                lines.append(f'            {safe}.push({cpp_val});')
+            else:
+                lines.append(f'            {safe} = {cpp_val};')
+
         # Set _precalc_loop_active = True
         self._precalc_loop_active = True
         try:

package/pineforge_codegen/codegen/helpers.py

@@ -33,6 +33,31 @@ CPP_RESERVED = {
 }
 
 
+# Bare C++ identifiers that ``strategy.*`` (and a few other) read-only
+# accessors lower to as zero-arg free-function calls — e.g.
+# ``strategy.grossprofit`` -> ``gross_profit()`` (see codegen/visit_expr.py
+# and codegen/emit_top.py). A user variable emitted with one of these names
+# becomes a class member that shadows the engine accessor, so the codegen
+# would emit ``gross_profit = gross_profit();`` and clang rejects the call
+# ("called object type 'double' is not a function"). Escaping such user
+# identifiers in ``_safe_name`` keeps the two namespaces disjoint; the
+# accessor call strings are emitted verbatim and never routed through
+# ``_safe_name``, so they are unaffected. Keep in sync with the accessor
+# lowerings if new bare-call accessors are added.
+BUILTIN_ACCESSOR_NAMES = {
+    "signed_position_size", "position_entry_name",
+    "count_wintrades", "count_losstrades", "eventrades",
+    "net_profit", "gross_profit", "gross_loss",
+    "grossprofit_percent", "grossloss_percent",
+    "max_contracts_held_all", "max_contracts_held_long",
+    "max_contracts_held_short", "max_drawdown_percent", "max_runup_percent",
+    "avg_trade", "avg_trade_percent", "avg_winning_trade", "avg_losing_trade",
+    "avg_winning_trade_percent", "avg_losing_trade_percent",
+    "margin_liquidation_price", "open_profit", "current_equity",
+    "open_trades_capital_held",
+}
+
+
 class NamingHelper:
     """Identifier escaping, callee resolution, and a generic AST walker.
 
@@ -56,7 +81,7 @@ class NamingHelper:
 
     def _safe_name(self, name: str) -> str:
         """Rename identifiers that collide with C++ reserved words."""
-        if name in CPP_RESERVED:
+        if name in CPP_RESERVED or name in BUILTIN_ACCESSOR_NAMES:
             return f"_{name}_"
         return name
 

package/pineforge_codegen/codegen/input.py

@@ -156,6 +156,27 @@ class InputHelper:
             return "get_input_int"
         return "get_input_double"
 
+    def _is_source_input(self, node: FuncCall) -> bool:
+        """True if an ``input.*`` call yields a *live per-bar source series*.
+
+        Covers both ``input.source(<native series>)`` and a bare
+        ``input(<native series>)`` — in Pine v6 ``input(close)`` is the
+        source-input overload and behaves like ``input.source(close)``,
+        returning a series that tracks ``close`` every bar (not a constant
+        frozen at the first bar). The defval is restricted to the native
+        OHLCV series the engine can resolve at runtime (the same set
+        ``input.source`` is restricted to); a bare ``input(14)`` /
+        ``input(\"x\")`` / ``input(true)`` stays a frozen scalar."""
+        func_name, namespace = self._resolve_callee(node.callee)
+        if namespace == "input" and func_name == "source":
+            return True
+        if func_name == "input" and namespace is None:
+            default = self._get_input_default(node)
+            if (isinstance(default, Identifier)
+                    and default.name in self._NATIVE_SOURCE_SERIES):
+                return True
+        return False
+
     def _source_defval_to_base_series(self, default) -> str:
         """Map an input.source defval (close/high/hl2/…) to its engine base
         source series member (``_src_close_`` …). Falls back to
@@ -175,16 +196,32 @@ class InputHelper:
         series and we read its current value; a subscripted source var is
         already tracked as a series var by the analyzer so ``src[1]`` lowers
         to a Series subscript. Every other input type routes through the
-        scalar getter table."""
-        if namespace == "input" and func_name == "source":
+        scalar getter table. A bare ``input(<native series>)`` is the Pine
+        source-input overload and is rendered identically to
+        ``input.source``."""
+        if self._is_source_input(node):
             default = self._get_input_default(node)
             base = self._source_defval_to_base_series(default)
             return f'get_input_source("{title}", {base})[0]'
         default = self._get_input_default(node)
         default_cpp = self._visit_expr(default) if default is not None else "0"
         getter = self._input_type_to_getter(func_name, namespace)
+        default_cpp = self._coerce_string_input_default(getter, default_cpp)
         return f'{getter}("{title}", {default_cpp})'
 
+    def _coerce_string_input_default(self, getter: str, default_cpp: str) -> str:
+        """String getters take a ``std::string`` default. An unresolved default
+        (e.g. ``input.string(size.tiny, ...)`` where ``size.tiny`` lowers to
+        ``0``) would pass a null char* and crash ``strlen`` inside the getter,
+        so coerce any non-string default to a safe empty string. (Label size is
+        a visual no-op in the backtest, so the exact default does not affect
+        trading logic.)"""
+        if getter == "get_input_string":
+            stripped = default_cpp.strip()
+            if not stripped.startswith("std::string(") and not stripped.startswith('"'):
+                return 'std::string("")'
+        return default_cpp
+
     def _enforce_enum_declared_before_input_enum(self, node: FuncCall) -> None:
         """Mirror the analyzer: ``input.enum(Enum.member)`` requires Enum to be defined above the call.