pineforge-codegen 0.7.5__py3-none-any.whl → 0.8.0__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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()

pineforge_codegen/parser.py

@@ -197,6 +197,13 @@ class Parser:
             # Check that the IDENT is followed by = (not == ) to confirm declaration
             if self._peek(2).type == TokenType.EQUALS:
                 return self._parse_typed_decl()
+        # Postfix-array type-annotated declaration: float[] x = ..., int[] x = ...
+        if (cur.type in TYPE_KEYWORDS
+                and self._peek().type == TokenType.LBRACKET
+                and self._peek(2).type == TokenType.RBRACKET
+                and self._peek(3).type == TokenType.IDENT
+                and self._peek(4).type == TokenType.EQUALS):
+            return self._parse_typed_decl()
 
         # IDENT-prefixed type-annotated declaration: ``Sample s = ...``,
         # ``array<Sample> arr = ...``, ``matrix<float> m = ...`` — when the
@@ -393,35 +400,42 @@ class Parser:
         return self._set_loc(node, start_tok)
 
     def _parse_type_hint_string(self) -> str:
-        """Parse primitive, UDT, array<T>, or map<K,V> type hints."""
+        """Parse primitive, UDT, array<T>, map<K,V>, or postfix-array (``T[]``) hints."""
         base = self._advance().value
-        if not self._check(TokenType.LT):
-            return base
-
-        parts: list[str] = []
-        depth = 0
-        self._advance()  # <
-        while not self._at_end():
-            tok = self._current()
-            if tok.type == TokenType.LT:
-                depth += 1
-                parts.append("<")
-                self._advance()
-                continue
-            if tok.type == TokenType.GT:
-                if depth == 0:
+        if self._check(TokenType.LT):
+            parts: list[str] = []
+            depth = 0
+            self._advance()  # <
+            while not self._at_end():
+                tok = self._current()
+                if tok.type == TokenType.LT:
+                    depth += 1
+                    parts.append("<")
                     self._advance()
-                    break
-                depth -= 1
-                parts.append(">")
+                    continue
+                if tok.type == TokenType.GT:
+                    if depth == 0:
+                        self._advance()
+                        break
+                    depth -= 1
+                    parts.append(">")
+                    self._advance()
+                    continue
+                if tok.type == TokenType.COMMA:
+                    parts.append(",")
+                else:
+                    parts.append(str(tok.value))
                 self._advance()
-                continue
-            if tok.type == TokenType.COMMA:
-                parts.append(",")
-            else:
-                parts.append(str(tok.value))
-            self._advance()
-        return f"{base}<{''.join(parts)}>"
+            base = f"{base}<{''.join(parts)}>"
+
+        # Pine postfix-array shorthand: `float[]` == `array<float>`, `T[]` == `array<T>`.
+        # Without this the trailing `[ ]` is left unconsumed, the following name
+        # fails to parse, and the whole declaration is silently dropped.
+        while self._check(TokenType.LBRACKET) and self._peek().type == TokenType.RBRACKET:
+            self._advance()  # [
+            self._advance()  # ]
+            base = f"array<{base}>"
+        return base
 
     def _parse_template_args(self) -> list[str]:
         """Parse and return generic args after a member name, e.g. new<K,V>()."""
@@ -487,6 +501,16 @@ class Parser:
               and self._current().value not in ("na",)):
             # Complex type: array<float>, table, etc.
             type_hint = self._parse_type_hint_string()
+        elif (self._current().type == TokenType.IDENT
+              and self._peek().type == TokenType.LBRACKET
+              and self._peek(2).type == TokenType.RBRACKET):
+            # Postfix-array of a non-primitive / UDT element type, e.g.
+            # ``var line[] lines = ...`` or ``var store[] xs = ...``. The
+            # empty ``[]`` can only form a type here (a subscript index would
+            # be non-empty), so this is unambiguously ``array<T>``. Without
+            # this branch the ``[]`` is left unconsumed, the name fails to
+            # parse, and the whole declaration is silently dropped.
+            type_hint = self._parse_type_hint_string()
 
         name_tok = self._consume(TokenType.IDENT)
         self._consume(TokenType.EQUALS)
