pineforge-codegen 0.7.6__tar.gz → 0.8.0__tar.gz

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pineforge-codegen
-Version: 0.7.6
+Version: 0.8.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.8.0/VERSION

@@ -0,0 +1 @@
+0.8.0

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/pineforge_codegen/codegen/base.py

@@ -902,8 +902,15 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 else:
                     default = self._default_for_spec(spec)
                 lines.append(f"    {cpp_type} {f.name} = {default};")
+            # NA sentinel (always the last data member). A default-constructed
+            # UDT - ``var T x = na``, an array fill slot, ``T.copy()`` no-arg -
+            # is na; the ``T.new(...)`` lowering sets this false. This lets
+            # ``na(udtVar)`` lower to the ``is_na(const T&)`` overload below
+            # instead of failing because no ``is_na`` accepts a struct.
+            lines.append(f"    bool __pf_na = true;")
             lines.append(f"    static {type_name} create() {{ return {type_name}{{}}; }}")
             lines.append("};")
+            lines.append(f"inline bool is_na(const {type_name}& _z) {{ return _z.__pf_na; }}")
             lines.append("")
 
         # 1c. Enum constants + string tables for str.tostring(enumVar)
@@ -1048,13 +1055,22 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
                 self._map_vars.add(name)
                 lines.append(f"    {self._type_spec_to_cpp(self._map_spec_for_name(name))} {safe};")
                 continue
-            # Detect UDT vars: init_str like "TypeName.new(...)"
+            # Detect UDT vars. Two signals: (1) the analyzer recorded an
+            # explicit UDT type annotation in ``_udt_var_types`` - this is the
+            # ONLY signal when the initializer is ``na`` (``var SDZone z = na``),
+            # where the inferred ``ptype`` is NA->double; (2) the init_str is a
+            # ``TypeName.new(...)`` constructor. Without (1) the member would
+            # decl as ``double`` and the later ``z = SDZone{...}`` would not
+            # compile (assigning SDZone to double).
             init_s = str(init_str)
-            udt_type = None
-            for udt_name in self._udt_defs:
-                if init_s.startswith(f"{udt_name}.new"):
-                    udt_type = udt_name
-                    break
+            udt_type = self._udt_var_types.get(name)
+            if udt_type not in self._udt_defs:
+                udt_type = None
+            if udt_type is None:
+                for udt_name in self._udt_defs:
+                    if init_s.startswith(f"{udt_name}.new"):
+                        udt_type = udt_name
+                        break
             if udt_type:
                 lines.append(f"    {udt_type} {safe};")
                 continue
@@ -1258,7 +1274,7 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if isinstance(val, (int, float)):
                 return str(val)
             if isinstance(val, str):
-                return f'std::string("{val}")'
+                return f'std::string("{self._cpp_string_escape(val)}")'
         # Also resolve bar field references
         if arg_str in BAR_FIELDS:
             return BAR_FIELDS[arg_str]

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/pineforge_codegen/codegen/emit_top.py

@@ -182,11 +182,27 @@ 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
@@ -224,8 +240,14 @@ class TopLevelEmitter:
             safe = self._safe_name(name)
             if name in self._array_vars or name in self._map_vars:
                 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
             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
@@ -394,6 +416,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_", "")
@@ -447,6 +488,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 +532,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", {})

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/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
 

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/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,8 +196,10 @@ 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]'

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/pineforge_codegen/codegen/security.py

@@ -1232,6 +1232,37 @@ class SecurityEmitter:
 
             self._emit_security_rebinds(sec_id, info, lines, ta_results, indent=2, emitted_lines=lines)
             emit_security_ta(post_rebind_ta_indices)
