@pineforge/codegen-pyodide 0.10.0 → 0.10.2

package/pineforge_codegen/method_binding.py

@@ -0,0 +1,163 @@
+"""Strict, source-order-preserving binding for typed Pine methods.
+
+Typed extension methods are inventoried before semantic analysis so a call may
+precede its declaration without falling through to a same-named builtin.  This
+module deliberately contains no analyzer or codegen state: both phases consume
+the same signature and binding result.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .ast_nodes import ASTNode, FuncCall, MethodDef, Program
+
+
+@dataclass(frozen=True)
+class MethodSignature:
+    key: str
+    param_names: tuple[str, ...]
+    param_defaults: tuple[ASTNode | None, ...]
+    param_type_hints: tuple[str | None, ...]
+    declaration: MethodDef | None = None
+
+
+@dataclass(frozen=True)
+class BoundMethodArgs:
+    """Non-receiver arguments in parameter and evaluation order."""
+
+    args_by_param: tuple[ASTNode, ...]
+    evaluation_order: tuple[ASTNode, ...]
+
+
+class MethodBindError(ValueError):
+    pass
+
+
+def signature_from_method_def(node: MethodDef) -> MethodSignature:
+    annotations = node.annotations or {}
+    defaults = list(annotations.get("param_defaults", ()))
+    hints = list(annotations.get("param_type_hints", ()))
+    while len(defaults) < len(node.params):
+        defaults.append(None)
+    while len(hints) < len(node.params):
+        hints.append(None)
+    return MethodSignature(
+        key=f"{node.type_name}.{node.name}",
+        param_names=tuple(node.params[1:]),
+        param_defaults=tuple(defaults[1:len(node.params)]),
+        param_type_hints=tuple(hints[1:len(node.params)]),
+        declaration=node,
+    )
+
+
+def signature_from_callable(
+    key: str,
+    param_names: list[str] | tuple[str, ...],
+    param_defaults: list[ASTNode | None] | tuple[ASTNode | None, ...],
+    param_type_hints: list[str | None] | tuple[str | None, ...] = (),
+) -> MethodSignature:
+    """Build a non-receiver signature from an analyzed method FuncInfo."""
+
+    names = tuple(param_names)
+    defaults = list(param_defaults)
+    hints = list(param_type_hints)
+    while len(defaults) < len(names):
+        defaults.append(None)
+    while len(hints) < len(names):
+        hints.append(None)
+    return MethodSignature(
+        key=key,
+        param_names=names,
+        param_defaults=tuple(defaults[:len(names)]),
+        param_type_hints=tuple(hints[:len(names)]),
+    )
+
+
+def inventory_method_signatures(program: Program) -> dict[str, MethodSignature]:
+    """Inventory direct method declarations without analyzing their bodies."""
+
+    result: dict[str, MethodSignature] = {}
+    for stmt in program.body:
+        if isinstance(stmt, MethodDef):
+            signature = signature_from_method_def(stmt)
+            # Preserve the analyzer's historical first-declaration lookup. This
+            # prepass does not introduce method overloading or duplicate policy.
+            result.setdefault(signature.key, signature)
+    return result
+
+
+def _written_actuals(call: FuncCall) -> list[ASTNode]:
+    """Recover written order lost by the parser's args/kwargs split."""
+
+    fallback = [*call.args, *call.kwargs.values()]
+    recorded = (call.annotations or {}).get("call_arg_order", ())
+    if (
+        len(recorded) == len(fallback)
+        and {id(node) for node in recorded} == {id(node) for node in fallback}
+    ):
+        return list(recorded)
+    if not fallback or any(getattr(node, "loc", None) is None for node in fallback):
+        return fallback
+    indexed = list(enumerate(fallback))
+    indexed.sort(
+        key=lambda item: (
+            item[1].loc.line,
+            item[1].loc.col,
+            item[0],
+        )
+    )
+    return [node for _index, node in indexed]
+
+
+def bind_method_call(
+    signature: MethodSignature,
+    call: FuncCall,
+) -> BoundMethodArgs:
+    """Bind one method call strictly, excluding the receiver argument."""
+
+    names = signature.param_names
+    if len(call.args) > len(names):
+        raise MethodBindError(
+            f"{signature.key}: too many positional arguments "
+            f"(expected {len(names)}, got {len(call.args)})"
+        )
+
+    for name in call.kwargs:
+        if name not in names:
+            raise MethodBindError(
+                f"{signature.key}: unknown keyword argument '{name}'"
+            )
+
+    bound: list[ASTNode | None] = [None] * len(names)
+    for index, value in enumerate(call.args):
+        bound[index] = value
+    for name, value in call.kwargs.items():
+        index = names.index(name)
+        if bound[index] is not None:
+            raise MethodBindError(
+                f"{signature.key}: argument '{name}' passed both "
+                "positionally and by keyword"
+            )
+        bound[index] = value
+
+    inserted_defaults: list[ASTNode] = []
+    for index, name in enumerate(names):
+        if bound[index] is not None:
+            continue
+        default = (
+            signature.param_defaults[index]
+            if index < len(signature.param_defaults)
+            else None
+        )
+        if default is None:
+            raise MethodBindError(
+                f"{signature.key}: missing required argument '{name}'"
+            )
+        bound[index] = default
+        inserted_defaults.append(default)
+
+    return BoundMethodArgs(
+        args_by_param=tuple(value for value in bound if value is not None),
+        evaluation_order=tuple([*_written_actuals(call), *inserted_defaults]),
+    )

