@pineforge/codegen-pyodide 0.8.1 → 0.9.0

package/pineforge_codegen/codegen/visit_stmt.py

@@ -258,6 +258,10 @@ class StmtVisitor:
         # Global-scope non-var vars are class members — emit assignment, not declaration
         is_global_member = node.name in self._global_member_vars
 
+        def remember_local_type(cpp_type: str | None) -> None:
+            if cpp_type and not is_global_member:
+                self._current_func_local_types[node.name] = cpp_type
+
         # Check if it is a static (non-series) global member variable already evaluated inside _inputs_initialized_ block
         is_static_global_input = False
         if is_global_member and isinstance(node.value, FuncCall) and self._is_input_call(node.value):
@@ -284,7 +288,7 @@ class StmtVisitor:
             title = self._get_input_title(node.value, var_name=node.name)
             cpp_val = self._render_input_value(node.value, func_name_i, namespace_i, title)
             if node.name in self.ctx.series_vars:
-                lines.append(f"{pad}{safe}.push({cpp_val});")
+                self._emit_history_series_write(lines, pad, safe, cpp_val)
             elif is_global_member:
                 lines.append(f"{pad}{safe} = {cpp_val};")
             else:
@@ -381,9 +385,12 @@ class StmtVisitor:
             compute_args = self._ta_compute_args_for_site(site)
             ret_type = "bool" if self._ta_name_from_site(site) in TA_RETURNS_BOOL else "double"
             ta_name = self._ta_member_name(site)
-            ta_expr = f"(is_first_tick_ ? {ta_name}.compute({compute_args}) : {ta_name}.recompute({compute_args}))"
+            ta_expr = (
+                f"(history_advances_new_bar() ? {ta_name}.compute({compute_args}) "
+                f": {ta_name}.recompute({compute_args}))"
+            )
             if node.name in self.ctx.series_vars:
-                lines.append(f"{pad}{safe}.push({ta_expr});")
+                self._emit_history_series_write(lines, pad, safe, ta_expr)
             elif is_global_member:
                 lines.append(f"{pad}{safe} = {ta_expr};")
             else:
@@ -393,7 +400,7 @@ class StmtVisitor:
         # Non-var series variable — push instead of declare
         if node.name in self.ctx.series_vars:
             cpp_val = self._visit_expr(node.value)
-            lines.append(f"{pad}{safe}.push({cpp_val});")
+            self._emit_history_series_write(lines, pad, safe, cpp_val)
             return
 
         # If/switch expression: x = if cond ... else ...
@@ -451,12 +458,29 @@ class StmtVisitor:
                 lines.append(f"{pad}{cpp_type}& {safe} = {cpp_val};")
                 return
 
+        # Global-scope UDT array-element alias (BUG: Pine array elements of a
+        # user-defined type are references). A global loop-local bound from
+        # ``arr.get(i)`` and later field-mutated must ALIAS the element so the
+        # mutation writes back into the array. Emit a fresh per-iteration
+        # ``UDT& z = arr[i];`` reference (any hoisted class member was
+        # suppressed) — identical to the non-hoisted function-local alias path.
+        # Gated by _register_udt_array_get_ref_locals (which only records global-
+        # scope names); the ``_current_func_body is None`` guard confines this to
+        # global scope, so a function-local sharing the name keeps its own path.
+        if (node.name in self._udt_array_get_ref_locals
+                and getattr(self, "_current_func_body", None) is None):
+            udt_t = self._udt_var_types.get(node.name)
+            cpp_val = self._visit_rhs_value(node.value, node.name, target_cpp_type=udt_t)
+            lines.append(f"{pad}{udt_t}& {safe} = {cpp_val};")
+            return
+
         # General declaration
         cpp_type = self._type_for_decl(node) if not is_global_member else None
         cpp_val = self._visit_rhs_value(node.value, node.name, target_cpp_type=cpp_type)
         if is_global_member:
             lines.append(f"{pad}{safe} = {cpp_val};")
         else:
+            remember_local_type(cpp_type)
             lines.append(f"{pad}{cpp_type} {safe} = {cpp_val};")
 
     @staticmethod
@@ -591,7 +615,11 @@ class StmtVisitor:
             compute_args = self._ta_compute_args_for_site(site)
             ta_mem = self._ta_member_name(site)
             result_var = f"_result_{ta_mem}"
