@pineforge/codegen-pyodide 0.8.0 → 0.9.0

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)
@@ -576,39 +643,64 @@ class Parser:
 
     # -- Function definition --
 
+    def _parse_param_type_annotation(self) -> str | None:
+        """Consume an optional function-parameter type annotation and return it
+        as a canonical hint string ('float', 'string', 'array<line>', 'pivot',
+        'chart.point', ...), or ``None`` for a bare untyped param.
+
+        Leaves the parser positioned at the parameter name. Supports the Pine
+        qualifier prefixes (``series`` / ``simple`` / ``const`` — consumed but
+        not part of the C++ type), builtin types, user-defined / drawing type
+        names, and the ``T[]`` postfix-array shorthand (normalised to
+        ``array<T>`` by ``_parse_type_hint_string``).
+        """
+        TYPE_TOKENS = {TokenType.TYPE_INT, TokenType.TYPE_FLOAT,
+                       TokenType.TYPE_BOOL, TokenType.TYPE_STRING}
+        # Optional qualifiers — they do not affect the C++ param type.
+        while self._check(TokenType.IDENT) and self._current().value in (
+            "series", "simple", "const",
+        ):
+            self._advance()
+        # Is there a type annotation before the parameter name? A builtin type
+        # token always is; an IDENT is a type only if followed by another IDENT
+        # (``line ln``), by ``[`` (``line[] arr``), or by ``<`` (the generic
+        # collection syntax ``array<float> xs`` / ``matrix<float> m`` /
+        # ``map<string,float> mp``). Without the ``<`` case the generic type is
+        # mis-consumed as the parameter name and the whole function definition
+        # silently fails to parse (its body leaks to top-level scope).
+        has_type = False
+        if self._current().type in TYPE_TOKENS:
+            has_type = True
+        elif self._check(TokenType.IDENT):
+            nxt = self._peek().type
+            if nxt in (TokenType.IDENT, TokenType.LBRACKET, TokenType.LT):
+                has_type = True
+        if not has_type:
+            return None
+        return self._parse_type_hint_string()
+
     def _parse_func_def(self) -> FuncDef:
         """Parse: name(param1, param2) => expr_or_block"""
         start_tok = self._current()
         name = self._consume(TokenType.IDENT).value
         self._consume(TokenType.LPAREN)
-        TYPE_TOKENS = {TokenType.TYPE_INT, TokenType.TYPE_FLOAT,
-                       TokenType.TYPE_BOOL, TokenType.TYPE_STRING}
         params = []
+        param_type_hints: list = []
+        param_defaults: list = []
         while not self._check(TokenType.RPAREN):
-            # 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
+            # Consume the optional type annotation (builtin / user / drawing /
+            # ``T[]``), returning the canonical hint string. Handles ``float[] arr``,
+            # ``line[] ln``, ``color c``, ``SDZone z``, ``string tf``, as well as
+            # the untyped bare-name case.
+            hint = self._parse_param_type_annotation()
             param_name = self._consume(TokenType.IDENT).value
-            if self._check(TokenType.IDENT):
-                # '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
+            pdefault = None
             if self._check(TokenType.EQUALS):
                 self._advance()  # consume '='
-                self._parse_expression()  # consume default value (discarded)
+                pdefault = self._parse_expression()  # default value
             params.append(param_name)
+            param_type_hints.append(hint)
+            param_defaults.append(pdefault)
             self._match(TokenType.COMMA)
         self._consume(TokenType.RPAREN)
         self._skip_newlines()
@@ -625,6 +717,13 @@ class Parser:
             expr = self._parse_expression()
             node = FuncDef(name=name, params=params, body=[ExprStmt(expr=expr)], is_single_expr=True)
 
+        # Record per-param type hints + defaults (mirrors _parse_method_def) so
+        # the analyzer can type UDT/string/array params and the codegen can emit
+        # them with the correct C++ type (``pivot hi``, ``std::string s``).
+        node.annotations = {
+            "param_type_hints": param_type_hints,
+            "param_defaults": param_defaults,
+        }
         return self._set_loc(node, start_tok)
 
     def _parse_type_or_enum_decl(self):
@@ -701,7 +800,8 @@ class Parser:
             if self._current().type in TYPE_KEYWORDS:
                 param_type = self._parse_type_hint_string()
             elif (self._current().type == TokenType.IDENT
-                  and self._peek().type == TokenType.IDENT):
+                  and self._peek().type in (TokenType.IDENT, TokenType.LBRACKET, TokenType.LT)):
+                # ``line ln`` / ``float[] arr`` / ``array<float> xs`` typed param.
                 param_type = self._parse_type_hint_string()
             p = self._consume(TokenType.IDENT).value
             pdefault = None

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)],