package/pineforge_codegen/parser.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 import re
 
 from .lexer import Token, TokenType
-from .errors import SourceLocation
+from .errors import CompileError, Diagnostic, Level, Phase, SourceLocation
 from .ast_nodes import (
     ASTNode,
     Program, StrategyDecl, ImportStmt,
@@ -56,6 +56,7 @@ class Parser:
         self.pos = 0
         self._source = source
         self._filename = filename
+        self._recovery_count = 0
 
     # ------------------------------------------------------------------
     # Helpers
@@ -143,6 +144,9 @@ class Parser:
                 self._recover()
             self._skip_newlines()
 
+        if self._recovery_count:
+            prog.annotations = dict(prog.annotations or {})
+            prog.annotations["parse_recovery_count"] = self._recovery_count
         return prog
 
     def _extract_version(self) -> int | None:
@@ -156,6 +160,7 @@ class Parser:
 
     def _recover(self) -> None:
         """Skip tokens until next NEWLINE or EOF for error recovery."""
+        self._recovery_count += 1
         while not self._at_end() and not self._check(TokenType.NEWLINE):
             self._advance()
         if self._check(TokenType.NEWLINE):
@@ -400,10 +405,13 @@ class Parser:
         start_tok = self._advance()  # consume 'strategy' or 'indicator'
         # Parse arguments as a function call, then convert to StrategyDecl
         self._consume(TokenType.LPAREN)
-        args, kwargs = self._parse_call_args()
+        args, kwargs, call_arg_order = self._parse_call_args()
         self._consume(TokenType.RPAREN)
         node = StrategyDecl(args=args, kwargs=kwargs)
-        node.annotations = {"decl_kind": start_tok.value}
+        node.annotations = {
+            "decl_kind": start_tok.value,
+            "call_arg_order": call_arg_order,
+        }
         return self._set_loc(node, start_tok)
 
     def _parse_import_stmt(self) -> ImportStmt:
@@ -786,8 +794,16 @@ class Parser:
         start_tok = self._advance()  # consume 'method'
         name = self._consume(TokenType.IDENT).value
         self._consume(TokenType.LPAREN)
-        # First param is the type + self: TypeName self
-        type_name = self._consume(TokenType.IDENT).value
+        # First param is the required receiver type + self name.  Receiver
+        # types use the same complete Pine hint grammar as ordinary typed
+        # parameters: primitives lex as TYPE_* tokens, while collections may
+        # carry nested ``<...>`` arguments or postfix ``[]``.  Consuming only
+        # IDENT here silently dropped valid declarations such as
+        # ``method id(int self)`` and ``method push(array<int> self, ...)``
+        # through the parser's top-level recovery path.
+        if self._current().type not in TYPE_KEYWORDS | {TokenType.IDENT}:
+            self._consume(TokenType.IDENT)  # raises a located ParseError
+        type_name = self._parse_type_hint_string()
         params = [self._consume(TokenType.IDENT).value]  # 'self' or user's name
         param_type_hints = [type_name]
         # Preserve per-param default expressions so codegen can substitute
@@ -1212,15 +1228,17 @@ class Parser:
         """Parse (args, kwargs) after callee expression."""
         start_tok = self._current()
         self._consume(TokenType.LPAREN)
-        args, kwargs = self._parse_call_args()
+        args, kwargs, call_arg_order = self._parse_call_args()
         self._consume(TokenType.RPAREN)
         node = FuncCall(callee=callee, args=args, kwargs=kwargs)
+        node.annotations = {"call_arg_order": call_arg_order}
         return self._set_loc(node, start_tok)
 
-    def _parse_call_args(self) -> tuple[list, dict]:
+    def _parse_call_args(self) -> tuple[list, dict, list]:
         """Parse function call arguments and keyword arguments."""
         args: list = []
         kwargs: dict = {}
+        call_arg_order: list = []
 
         while not self._check(TokenType.RPAREN) and not self._at_end():
             # Detect kwargs: IDENT = value (but not IDENT == value)
@@ -1228,15 +1246,36 @@ class Parser:
                     and self._peek().type == TokenType.EQUALS
                     and self._peek(2).type != TokenType.EQUALS):
                 key_tok = self._advance()