-            lines.append(f"{pad}auto {result_var} = (is_first_tick_ ? {ta_mem}.compute({compute_args}) : {ta_mem}.recompute({compute_args}));")
+            lines.append(
+                f"{pad}auto {result_var} = (history_advances_new_bar() ? "
+                f"{ta_mem}.compute({compute_args}) : "
+                f"{ta_mem}.recompute({compute_args}));"
+            )
 
             ta_name = self._ta_name_from_site(site)
             fields = TA_TUPLE_FIELDS.get(ta_name, [f"field{i}" for i in range(len(node.names))])
@@ -611,7 +639,9 @@ class StmtVisitor:
                     # 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});")
+                        self._emit_history_series_write(
+                            lines, pad, safe, field_expr
+                        )
                     else:
                         lines.append(f"{pad}double {name} = {field_expr};")
             return
@@ -716,40 +746,37 @@ class StmtVisitor:
         pad = "    " * indent
         start = self._visit_expr(node.start)
         end = self._visit_expr(node.end)
-        var = node.var  # new AST uses .var instead of .var_name
-        if node.step is not None:
-            # Explicit `by` step: unchanged from before — ascending compare
-            # (matches every existing corpus use, all positive literal steps).
-            step = self._visit_expr(node.step)
-            lines.append(f"{pad}for (int {var} = {start}; {var} <= {end}; {var} += {step}) {{")
-        else:
-            # No `by` clause: Pine v6 auto-infers the loop direction from
-            # start/end — descending (step -1) when start > end, else
-            # ascending (step +1); see the Pine v6 `for` reference. start/end
-            # are arbitrary runtime expressions (``for i = array.size(arr)-1
-            # to 0`` — a common "iterate backward to safely remove an element
-            # while iterating" idiom), so the direction can't always be
-            # resolved at codegen time. Compute start/end into locals ONCE
-            # (avoids re-evaluating a side-effecting expression, same class
-            # of bug as nz()'s double-eval) and pick the comparison direction
-            # at runtime from their relative order — this previously always
-            # emitted an ascending `<=` loop, which never executes when
-            # start > end (silently dropping the whole loop body).
-            fid = self._for_counter
-            self._for_counter += 1
-            s_var, e_var = f"_for_start_{fid}", f"_for_end_{fid}"
-            lines.append(f"{pad}int {s_var} = ({start}), {e_var} = ({end});")
-            lines.append(
-                f"{pad}for (int {var} = {s_var}; "
-                f"({s_var} <= {e_var}) ? ({var} <= {e_var}) : ({var} >= {e_var}); "
-                f"{var} += ({s_var} <= {e_var}) ? 1 : -1) {{"
-            )
+        step = self._visit_expr(node.step) if node.step is not None else "1"
+        var = self._safe_name(node.var)  # new AST uses .var instead of .var_name
+
+        # Pine infers loop direction from the initial ``from``/``to`` values for
+        # both implicit and explicit ``by`` loops. The ``by`` value is a positive
+        # magnitude; descending loops subtract it. ``to`` can change during the
+        # loop, so refresh the cached end expression after each iteration while
+        # keeping the initial direction and step fixed.
+        fid = self._for_counter
+        self._for_counter += 1
+        s_var = f"_for_start_{fid}"
+        e_var = f"_for_end_{fid}"
+        step_var = f"_for_step_{fid}"
+        down_var = f"_for_down_{fid}"
+        lines.append(f"{pad}int {s_var} = ({start});")
+        lines.append(f"{pad}int {e_var} = ({end});")
+        lines.append(f"{pad}int {step_var} = ({step});")
+        lines.append(f"{pad}if ({step_var} < 0) {step_var} = -{step_var};")
+        lines.append(f"{pad}if ({step_var} == 0) {step_var} = 1;")
+        lines.append(f"{pad}const bool {down_var} = ({s_var} > {e_var});")
+        lines.append(
+            f"{pad}for (int {var} = {s_var}; "
+            f"({down_var} ? ({var} >= {e_var}) : ({var} <= {e_var})); "
+            f"{var} += ({down_var} ? -{step_var} : {step_var}), {e_var} = ({end})) {{"
+        )
         # Register the loop counter so reads of it inside the body resolve (the
         # unknown-identifier guard in _visit_ident would otherwise flag it).
         saved_loop = self._current_loop_vars
         self._current_loop_vars = set(self._current_loop_vars)