@@ -561,24 +585,24 @@ class Parser:
                        TokenType.TYPE_BOOL, TokenType.TYPE_STRING}
         params = []
         while not self._check(TokenType.RPAREN):
-            # Pine: series float x / series int x — one parameter (not "series" + "x")
-            if self._check(TokenType.IDENT) and self._current().value == "series":
-                self._advance()  # consume 'series'
-                if self._current().type in TYPE_TOKENS:
-                    self._advance()  # float, int, ...
-                param_name = self._consume(TokenType.IDENT).value
-                if self._check(TokenType.EQUALS):
-                    self._advance()
-                    self._parse_expression()
-                params.append(param_name)
-                self._match(TokenType.COMMA)
-                continue
-            # Handle optional type annotation: type param (e.g., int len, float src)
+            # Consume optional Pine parameter type qualifiers, e.g. `series float x`,
+            # `simple string maType`, `const int n`. Each is one qualifier in front
+            # of the (optional) type and the name — NOT a separate parameter.
+            while self._check(TokenType.IDENT) and self._current().value in (
+                "series",
+                "simple",
+                "const",
+            ):
+                self._advance()
+            # Handle optional type annotation: type param (e.g., int len, float src,
+            # string s). Built-in types are dedicated tokens; user-defined types are
+            # IDENTs and handled by the "next is IDENT" check below.
             if self._current().type in TYPE_TOKENS:
                 self._advance()  # skip the type annotation
             param_name = self._consume(TokenType.IDENT).value
             if self._check(TokenType.IDENT):
-                # 'param_name' was actually a type name parsed as IDENT, next is real name
+                # 'param_name' was actually a (user-defined) type name parsed as IDENT,
+                # next is the real name.
                 param_name = self._consume(TokenType.IDENT).value
             # Skip default value: param = expr
             if self._check(TokenType.EQUALS):

pineforge_codegen/support_checker.py

@@ -80,6 +80,10 @@ SUPPORTED_MATRIX: frozenset[str] = frozenset(set(MATRIX_METHODS) | {"new"})
 SUPPORTED_SYMINFO: frozenset[str] = frozenset(SYMINFO_MEMBER_MAP)
 SUPPORTED_COLOR_CONST: frozenset[str] = frozenset(COLOR_CONST_MAP)
 SUPPORTED_COLOR_FUNC: frozenset[str] = frozenset({"new", "rgb", "r", "g", "b", "t"})
+# Cosmetic color builders with no backtest-logic effect. Warned (not rejected);
+# codegen emits a benign default color (0 = na color). color.from_gradient is a
+# charting/plot helper that only tints visual output.
+COSMETIC_COLOR_FUNC: frozenset[str] = frozenset({"from_gradient"})
 SUPPORTED_TIMEFRAME_FUNC: frozenset[str] = frozenset({"change", "in_seconds"})
 SUPPORTED_RUNTIME_FUNC: frozenset[str] = frozenset({"error"})
 # log.* helpers wired into pine_log_{info,warning,error} by codegen/visit_call.