+            returns_tuple = item.get("returns_tuple", False)
+            tuple_size = item.get("tuple_size", 0)
+            if (
+                returns_tuple
+                and tuple_size
+                and tuple_size > 0
+                and isinstance(expr_node, TupleLiteral)
+            ):
+                # A tuple body destructures into per-element scalar members
+                # ``_req_sec_{sec_id}_{i}`` (declared in ``base.py`` and reset in
+                # ``clear_security``). Assign each element individually rather
+                # than building the whole ``TupleLiteral`` (which lowers to an
+                # ``std::make_tuple(...)`` against the non-existent aggregate
+                # member ``_req_sec_{sec_id}``).
+                for i, el in enumerate(expr_node.elements):
+                    el_cpp = self._build_security_expr(
+                        sec_id,
+                        el,
+                        None,
+                        ta_results,
+                        security_mutable_names=security_mutable_names,
+                        emitted_lines=lines,
+                    )
+                    lines.append(f"        _req_sec_{sec_id}_{i} = {el_cpp};")
+                for field in sorted(self._security_ohlc_hist_fields_by_sec.get(sec_id, ())):
+                    lines.append(
+                        f"        {self._security_ohlc_hist_series_cpp(sec_id, field)}.push(bar.{field});"
+                    )
+                lines.append("    }")
+                lines.append("")
+                continue
             expr_cpp = self._build_security_expr(
                 sec_id,
                 expr_node,

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/pineforge_codegen/codegen/ta.py

@@ -295,4 +295,7 @@ class TaSiteHelper:
             return True
         except ValueError:
             pass
-        return val in ("true", "false", "0", "0.0", "na<double>()")
+        return val in (
+            "true", "false", "0", "0.0",
+            "na<double>()", "na<int>()", "na<int64_t>()", "na<bool>()",
+        )

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/pineforge_codegen/codegen/tables.py

@@ -382,14 +382,14 @@ ORDER_DIRECTION_MAP = {
 
 # Methods called as ``array.method(arr, ...)`` or ``arr.method(...)``.
 ARRAY_METHODS = {
-    "get":       lambda a, args: f"{a}[{args[0]}]",
-    "set":       lambda a, args: f"{a}[{args[0]}] = {args[1]}",
+    "get":       lambda a, args: f"{a}[({args[0]})]",
+    "set":       lambda a, args: f"{a}[({args[0]})] = {args[1]}",
     "push":      lambda a, args: f"{a}.push_back({args[0]})",
     "unshift":   lambda a, args: f"{a}.insert({a}.begin(), {args[0]})",
     "insert":    lambda a, args: f"{a}.insert({a}.begin() + (int)({args[0]}), {args[1]})",
     "pop":       lambda a, args: f"[&](){{ auto v={a}.back(); {a}.pop_back(); return v; }}()",
     "shift":     lambda a, args: f"[&](){{ auto v={a}.front(); {a}.erase({a}.begin()); return v; }}()",
-    "remove":    lambda a, args: f"[&](){{ auto v={a}[{args[0]}]; {a}.erase({a}.begin()+(int)({args[0]})); return v; }}()",
+    "remove":    lambda a, args: f"[&](){{ auto v={a}[({args[0]})]; {a}.erase({a}.begin()+(int)({args[0]})); return v; }}()",
     "first":     lambda a, args: f"{a}.front()",
     "last":      lambda a, args: f"{a}.back()",
     "size":      lambda a, args: f"(double){a}.size()",
@@ -435,7 +435,7 @@ ARRAY_METHODS = {
     "mode":      lambda a, args: f"[&](){{ std::unordered_map<double,int> m; for(auto v:{a})m[v]++; double best=0; int bc=0; for(auto&[v,c]:m)if(c>bc||(c==bc&&v<best)){{bc=c;best=v;}} return best; }}()",
     "percentile_linear_interpolation": lambda a, args: f"[&](){{ auto c={a}; std::sort(c.begin(),c.end()); double k=({args[0]}/100.0)*c.size()-0.5; int i=std::max(0,(int)k); double f=k-i; if(i+1>=(int)c.size()) return c.back(); return c[i]*(1-f)+c[i+1]*f; }}()",
     "percentile_nearest_rank": lambda a, args: f"[&](){{ auto c={a}; std::sort(c.begin(),c.end()); int r=(int)std::ceil(({args[0]}/100.0)*c.size()); return c[std::min(r-1,(int)c.size()-1)]; }}()",
-    "percentrank": lambda a, args: f"[&](){{ if({a}.size()<=1) return na<double>(); double v={a}[{args[0]}]; if(std::isnan(v)) return na<double>(); int le=0; for(auto x:{a}) if(!std::isnan(x) && x<=v) le++; return (double)(le-1)/({a}.size()-1)*100.0; }}()",
+    "percentrank": lambda a, args: f"[&](){{ if({a}.size()<=1) return na<double>(); double v={a}[({args[0]})]; if(std::isnan(v)) return na<double>(); int le=0; for(auto x:{a}) if(!std::isnan(x) && x<=v) le++; return (double)(le-1)/({a}.size()-1)*100.0; }}()",
     "abs":       lambda a, args: f"[&](){{ std::vector<double> r; for(auto v:{a})r.push_back(std::abs(v)); return r; }}()",
     "join":      lambda a, args: "[&](){{ std::string r; for(size_t i=0;i<{arr}.size();i++){{ if(i>0)r+={sep}; r+=std::to_string({arr}[i]); }} return r; }}()".format(arr=a, sep=args[0] if args else 'std::string(",")'),
     "standardize": lambda a, args: f"[&](){{ double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); s=std::sqrt(s/{a}.size()); std::vector<double> r; for(auto v:{a})r.push_back(s==0?1.0:(v-m)/s); return r; }}()",

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/pineforge_codegen/codegen/types.py

@@ -357,7 +357,12 @@ class TypeInferer:
 
     def _series_type_for(self, name: str) -> str:
         """C++ element type for a series variable's history buffer."""
-        if self._is_int64_builtin_init(name):
+        from .tables import INT64_BUILTINS
+        # A bare int64 bar builtin used as a history series (``time[1]``) needs an
+        # int64_t buffer: epoch-ms overflow int32 and the na sentinel would be
+        # misdetected. ``_is_int64_builtin_init`` only matches user vars whose
+        # init RHS is such a builtin, so also match the builtin name directly.
+        if name in INT64_BUILTINS or self._is_int64_builtin_init(name):
             return "int64_t"
         sym = self.ctx.symbols.resolve(name)
         if sym is not None:
@@ -473,8 +478,15 @@ class TypeInferer:
                     return "std::string"
                 if func_name == "bool":
                     return "bool"
-                if func_name in ("int", "color", "time"):
+                if func_name == "int":
                     return "int"
+                # ``input.time`` returns an epoch-MS timestamp and ``input.color``
+                # a packed ARGB int — both use the ``get_input_int64`` getter
+                # (input.py), so their storage must be ``int64_t`` or the value
+                # truncates under int32 (e.g. a date-window bound flips sign and
+                # the guard is permanently false).
+                if func_name in ("color", "time"):
+                    return "int64_t"
                 return "double"
             if namespace == "str":
                 if func_name == "split":

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/pineforge_codegen/codegen/visit_call.py

@@ -439,6 +439,13 @@ class CallVisitor:
         if namespace == "color":
             return self._visit_color_call(func_name, node)
 
+        # Bare color(...) cast (cosmetic). The engine has no color-cast helper
+        # and colors have no backtest-logic effect, so emit a benign default
+        # color (0 = na color, matching the color.new / from_gradient
+        # fallbacks). The support checker warns on this construct.
+        if namespace is None and func_name == "color" and func_name not in self._func_names:
+            return "0"
+
         # Skip visual/unsupported namespace calls
         if namespace in SKIP_NAMESPACES or namespace in SKIP_VAR_TYPES:
             return "0"
@@ -913,6 +920,11 @@ class CallVisitor:
                     if f_cpp_type == "int" and "na<double>" in val:
                         val = val.replace("na<double>()", "0")
                     field_inits.append(f".{f.name} = {val}")
+            # Mark the constructed object non-na (the struct's ``__pf_na`` is the
+            # last declared field, so this designator stays in declaration order).
+            # A bare default-constructed UDT keeps ``__pf_na = true`` (na); only a
+            # real ``.new(...)`` flips it false so ``na(obj)`` reports correctly.
+            field_inits.append(".__pf_na = false")
             return f"{namespace}{{{', '.join(field_inits)}}}"
 
         # UDT copy: TypeName.copy(obj)

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/pineforge_codegen/codegen/visit_expr.py

@@ -180,7 +180,7 @@ class ExprVisitor:
         if isinstance(node, NumberLiteral):
             return str(node.value)
         if isinstance(node, StringLiteral):
-            return f'std::string("{node.value}")'
+            return f'std::string("{self._cpp_string_escape(node.value)}")'
         if isinstance(node, BoolLiteral):
             return "true" if node.value else "false"
         if isinstance(node, NaLiteral):
@@ -475,8 +475,17 @@ class ExprVisitor:
                 if node.member in ("is_heikinashi", "is_kagi", "is_linebreak",
                                    "is_pnf", "is_range", "is_renko"):
                     return "false"
-                # Defensive: support_checker.UNSUPPORTED_MEMBERS should already have
-                # rejected any unhandled chart.* member. Reaching here is a bug.
+                # Cosmetic / chart-only reads with no batch-mode value (theme
+                # colors, viewport bar times). The support checker warns on
+                # these (COSMETIC_MEMBERS); emit a benign default (0 = na color /
+                # epoch 0). They have no backtest-logic effect.
+                if node.member in ("fg_color", "bg_color",
+                                   "left_visible_bar_time",
+                                   "right_visible_bar_time"):
+                    return "0"
+                # Defensive: support_checker (COSMETIC_MEMBERS / UNSUPPORTED_MEMBERS)
+                # should already have warned/rejected any unhandled chart.* member.
+                # Reaching here is a bug.
                 raise ValueError(
                     f"codegen: unhandled chart.{node.member} — analyzer should have rejected. "
                     f"Add a handler above or extend UNSUPPORTED_MEMBERS."
@@ -717,6 +726,31 @@ class ExprVisitor:
                     if series_name not in self._strategy_series_vars:
                         self._strategy_series_vars.add(series_name)
                     return f"{series_name}[{idx}]"
+        # History reference applied directly to an inline call result, e.g.
+        # ``ta.highest(high, 10)[1]`` or ``f()[2]``. In Pine the call yields a
+        # series, so ``[k]`` reads its value k bars ago — but the call lowers to
+        # a freshly-computed C++ scalar, and ``scalar[k]`` is not subscriptable.
+        # Materialize the result into a self-contained history buffer: a static
+        # ``Series<T>`` that pushes (new bar) / updates (intrabar) the value
+        # exactly once per evaluation — same semantics as every other series in
+        # the strategy — and read ``[k]`` off it. The inner call is emitted once
+        # so its own stateful indicator is not double-stepped, and the buffer
+        # clears itself on run-start (``is_first_tick_ && bar_index_ == 0``) so a
+        # reused strategy handle (parameter sweep) does not leak prior-run history.
+        if isinstance(node.object, FuncCall):
+            inner = self._visit_expr(node.object)
+            cpp_t = self._infer_type(node.object)
+            if cpp_t not in ("double", "int", "bool"):
+                cpp_t = "double"
+            return (
+                f"([&]() -> {cpp_t} {{ "
+                f"static thread_local Series<{cpp_t}> _hist_call; "
+                f"if (is_first_tick_ && bar_index_ == 0) _hist_call.clear(); "
+                f"{cpp_t} _hv = ({inner}); "
+                f"if (is_first_tick_) _hist_call.push(_hv); "
+                f"else _hist_call.update(_hv); "
+                f"return _hist_call[(int)({idx})]; }}())"
+            )
         obj = self._visit_expr(node.object)
         # If subscripting a non-series variable (e.g., function parameter),
         # src[0] → src (current value), src[N>0] → src (can't access history)

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/pineforge_codegen/codegen/visit_stmt.py

@@ -100,7 +100,6 @@ from ..ast_nodes import (
 )
 from ..symbols import TypeSpec
 from .tables import (
-    SKIP_VAR_TYPES,
     TA_RETURNS_BOOL,
     TA_TUPLE_FIELDS,
     MATRIX_RETURNING_METHODS,
@@ -259,7 +258,7 @@ class StmtVisitor:
         if is_global_member and isinstance(node.value, FuncCall) and self._is_input_call(node.value):
             func_name_i, namespace_i = self._resolve_callee(node.value.callee)
             is_static_global_input = (
-                func_name_i != "source"
+                not self._is_source_input(node.value)
                 and node.name not in self._array_vars
                 and node.name not in getattr(self, "_matrix_specs", {})
                 and node.name not in getattr(self, "_map_vars", {})
@@ -356,16 +355,19 @@ class StmtVisitor:
                     lines.append(f"{pad}{cpp_type} {safe};")
                 return
 
-        # Skip visual function assignments — but still emit declaration for
-        # table function results since the var may be used later
+        # Visual/drawing function assignments (line.new, label.new, box.new,
+        # table.new, ...) are no-ops in a backtest, but the assigned variable may
+        # still be referenced later (e.g. pushed into an array<line>, or used as a
+        # handle by sibling set_* calls). Emit a default-valued local declaration
+        # so those references compile; the value is inert. Global members are
+        # already declared at class scope, so only locals need this. (Previously
+        # only `table` results were declared, which dropped loop-local line/label
+        # handles and produced "use of undeclared identifier".)
         if isinstance(node.value, FuncCall) and self._is_skip_expr(node.value):
-            func_name, namespace = self._resolve_callee(node.value.callee)
-            if namespace in SKIP_VAR_TYPES:
-                # Emit var with default value so references don't fail
-                if not is_global_member:
-                    cpp_type = self._type_for_decl(node)
-                    default = "0" if cpp_type in ("int", "double") else ('std::string("")' if cpp_type == "std::string" else "false")
-                    lines.append(f"{pad}{cpp_type} {safe} = {default};")
+            if not is_global_member:
+                cpp_type = self._type_for_decl(node)
+                default = "0" if cpp_type in ("int", "double") else ('std::string("")' if cpp_type == "std::string" else "false")
+                lines.append(f"{pad}{cpp_type} {safe} = {default};")
             return
 
         # TA call
@@ -542,7 +544,20 @@ class StmtVisitor:
                 if name == "_":
                     continue
                 if i < len(fields):
-                    lines.append(f"{pad}double {name} = {result_var}.{fields[i]};")
+                    field_expr = f"{result_var}.{fields[i]}"
+                    # A history-referenced destructured name (e.g.
+                    # ``[v, dir] = ta.supertrend(...)`` with ``dir[1]`` used
+                    # later) is tracked in ``series_vars`` and declared as a
+                    # ``Series<T>`` class member. Pushing into that member keeps
+                    # its history buffer advancing so ``dir[n]`` resolves; a
+                    # fresh ``double`` local would shadow the member and make
+                    # ``dir[n]`` a scalar subscript (clang error). Non-series
+                    # destructured names keep the plain scalar declaration.
+                    if name in self.ctx.series_vars:
+                        safe = self._safe_name(name)
+                        lines.append(f"{pad}{safe}.push({field_expr});")
+                    else:
+                        lines.append(f"{pad}double {name} = {field_expr};")
             return
 
         # User-defined function returning a tuple: use C++17 structured bindings

{pineforge_codegen-0.7.6 → pineforge_codegen-0.8.0}/pineforge_codegen/lexer.py

@@ -273,9 +273,16 @@ class Lexer:
                 self._read_token()
             if not self._at_end() and self.source[self.pos] == "\n":
                 self._advance()
-            # If parens closed on this line, emit NEWLINE so parser sees end of statement
+            # If parens closed on this line, end the statement UNLESS the line
+            # ends with a continuation token (e.g. trailing operator), in which
+            # case the next line continues the same logical line.
             if self.paren_depth == 0 and emitted_in_parens:
-                self._emit(TokenType.NEWLINE, "\\n", self.line - 1, self.col)
+                last_token = self.tokens[-1] if self.tokens else None
+                if last_token and last_token.type in self.CONTINUATION_TOKENS:
+                    self._in_continuation = True
+                else:
+                    self._in_continuation = False
+                    self._emit(TokenType.NEWLINE, "\\n", self.line - 1, self.col)
             return
 
         # Indentation handling
@@ -290,9 +297,24 @@ class Lexer:
         else:
             indent_level = len(raw) // 4
 
+        # Operator-first line continuation: when a line *begins* with a binary
+        # / ternary operator that cannot start a statement (e.g. ``? x``,
+        # ``: y``, ``+ z``, ``and w``), it continues the previous logical line
+        # even though that line did not *end* with an operator (the break was
+        # placed before the operator instead of after it). Suppress this line's
+        # INDENT/DEDENT and drop the NEWLINE that ended the prior line so the
+        # parser sees one contiguous expression. Only applies outside parens
+        # and when not already in an end-of-line continuation.
+        starts_with_cont_op = (
+            not self._in_continuation
+            and self._line_starts_with_continuation_op()
+        )
+        if starts_with_cont_op and self.tokens and self.tokens[-1].type == TokenType.NEWLINE:
+            self.tokens.pop()
+
         # If we're in a continuation (previous line ended with an operator),
         # suppress INDENT/DEDENT — the indentation is cosmetic, not structural
-        if not self._in_continuation:
+        if not self._in_continuation and not starts_with_cont_op:
             current_indent = self.indent_stack[-1]
             if indent_level > current_indent:
                 self.indent_stack.append(indent_level)
@@ -329,6 +351,49 @@ class Lexer:
         else:
             self._in_continuation = False
 
+    def _line_starts_with_continuation_op(self) -> bool:
+        """True when the upcoming line content begins with a binary/ternary
+        operator that can never begin a statement, so the line is a
+        continuation of the previous logical line.
+
+        Called with ``self.pos`` positioned at the first non-whitespace
+        character of the line. Deliberately conservative: ``-`` is excluded
+        (ambiguous leading unary minus) and ``.`` is excluded (``.5`` is a
+        leading-dot number, not member access). The included operators
+        (``? : + * / % == != > < >= <= and or``) cannot legally start a Pine
+        statement, so suppressing the line break for them never merges two
+        independent statements that previously parsed."""
+        src = self.source
+        p = self.pos
+        n = len(src)
+        if p >= n:
+            return False
+        c = src[p]
+        c2 = src[p + 1] if p + 1 < n else ""
+        # Two-character comparison operators.
+        if c2 == "=" and c in ("=", "!", ">", "<"):
+            return True
+        # ':' ternary-else continuation, but not ':=' (reassignment).
+        if c == ":" and c2 != "=":
+            return True
+        # Single-character operators that cannot start a statement.
+        if c in "?+*%><":
+            return True
+        # '/' division continuation, but never '//' (comment).
+        if c == "/" and c2 != "/":
+            return True
+        # 'and' / 'or' keyword continuation (require a word boundary so names
+        # like ``android`` / ``organic`` are not misread).
+        def _kw(word: str) -> bool:
+            end = p + len(word)
+            if src[p:end] != word:
+                return False
+            nxt = src[end] if end < n else ""
+            return not (nxt.isalnum() or nxt == "_")
+        if _kw("and") or _kw("or"):
+            return True
+        return False
+
     def _advance_to(self, target: int) -> None:
         while self.pos < target and self.pos < len(self.source):
             self._advance()