-        if var:
-            self._current_loop_vars.add(var)
+        if node.var:
+            self._current_loop_vars.add(node.var)
         _blk_saved = self._push_block_var_remap(node)
         try:
             for s in node.body:
@@ -787,9 +814,19 @@ class StmtVisitor:
         pad = "    " * indent
         iterable = self._visit_expr(node.iterable)
         saved_loop = self._current_loop_vars
+        saved_loop_specs = self._current_loop_var_specs
         self._current_loop_vars = set(self._current_loop_vars)
+        self._current_loop_var_specs = dict(self._current_loop_var_specs)
+        iterable_spec = self._type_spec_from_expr(node.iterable)
+        elem_spec = (
+            iterable_spec.element
+            if iterable_spec is not None and iterable_spec.kind == "array"
+            else None
+        )
         if node.var:
             self._current_loop_vars.add(node.var)
+            if elem_spec is not None:
+                self._current_loop_var_specs[node.var] = elem_spec
         if node.vars:
             for v in node.vars:
                 if v != "_":
@@ -809,6 +846,7 @@ class StmtVisitor:
             self._pop_block_var_remap(_blk_saved)
         lines.append(f"{pad}}}")
         self._current_loop_vars = saved_loop
+        self._current_loop_var_specs = saved_loop_specs
 
     def _visit_while(self, node: WhileStmt, lines: list[str], indent: int) -> None:
         pad = "    " * indent

package/pineforge_codegen/parser.py

@@ -166,6 +166,28 @@ class Parser:
     # ------------------------------------------------------------------
 
     def _parse_statement(self):
+        stmt = self._parse_single_statement()
+        if not self._check(TokenType.COMMA):
+            return stmt
+
+        stmts: list = []
+        self._extend_statement_list(stmts, stmt)
+        while self._match(TokenType.COMMA):
+            if self._check(TokenType.NEWLINE) or self._check(TokenType.DEDENT) or self._at_end():
+                break
+            self._extend_statement_list(stmts, self._parse_single_statement())
+        return stmts
+
+    @staticmethod
+    def _extend_statement_list(stmts: list, stmt) -> None:
+        if stmt is None:
+            return
+        if isinstance(stmt, list):
+            stmts.extend(stmt)
+        else:
+            stmts.append(stmt)
+
+    def _parse_single_statement(self):
         cur = self._current()
 
         # Control flow keywords
@@ -192,6 +214,33 @@ class Parser:
         if cur.type in (TokenType.VAR, TokenType.VARIP):
             return self._parse_var_keyword_decl()
 
+        # Type-qualifier prefix on a top-level declaration. Pine v6 allows
+        # ``const`` / ``simple`` / ``series`` to qualify a typed variable
+        # declaration (``const int DEFAULT = 1``). The qualifier carries no
+        # C++-side meaning (the engine infers mutability from ``var``/
+        # ``varip``), so consume it and parse the underlying declaration.
+        # Without this the qualifier is parsed as a bare identifier and the
+        # subsequent typed decl leaks the stray ``ExprStmt(const)`` that
+        # produces "Unknown variable 'const'" at codegen.
+        if (cur.type == TokenType.IDENT
+                and cur.value in ("const", "series", "simple")):
+            nxt = self._peek()
+            # ``const int NAME = ...`` / ``const float[] x = ...``
+            typed_after_qual = (
+                nxt.type in TYPE_KEYWORDS
+                or (nxt.type == TokenType.IDENT and self._is_ident_typed_var_decl(offset=1))
+            )
+            # ``const NAME = ...`` (qualifier on an untyped decl — rare but
+            # legal; ``const`` here is just dropped).
+            bare_after_qual = (
+                nxt.type == TokenType.IDENT
+                and self._peek(2).type == TokenType.EQUALS
+                and self._peek(3).type != TokenType.EQUALS
+            )
+            if typed_after_qual or bare_after_qual:
+                self._advance()  # consume the qualifier prefix
+                return self._parse_single_statement()
+
         # Type-annotated declaration: float x = ..., int x = ...
         if cur.type in TYPE_KEYWORDS and self._peek().type == TokenType.IDENT:
             # Check that the IDENT is followed by = (not == ) to confirm declaration