+                if key_tok.value in kwargs:
+                    raise CompileError(
+                        [
+                            Diagnostic(
+                                level=Level.ERROR,
+                                phase=Phase.PARSER,
+                                location=self._loc(key_tok),
+                                message=(
+                                    "duplicate keyword argument "
+                                    f"'{key_tok.value}'"
+                                ),
+                                hint=(
+                                    f"Remove one '{key_tok.value}=' binding; "
+                                    "a keyword argument may be specified only once."
+                                ),
+                            )
+                        ]
+                    )
                 self._advance()  # consume =
                 val = self._parse_expression()
                 kwargs[key_tok.value] = val
+                call_arg_order.append(val)
             else:
-                args.append(self._parse_expression())
+                val = self._parse_expression()
+                args.append(val)
+                call_arg_order.append(val)
 
             self._match(TokenType.COMMA)
 
-        return args, kwargs
+        return args, kwargs, call_arg_order
 
     # -- Primary expressions --
 

package/pineforge_codegen/signatures.py

@@ -229,7 +229,7 @@ _math("round",
       _sig([("x", F)], ret=I),                             # round(x) → int
       _sig([("x", F), ("precision", I)]))                  # round(x, n) → float
 _math("round_to_mintick", _sig([("x", F)]))
-_math("sign",   _sig([("x", F)], ret=I))
+_math("sign",   _sig([("x", F)], ret=F))
 _math("max",
       _sig([("x", F), ("y", F)]),                          # 2-arg
       _sig([("x", F), ("y", F), ("z", F)]),                # 3-arg
@@ -307,13 +307,13 @@ _strat("exit", _sig([
 _strat("close", _sig([
     ("id", S), ("comment", S, None),
     ("qty", F, None), ("qty_percent", F, None),
-    ("alert_message", S, None), ("disable_alert", B, None),
-    ("immediately", B, False),
+    ("alert_message", S, None), ("immediately", B, False),
+    ("disable_alert", B, None),
 ], ret=VOID))
 
 _strat("close_all", _sig([
     ("comment", S, None), ("alert_message", S, None),
-    ("disable_alert", B, None), ("immediately", B, False),
+    ("immediately", B, False), ("disable_alert", B, None),
 ], ret=VOID))
 
 _strat("cancel", _sig([("id", S)], ret=VOID))