@pineforge/codegen-pyodide 0.7.6 → 0.8.1

package/pineforge_codegen/codegen/visit_stmt.py

@@ -100,12 +100,16 @@ from ..ast_nodes import (
 )
 from ..symbols import TypeSpec
 from .tables import (
-    SKIP_VAR_TYPES,
+    ARRAY_NEW_CTORS,
     TA_RETURNS_BOOL,
     TA_TUPLE_FIELDS,
     MATRIX_RETURNING_METHODS,
 )
 
+# Sentinel for "no block-scoped var remap was activated" so an empty dict
+# saved-remap is still distinguishable from the no-op case.
+_NO_BLOCK_REMAP = object()
+
 
 class StmtVisitor:
     """Statement-level visitor methods shared across the codegen.
@@ -259,7 +263,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", {})
@@ -292,7 +296,7 @@ class StmtVisitor:
         # array.new_float() etc., plus array-returning copy/slice.
         if isinstance(node.value, FuncCall):
             func_name, namespace = self._resolve_callee(node.value.callee)
-            if namespace == "array" and func_name in ("new", "new_float", "new_int", "new_bool", "new_string", "from", "copy", "slice"):
+            if namespace == "array" and func_name in ARRAY_NEW_CTORS | {"new", "from", "copy", "slice"}:
                 self._array_vars.add(node.name)
                 spec = self._type_spec_from_expr(node.value) or self._array_spec_for_name(node.name)
                 self._collection_types.setdefault(node.name, spec)
@@ -356,16 +360,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
@@ -399,12 +406,57 @@ class StmtVisitor:
             self._visit_if_switch_expr(node.value, safe, lines, indent)
             return
 
+        # UDT lvalue alias (BUG C): a local initialised from a user-defined-UDT
+        # var/global lvalue (or a ternary/switch of such lvalues) and then
+        # mutated through must ALIAS the global, not value-copy — Pine UDTs are
+        # reference types. Emit a C++ reference (non-rebinding) or pointer
+        # (rebinding) alias instead of the default copy.
+        if not is_global_member:
+            alias = self._udt_local_alias_kind(node)
+            if alias is not None:
+                kind, udt_t = alias
+                if kind == "ref":
+                    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
+                # Pointer alias: take address of each selected lvalue; subsequent
+                # field access lowers to ``->`` and rebinds to ``&(other)``.
+                self._udt_ptr_alias_locals.add(node.name)
+                cpp_val = self._addr_of_udt_selection(node.value, node.name)
+                lines.append(f"{pad}{udt_t}* {safe} = {cpp_val};")
+                return
+
+        # Collection lvalue alias (BUG 2): a local bound to an existing array /
+        # map / matrix lvalue (or a ternary/switch selecting same-typed ones)
+        # and later MUTATED through must ALIAS the member, not value-copy — Pine
+        # collections are reference types. Proven: jevondijefferson-big-breakout
+        # does ``array<orderBlock> orderBlocks = internal ? internalOrderBlocks
+        # : swingOrderBlocks`` then ``orderBlocks.unshift(ob)`` in three helpers;
+        # the value-copy left the member arrays empty. Emit a non-rebinding C++
+        # reference instead.
+        if not is_global_member:
+            coll_spec = self._collection_lvalue_selection_spec(node.value)
+            if coll_spec is not None and self._collection_local_must_alias(node):
+                # Register the local's collection kind so subsequent
+                # ``.size()/.get()/.unshift()`` dispatch resolves correctly.
+                self._collection_types[node.name] = coll_spec
+                if coll_spec.kind == "array":
+                    self._array_vars.add(node.name)
+                elif coll_spec.kind == "map":
+                    self._map_vars.add(node.name)
+                elif coll_spec.kind == "matrix":
+                    self._matrix_specs[node.name] = coll_spec
+                cpp_type = self._type_spec_to_cpp(coll_spec)
+                cpp_val = self._visit_rhs_value(node.value, node.name, target_cpp_type=cpp_type)
+                lines.append(f"{pad}{cpp_type}& {safe} = {cpp_val};")
+                return
+
         # General declaration
-        cpp_val = self._visit_expr(node.value)
+        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:
-            cpp_type = self._type_for_decl(node)
             lines.append(f"{pad}{cpp_type} {safe} = {cpp_val};")
 
     @staticmethod
@@ -474,6 +526,12 @@ class StmtVisitor:
         if self._active_var_remap and safe in self._active_var_remap:
             safe = self._active_var_remap[safe]
 
+        # Pointer-aliased UDT local (BUG C, rebinding case): ``p := other``
+        # rebinds the pointer to the address of the newly selected UDT lvalue.
+        if target_name in self._udt_ptr_alias_locals and node.op == ":=":
+            lines.append(f"{pad}{safe} = {self._addr_of_udt_selection(node.value, target_name)};")
+            return
+
         if target_name in self.ctx.series_vars:
             val_cpp = self._visit_expr(node.value)
             if node.op == ":=":
@@ -507,7 +565,7 @@ class StmtVisitor:
                             f"expected {self._type_spec_to_cpp(lhs_spec)}, "
                             f"got {self._type_spec_to_cpp(rhs_spec)}",
                         )
-            val_cpp = self._visit_expr(node.value)
+            val_cpp = self._visit_rhs_value(node.value, target_name)
             if node.op == ":=":
                 lines.append(f"{pad}{safe} = {val_cpp};")
             else:
@@ -517,7 +575,7 @@ class StmtVisitor:
                 else:
                     lines.append(f"{pad}{safe} {node.op} {val_cpp};")
         else:
-            val_cpp = self._visit_expr(node.value)
+            val_cpp = self._visit_rhs_value(node.value, target_name)
             if node.op == ":=":
                 lines.append(f"{pad}{safe} = {val_cpp};")
             else:
@@ -542,7 +600,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
@@ -585,7 +656,30 @@ class StmtVisitor:
 
         lines.append(f"{pad}/* unsupported tuple assignment */")
 
+    def _push_block_var_remap(self, node):
+        """Activate block-scoped var renames for ``node`` (BUG 1). Returns the
+        previous ``_active_var_remap`` to restore (or ``_NO_BLOCK_REMAP`` if this
+        block owns no renames). Renames are MERGED over the inherited remap so
+        nested blocks keep any enclosing func-clone / outer-block mapping."""
+        renames = self._block_var_renames.get(id(node))
+        if not renames:
+            return _NO_BLOCK_REMAP
+        saved = self._active_var_remap
+        self._active_var_remap = {**saved, **renames}
+        return saved
+
+    def _pop_block_var_remap(self, saved) -> None:
+        if saved is not _NO_BLOCK_REMAP:
+            self._active_var_remap = saved
+
     def _visit_if(self, node: IfStmt, lines: list[str], indent: int) -> None:
+        _blk_saved = self._push_block_var_remap(node)
+        try:
+            self._visit_if_body(node, lines, indent)
+        finally:
+            self._pop_block_var_remap(_blk_saved)
+
+    def _visit_if_body(self, node: IfStmt, lines: list[str], indent: int) -> None:
         pad = "    " * indent
 
         # TA hoisting: inside per-call-site function variants, execute ALL
@@ -622,20 +716,73 @@ class StmtVisitor:
         pad = "    " * indent
         start = self._visit_expr(node.start)
         end = self._visit_expr(node.end)
-        step = self._visit_expr(node.step) if node.step else "1"
         var = node.var  # new AST uses .var instead of .var_name
-        lines.append(f"{pad}for (int {var} = {start}; {var} <= {end}; {var} += {step}) {{")
+        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) {{"
+            )
         # 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)
-        for s in node.body:
-            self._visit_stmt(s, lines, indent + 1)
+        _blk_saved = self._push_block_var_remap(node)
+        try:
+            for s in node.body:
+                self._visit_stmt(s, lines, indent + 1)
+        finally:
+            self._pop_block_var_remap(_blk_saved)
         self._current_loop_vars = saved_loop
         lines.append(f"{pad}}}")
 
+    def _loop_elem_is_writeback_udt(self, iterable) -> bool:
+        """Whether a ``for x in coll`` loop variable must bind by reference.
+
+        In Pine a ``for x in arr`` loop variable over an array of *user-defined
+        objects* is a reference to the element — field writes (``x.f := v``)
+        mutate the array in place — whereas over a primitive array it is a
+        copy. So emit C++ ``auto&`` only for arrays whose element is a
+        user-defined UDT struct. Primitive elements keep ``auto`` (Pine copy
+        semantics: writing the loop var must NOT write back). Drawing handles
+        (line/box/label/linefill/...) also keep ``auto``: their element type
+        name is a builtin, not in ``_udt_defs``, and a handle copy already
+        mutates the shared engine object. (Reassigning the loop var itself —
+        ``x := ...`` — is not modelled by either form, but Pine forbids it for
+        objects in practice and it does not occur in the corpus.)
+        """
+        spec = self._type_spec_from_expr(iterable)
+        return (
+            spec is not None
+            and spec.kind == "array"
+            and spec.element is not None
+            and spec.element.kind == "udt"
+            and spec.element.name in self._udt_defs
+        )
+
     def _visit_for_in(self, node, lines: list[str], indent: int) -> None:
         pad = "    " * indent
         iterable = self._visit_expr(node.iterable)
@@ -649,12 +796,17 @@ class StmtVisitor:
                     self._current_loop_vars.add(v)
         if node.var:
             v_cpp = self._safe_name(node.var)
-            lines.append(f"{pad}for (auto {v_cpp} : {iterable}) {{")
+            ref = "&" if self._loop_elem_is_writeback_udt(node.iterable) else ""
+            lines.append(f"{pad}for (auto{ref} {v_cpp} : {iterable}) {{")
         elif node.vars:
             bindings = ", ".join(node.vars)
             lines.append(f"{pad}for (auto [{bindings}] : {iterable}) {{")
-        for s in node.body:
-            self._visit_stmt(s, lines, indent + 1)
+        _blk_saved = self._push_block_var_remap(node)
+        try:
+            for s in node.body:
+                self._visit_stmt(s, lines, indent + 1)
+        finally:
+            self._pop_block_var_remap(_blk_saved)
         lines.append(f"{pad}}}")
         self._current_loop_vars = saved_loop
 
@@ -662,8 +814,12 @@ class StmtVisitor:
         pad = "    " * indent
         cond = self._visit_expr(node.condition)
         lines.append(f"{pad}while ({cond}) {{")
-        for s in node.body:
-            self._visit_stmt(s, lines, indent + 1)
+        _blk_saved = self._push_block_var_remap(node)
+        try:
+            for s in node.body:
+                self._visit_stmt(s, lines, indent + 1)
+        finally:
+            self._pop_block_var_remap(_blk_saved)
         lines.append(f"{pad}}}")
 
     def _visit_switch(self, node: SwitchStmt, lines: list[str], indent: int) -> None:
@@ -712,6 +868,12 @@ class StmtVisitor:
                     # Check if it's a skip expr
                     if self._is_skip_expr(stmt.expr):
                         return
+                    # A void drawing setter / delete / visual-noop cannot be the
+                    # branch's value (it lowers to a void C++ call) — emit it as
+                    # a statement and leave ``target`` at its default.
+                    if self._call_is_void(stmt.expr):
+                        self._visit_stmt(stmt, lines, indent)
+                        return
                     cpp = self._visit_expr(stmt.expr)
                     pad = "    " * indent
                     lines.append(f"{pad}{target} = {cpp};")

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

package/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)
@@ -552,39 +576,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):
-            # 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)
-            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 type name parsed as IDENT, next is 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()
@@ -601,6 +650,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):
@@ -677,7 +733,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