@@ -273,7 +322,7 @@ class Parser:
 
         return self._set_loc(ExprStmt(expr=expr), start_tok)
 
-    def _is_ident_typed_var_decl(self) -> bool:
+    def _is_ident_typed_var_decl(self, offset: int = 0) -> bool:
         """Look ahead for ``IDENT [<...>] IDENT '='`` (UDT-typed declaration).
 
         Triggered by ``Sample s = expr`` / ``array<Sample> w = expr`` /
@@ -283,15 +332,21 @@ class Parser:
         ``true``, ``false``), and function-definition shapes
         (``IDENT '(' ... ')' '=>'``).
 
+        ``offset`` shifts the starting position (used to look ahead past a
+        consumed type-qualifier prefix like ``const``).
+
         Probe: data/validation/udt-method-probe-19-array-of-udt-method.
         """
-        cur = self._current()
+        base = self.pos + offset
+        if base >= len(self.tokens):
+            return False
+        cur = self.tokens[base]
         if cur.type != TokenType.IDENT:
             return False
         if cur.value in ("enum", "type", "strategy", "indicator", "na", "true", "false"):
             return False
         # Skip past optional generic args after the type ident: IDENT [< ... >]
-        i = self.pos + 1
+        i = base + 1
         if i < len(self.tokens) and self.tokens[i].type == TokenType.LT:
             depth = 1
             i += 1
@@ -374,12 +429,24 @@ class Parser:
         first = VarDecl(name=name_tok.value, value=value)
         self._set_loc(first, start_tok)
 
-        # Check for comma-separated additional declarations: x=1, y=2, z=3
-        if not self._check(TokenType.COMMA):
+        # Check for comma-separated additional declarations: x=1, y=2, z=3.
+        # Other comma-separated simple statements (``a := 1, b := 2`` or
+        # ``array.fill(a, na), array.set(a, 0, 1)``) are handled by the
+        # statement wrapper above, so do not greedily consume their comma.
+        if not (
+            self._check(TokenType.COMMA)
+            and self._peek().type == TokenType.IDENT
+            and self._peek(2).type == TokenType.EQUALS
+        ):
             return first
 
         decls = [first]
-        while self._match(TokenType.COMMA):
+        while (
+            self._check(TokenType.COMMA)
+            and self._peek().type == TokenType.IDENT
+            and self._peek(2).type == TokenType.EQUALS
+        ):
+            self._advance()
             st = self._current()
             n = self._consume(TokenType.IDENT)
             self._consume(TokenType.EQUALS)

package/pineforge_codegen/signatures.py

@@ -133,8 +133,8 @@ _ta("kcw",     _sig([("source", F), ("length", I), ("mult", F, 1.5)]))
 # --- Volatility & Range ---
 _ta("atr",     _sig([("length", I)]))
 _ta("tr",      _sig([("handle_na", B, False)]))