@@ -96,7 +100,6 @@ HARD_REJECT_FUNC: dict[str, str] = {
     "request.seed":              "External seed data feeds not available in PineForge.",
     "request.quandl":            "External Quandl data not available in PineForge.",
     "request.currency_rate":     "Currency conversion data not available in PineForge.",
-    "color.from_gradient":       "Charting helpers not available in PineForge backtests.",
     # ticker.* chart-type modifiers and cross-symbol constructors — hard reject
     "ticker.heikinashi":         (
         "ticker.heikinashi() chart-type modifier / cross-symbol construction not supported — "
@@ -215,10 +218,17 @@ NOT_YET_FUNC: dict[str, str] = {
 }
 
 # Bare (no-namespace) function names that codegen has no handler for.
-# Without a handler, the generic emitter at visit_call.py:912 would
-# produce e.g. `color(arg)` — an undeclared C++ symbol. Reject loudly.
-UNSUPPORTED_BARE_FUNCS: dict[str, str] = {
-    "color": "Bare color(...) cast is not supported. Use color.new(c, alpha) or color.rgb(r, g, b, transp).",
+# Without a handler, the generic emitter at visit_call.py:912 would produce an
+# undeclared C++ symbol. Reject loudly. (Currently empty — the bare color(...)
+# cast moved to COSMETIC_BARE_FUNCS below.)
+UNSUPPORTED_BARE_FUNCS: dict[str, str] = {}
+
+# Bare (no-namespace) cosmetic casts with no backtest-logic effect. Warned
+# (not rejected); codegen emits a benign default. ``color(x)`` is a Pine color
+# cast — colors never affect trade logic, so codegen emits a default color
+# (0 = na color) and the strategy keeps running.
+COSMETIC_BARE_FUNCS: dict[str, str] = {
+    "color": "color(...) cast has no effect in PineForge backtests (visual only); it emits a default color.",
 }
 
 # Whole namespaces with NO codegen support. Any call into one of these
@@ -230,14 +240,19 @@ UNSUPPORTED_NAMESPACES: dict[str, str] = {
     "volume_row": "volume_row.* is not supported in PineForge batch backtests; same reason as footprint.*.",
 }
 
-# Member-access references with no batch-mode equivalent. Codegen would
-# silently emit "false" (visit_expr.py chart.* fallthrough) which
-# becomes epoch 0 in time arithmetic. Reject loudly.
-UNSUPPORTED_MEMBERS: dict[tuple[str, str], str] = {
-    ("chart", "left_visible_bar_time"):  "chart.left_visible_bar_time has no meaning in a batch backtest (no viewport).",
-    ("chart", "right_visible_bar_time"): "chart.right_visible_bar_time has no meaning in a batch backtest (no viewport).",
-    ("chart", "bg_color"): "chart.bg_color has no meaning in a batch backtest (no chart theme).",
-    ("chart", "fg_color"): "chart.fg_color has no meaning in a batch backtest (no chart theme).",
+# Member-access references with no batch-mode equivalent. Reject loudly.
+# (Currently empty — the chart.* cosmetic reads moved to COSMETIC_MEMBERS.)
+UNSUPPORTED_MEMBERS: dict[tuple[str, str], str] = {}
+
+# Cosmetic / chart-only member reads with no backtest-logic effect. Warned
+# (not rejected); codegen emits the benign default — chart.* falls through
+# SKIP_NAMESPACES in visit_expr.py to ``0`` (and the analyzer types chart.* as
+# COLOR, so the 0 lands in an int color slot and compiles cleanly).
+COSMETIC_MEMBERS: dict[tuple[str, str], str] = {
+    ("chart", "left_visible_bar_time"):  "chart.left_visible_bar_time has no meaning in a batch backtest (no viewport); emits 0.",
+    ("chart", "right_visible_bar_time"): "chart.right_visible_bar_time has no meaning in a batch backtest (no viewport); emits 0.",
+    ("chart", "bg_color"): "chart.bg_color has no meaning in a batch backtest (no chart theme); emits a default color.",
+    ("chart", "fg_color"): "chart.fg_color has no meaning in a batch backtest (no chart theme); emits a default color.",
 }
 
 # Constant-only namespaces whose members are drawing/visual style constants
@@ -692,9 +707,15 @@ class SupportChecker:
             self._visit_children(node)
             return
 
-        # Bare-function rejections (e.g. `color(arg)` cast). Codegen would
-        # otherwise fall through to the generic emit at visit_call.py:912 and
-        # produce an undeclared C++ symbol.
+        # Bare cosmetic casts (e.g. `color(na)` -> default color). No backtest
+        # effect; warn and let codegen emit a benign default color.
+        if ns is None and name in COSMETIC_BARE_FUNCS:
+            self._warn(node, COSMETIC_BARE_FUNCS[name])
+            self._visit_children(node)
+            return
+
+        # Bare-function rejections. Codegen would otherwise fall through to the
+        # generic emit at visit_call.py:912 and produce an undeclared C++ symbol.
         if ns is None and self._reject_if_in(
             UNSUPPORTED_BARE_FUNCS,
             name,
@@ -865,6 +886,16 @@ class SupportChecker:
             self._err(node, f"timeframe.{name}(...) is not implemented in PineForge runtime.")
             self._visit_children(node)
             return
+        if ns == "color" and name in COSMETIC_COLOR_FUNC:
+            # Cosmetic color builder (e.g. color.from_gradient): no backtest
+            # effect. Warn and let codegen emit a default color (0).
+            self._warn(
+                node,
+                f"color.{name}(...) has no effect in PineForge backtests "
+                f"(visual only); it emits a default color.",
+            )
+            self._visit_children(node)
+            return
         if ns == "color" and name not in SUPPORTED_COLOR_FUNC:
             self._err(node, f"color.{name}(...) is not implemented in PineForge runtime.")
             self._visit_children(node)
@@ -1001,7 +1032,21 @@ class SupportChecker:
             lambda k, v: f"{k}.{node.member}: {v}",
         ):
             return
-        # Specific unsupported (namespace, member) pairs (e.g. chart.left_visible_bar_time).
+        # Cosmetic / chart-only member reads (chart.fg_color/bg_color/visible
+        # bar times). No backtest-logic effect; warn and let codegen emit the
+        # benign default (chart.* -> 0 via SKIP_NAMESPACES in visit_expr.py).
+        if (
+            isinstance(node.object, Identifier)
+            and (node.object.name, node.member) in COSMETIC_MEMBERS
+        ):
+            self._warn(
+                node,
+                f"{node.object.name}.{node.member}: "
+                f"{COSMETIC_MEMBERS[(node.object.name, node.member)]}",
+            )
+            self._visit_children(node)
+            return
+        # Specific unsupported (namespace, member) pairs.
         if isinstance(node.object, Identifier) and self._reject_if_in(
             UNSUPPORTED_MEMBERS,
             (node.object.name, node.member),
@@ -1134,10 +1179,25 @@ class SupportChecker:
                 hint="Codegen only recognizes the barmerge.lookahead_* literal; other values are silently treated as lookahead_off.",
             )
         if self._is_barmerge_member(lookahead_node, "lookahead_on"):
-            self._err(
+            # lookahead_on is supported by codegen + engine: base.py forwards
+            # the flag into _security_eval_info, emit_top.py registers it via
+            # register_security_eval(..., lookahead_on=true), and the engine
+            # (engine_security.cpp) dispatches the partial HTF eval and gates
+            # the per-bucket series slot on it. The completed-HTF value becomes
+            # visible from the HTF bucket's first chart bar (TV's forward-look).
+            # We emit a WARNING (not ERROR) because lookahead_on is inherently
+            # data-sensitive: with a 0-offset HTF expression it exposes the
+            # in-progress bucket's value (TV's documented repaint), whereas the
+            # safe non-repainting idiom pairs it with a [1] offset
+            # (e.g. close[1]) to read only completed prior buckets.
+            self._warn(
                 lookahead_node,
-                "request.security lookahead_on is not supported in PineForge paid parity mode.",
-                hint="Use barmerge.lookahead_off. lookahead_on can expose future/partial HTF values and is highly data-sensitive.",
+                "request.security lookahead_on changes HTF timing: the completed "
+                "higher-timeframe value is exposed from the bucket's first chart "
+                "bar. PineForge emits this (engine-supported) but results differ "
+                "from lookahead_off and, with a 0-offset HTF expression, repaint "
+                "future data.",
+                hint="The safe non-repainting form pairs lookahead_on with a [1] offset (e.g. close[1]) to read only completed prior HTF bars.",
             )
 
         # Data-adjustment kwargs: codegen emits a numeric constant but the

{pineforge_codegen-0.7.5.dist-info → pineforge_codegen-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pineforge-codegen
-Version: 0.7.5
+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.7.5.dist-info → pineforge_codegen-0.8.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 pineforge_codegen/__init__.py,sha256=O8-sYnIHi1Kwo9h6khfDrKrGXZ85TQJlJfvkkgCo4QU,4158
 pineforge_codegen/ast_nodes.py,sha256=a5wW_wJ8QPy35guqJOVXU6D89kdTVrTNcd-lw0-dTaM,7680
 pineforge_codegen/errors.py,sha256=U6oUuK9GyEDBpSriXzhWyKMuTG-hyk4mND6gVjnxu6A,2931
-pineforge_codegen/lexer.py,sha256=afxd3MED6Utqi97HtkGbcoh1WMG0AsMs9-ZP3H9Pq_Q,18593
-pineforge_codegen/parser.py,sha256=xmpiTGNcGrdPvbWOucIkdjBUTT6Oea-6u_Nq4khEp9E,47730
+pineforge_codegen/lexer.py,sha256=4CLxGfBkv2W8EduCOv2e_y1tdqSW1oCqxoQ2lnURLhk,21774
+pineforge_codegen/parser.py,sha256=m2l1da_R_CifdcsMImDyxvKzY_rk_qsj6UVsoRnYWcA,49351
 pineforge_codegen/pragmas.py,sha256=xzXqecJk5nhOFxha3fWA-dq8lNJ69v4w85vZx71zyF4,4550
 pineforge_codegen/signatures.py,sha256=FGwOPjrEgw8a5hOEx3zWFdor6aMb0iJDBIXIa7VDgSA,31139
-pineforge_codegen/support_checker.py,sha256=YtHWvbtZ6INRIAn3aUzI9HQGq64YsbmhjjsvZX1ALO8,59681
+pineforge_codegen/support_checker.py,sha256=TKvkRuQKllhA2cdc2UWW18FUZSid7H7BK0nxidY56k0,63076
 pineforge_codegen/symbols.py,sha256=ixjkvOfkZrhlteQQhSAlOafcdTcSaTshe-rsfUPOK1A,3660
 pineforge_codegen/tokens.py,sha256=SODOOSXKiTW0GMOz41D_IykuAVsUbbSFYS11pqON2rY,12882
 pineforge_codegen/tv_input_choices.py,sha256=4t5q-49hwWquoOMVMbx_WgvFzsZ2Xll24imI7Evsk8I,2508
@@ -17,19 +17,19 @@ pineforge_codegen/analyzer/diagnostics.py,sha256=XQihiH2vQYcPQ83NwTKU6RAuakRXkuh
 pineforge_codegen/analyzer/tables.py,sha256=KiI3gvYGWBw9PgX_PPXPS-fk8dfH54OjMCMGeb3tD0Y,7442
 pineforge_codegen/analyzer/types.py,sha256=HAbEAnxkZxX7d5iFQA6KT0Ocs7kkUprX78z9DMcHVlc,12181
 pineforge_codegen/codegen/__init__.py,sha256=jvwwf93pqyHnFSvGPcD8Mhr_kAk0Uc4W6IqhKu8UIlI,2232
-pineforge_codegen/codegen/base.py,sha256=p9Tkh7VTLSTl34i-pyIYOm6PmmonAYOtRgfLKFXHnQo,74019
-pineforge_codegen/codegen/emit_top.py,sha256=dyuLuPh8SoZcxiC3wwa7wVikPMOBY0bFDCq8L2VvoNI,46638
-pineforge_codegen/codegen/helpers.py,sha256=TIsTUjrri4DobEJ9Cr-rl9s6LILWuKWolROUu1-f4mw,7313
+pineforge_codegen/codegen/base.py,sha256=byvd8tReKtaKmJjhL9P9BwJqhXFoCBugYpzkhAUJUaw,75186
+pineforge_codegen/codegen/emit_top.py,sha256=OLmnhcO69ei4-n8BDewxKXLEYm1pVldc0Lmi811vvYY,49090
+pineforge_codegen/codegen/helpers.py,sha256=gtm205xciMW326EQyxLy1mjeQ_5ZNP_t8hWE9zmE_0I,8723
 pineforge_codegen/codegen/helpers_syminfo.py,sha256=GFrx9i2HXSCmGIpIds0cFrtJ6IQiznfXxH8aI8h3DQ4,4878
-pineforge_codegen/codegen/input.py,sha256=z-qkYIUrmlU5EW1siUiXdbs7r6eY6-FfLXuKB5F-E1g,15587
-pineforge_codegen/codegen/security.py,sha256=dsmWLtH3GMRmHeRCpMUk2WDn_8WCDeU76L-tOFGdzcE,67565
-pineforge_codegen/codegen/ta.py,sha256=ticEy6RLk8B2Qos9-eXUpirpZd07Pt0N9UyYNrke_mY,12983
-pineforge_codegen/codegen/tables.py,sha256=p3BD7ln8EhmtayVBCufOKOSCmgDB10ut42E18_yI7vw,36289
-pineforge_codegen/codegen/types.py,sha256=kt2tXtFhFmm4cWBuXnvPHfop-AWIB7drUiKNaDblQxs,29770
-pineforge_codegen/codegen/visit_call.py,sha256=V21US4tHVYg5pHcD5y8Jc9yxghiBcw907TqUtNlE91Y,74801
-pineforge_codegen/codegen/visit_expr.py,sha256=kXrwIRouG4uo-e0lze23Kat3p5LFSfldgML088s4G_U,36762
-pineforge_codegen/codegen/visit_stmt.py,sha256=Vgtx_j_xYjH-qntnUlZiyYXIX9oioijN8vmBLrneYcA,38125
-pineforge_codegen-0.7.5.dist-info/METADATA,sha256=_I6Xwm4bYMuH8WNQUk60as8KufIyRK4Ok8F_3ZurcuE,17599
-pineforge_codegen-0.7.5.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-pineforge_codegen-0.7.5.dist-info/licenses/LICENSE,sha256=Hf1kZ8OCaQ-nd2i92f2WEX1ZKCc6jqe-rtR4fVENQHY,7186
-pineforge_codegen-0.7.5.dist-info/RECORD,,
+pineforge_codegen/codegen/input.py,sha256=5NNzkZWMt7yTvT0_68Hm8okkbrtP2w8TFQ_iRI2VVOc,16822
+pineforge_codegen/codegen/security.py,sha256=sN8pHHmqgosggYysY9pwZfBH7QRrHsojMyIE22eejlw,69115
+pineforge_codegen/codegen/ta.py,sha256=tXRATmRzqbXtH0PU9ZpTM-cmKlH6RhQ1_xBU6NlAQ54,13062
+pineforge_codegen/codegen/tables.py,sha256=iTNtwEkHhZI2keGUS89rVySE4LuvkBHcfYTG-QG8U0Y,36297
+pineforge_codegen/codegen/types.py,sha256=m87uBmJ8zVOt3v6qBjhV7yfXuTTyuCu-gXkhTl8Koco,30603
+pineforge_codegen/codegen/visit_call.py,sha256=8JWkMbxhaavqGmXpIO7B9D33wc-ePh3GpPq1YrIASnE,75592
+pineforge_codegen/codegen/visit_expr.py,sha256=AxcESavP6WWSTbI1STdCOSha_BoLyR3MuJv8aqHOIA8,38901
+pineforge_codegen/codegen/visit_stmt.py,sha256=xnpXJEBpf24FBi5Ey2I_SgIzSjHe84nbP1SYIYzoMl4,39268
+pineforge_codegen-0.8.0.dist-info/METADATA,sha256=YLX1nKMm5Ea18Qcb1c4XDAzxh9Q0iPSd7vYEUSTbRSc,17599
+pineforge_codegen-0.8.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pineforge_codegen-0.8.0.dist-info/licenses/LICENSE,sha256=Hf1kZ8OCaQ-nd2i92f2WEX1ZKCc6jqe-rtR4fVENQHY,7186
+pineforge_codegen-0.8.0.dist-info/RECORD,,