-_ta("stdev",   _sig([("source", F), ("length", I)]))
-_ta("variance",_sig([("source", F), ("length", I)]))
+_ta("stdev",   _sig([("source", F), ("length", I), ("biased", B, True)]))
+_ta("variance",_sig([("source", F), ("length", I), ("biased", B, True)]))
 
 # --- Trend ---
 _ta("supertrend", _sig([("factor", F), ("atrPeriod", I)],

package/pineforge_codegen/support_checker.py

@@ -342,10 +342,14 @@ UNSUPPORTED_NAMESPACE_VARS: dict[str, str] = {
 # request.security parameter rules.
 # Codegen supports symbol/timeframe/expression plus gaps/lookahead (read in
 # _eval_security_* emission and forwarded to register_security_eval).
-# ignore_invalid_symbol/currency are accepted by the parser but silently
-# dropped by codegen — reject loudly to surface unsupported behavior.
+# `currency` is still rejected loudly (it changes the returned values via FX
+# conversion, which codegen drops — silently wrong). `ignore_invalid_symbol` is
+# a guaranteed no-op here: codegen forces request.security onto the current
+# chart symbol (see the "symbol must reference current chart symbol" check),
+# which is always valid, so the flag can never change the result — accept+ignore.
 SECURITY_ALLOWED_PARAMS: frozenset[str] = frozenset(
     {"symbol", "timeframe", "expression", "gaps", "lookahead",
+     "ignore_invalid_symbol",
      # Data-adjustment constants — silently accepted and ignored by codegen;
      # the underlying engine uses a fixed unadjusted data source.
      "backadjustment", "settlement_as_close", "adjustment"}
@@ -462,6 +466,12 @@ class SupportChecker:
         # (``panel.cell(...)``) is a visual sink whose args may carry visual
         # constants, so it routes through ``_visit_children_const_ok``.
         self._visual_container_vars: set[str] = set()
+        # User helpers whose body is only a visual sink (for example
+        # ``cell(table t, ..., align) => t.cell(..., text_halign=align)``).
+        # A call to such a helper is itself a visual context, so style
+        # constants passed through its arguments are safe and should not trip
+        # the free-expression constant-namespace rejection.
+        self._visual_sink_funcs: set[str] = set()
         self._drawing_tuple_vars: set[str] = set()
         self._func_tuple_drawing_returns: dict[str, list[bool]] = {}
         # Track whether we are inside an if/ternary condition expression.
@@ -520,6 +530,8 @@ class SupportChecker:
                 if tuple_returns:
                     self._func_tuple_drawing_returns[stmt.name] = tuple_returns
                 self._collect_visual_container_params(stmt)
+                if self._func_body_is_visual_sink(stmt):
+                    self._visual_sink_funcs.add(stmt.name)
             elif isinstance(stmt, MethodDef):
                 self._user_methods.add(stmt.name)
                 self._collect_visual_container_params(stmt)
@@ -535,6 +547,27 @@ class SupportChecker:
             if hint and str(hint).replace(" ", "") in _VISUAL_CONTAINER_TYPES:
                 self._visual_container_vars.add(pname)
 
+    def _expr_is_visual_sink_call(self, expr: ASTNode | None) -> bool:
+        if not isinstance(expr, FuncCall):
+            return False
+        ns, name = _qualified_name(expr.callee)
+        if ns is None and name in SKIP_FUNC_NAMES:
+            return True
+        if ns is not None and ns in SKIP_NAMESPACES:
+            return True
+        if ns in _DRAWING_NOOP_BY_NS and name in _DRAWING_NOOP_BY_NS[ns]:
+            return True
+        return ns is not None and ns in self._visual_container_vars
+
+    def _func_body_is_visual_sink(self, fn: FuncDef | MethodDef) -> bool:
+        if not fn.body:
+            return False
+        for stmt in fn.body:
+            expr = stmt.expr if isinstance(stmt, ExprStmt) else None
+            if not self._expr_is_visual_sink_call(expr):
+                return False
+        return True
+
     @staticmethod
     def _type_name_contains_drawing(type_name: str | None) -> bool:
         if not type_name:
@@ -1207,6 +1240,10 @@ class SupportChecker:
             self._visit_children_const_ok(node)
             return
 
+        if ns is None and name in self._visual_sink_funcs:
+            self._visit_children_const_ok(node)
+            return
+
         self._visit_children(node)
 
     def _visit_Identifier(self, node: Identifier) -> None:

package/release.json

@@ -1,7 +1,7 @@
 {
-  "codegen": "0.8.1",
+  "codegen": "0.9.0",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "85ac44383967dd8c9825a276661eab568b16ecb89fcb929a3b9b638b6a4f371c"
+  "sha256": "fc828c2a32ba93bbeeffa8e0a4c4696a417a6cc64448c1b70bdce2267cd051d9"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "0.8.1",
+  "CODEGEN_VERSION": "0.9.0",
   "TA_CLASS_MAP_KEYS": [
     "sma",
     "ema",
@@ -577,11 +577,13 @@
     ],
     "ta.stdev": [
       "source",
-      "length"
+      "length",
+      "biased"
     ],
     "ta.variance": [
       "source",
-      "length"
+      "length",
+      "biased"
     ],
     "ta.supertrend": [
       "factor",
@@ -1574,6 +1576,7 @@
     "backadjustment",
     "expression",
     "gaps",
+    "ignore_invalid_symbol",
     "lookahead",
     "settlement_as_close",
     "symbol",