@pineforge/codegen-pyodide 0.10.4 → 1.0.0-rc.1

package/pineforge_codegen/parser.py

@@ -11,18 +11,20 @@ Rewritten parser (Tasks 5 & 6) that:
 
 from __future__ import annotations
 
+import math
 import re
 
 from .lexer import Token, TokenType
 from .errors import CompileError, Diagnostic, Level, Phase, SourceLocation
+from .limits import MAX_NESTING_DEPTH, TimeBudget, limit_error, syntax_children
 from .ast_nodes import (
-    ASTNode,
+    ASTNode, ArgOrder,
     Program, StrategyDecl, ImportStmt,
     VarDecl, Assignment, TupleAssign,
     IfStmt, ForStmt, ForInStmt, WhileStmt, SwitchStmt, BreakStmt, ContinueStmt,
     FuncDef, ExprStmt,
     BinOp, UnaryOp, Ternary, FuncCall, Subscript,
-    Identifier, MemberAccess, TypeAnnotation,
+    Identifier, MemberAccess,
     NumberLiteral, StringLiteral, BoolLiteral, NaLiteral, ColorLiteral,
     TupleLiteral,
     TypeField, TypeDecl, EnumDecl, MethodDef,
@@ -30,9 +32,20 @@ from .ast_nodes import (
 
 
 class ParseError(Exception):
-    pass
+    def __init__(self, message: str, token: Token) -> None:
+        super().__init__(message)
+        self.token = token
 
 
+# ``//@version=N`` as TradingView reads it (tests/test_version_directive.py): the
+# whole line, spaces, tabs or form feeds allowed before ``//``, between ``//``
+# and ``@version``, around ``=`` and at the end, ASCII digits; a line ends at
+# ``\r\n``, ``\r`` or ``\n``.
+_VERSION_DIRECTIVE_RE = re.compile(
+    r"[ \t\f]*//[ \t\f]*@version[ \t\f]*=[ \t\f]*([0-9]+)[ \t\f]*"
+)
+_TRADINGVIEW_LINE_END_RE = re.compile(r"\r\n|\r|\n")
+
 # Type annotation keywords
 TYPE_KEYWORDS = {
     TokenType.TYPE_INT, TokenType.TYPE_FLOAT,
@@ -51,12 +64,22 @@ COMPOUND_ASSIGN_OPS = {
 
 
 class Parser:
-    def __init__(self, tokens: list[Token], *, source: str = "", filename: str = "<input>") -> None:
+    def __init__(self, tokens: list[Token], *, source: str = "", filename: str = "<input>",
+                 budget: TimeBudget | None = None, library: bool = False) -> None:
         self.tokens = tokens
         self.pos = 0
         self._source = source
         self._filename = filename
-        self._recovery_count = 0
+        self._budget = budget
+        # A Pine library module (``library_modules``): its ``library()``
+        # declaration and ``export`` declarations parse instead of being
+        # refused, and a ``const`` qualifier is recorded on its declaration.
+        self._library = library
+        # Syntax levels around the parse position, and the depth of each
+        # operator/postfix chain subtree measured so far (held by id; the
+        # parser never discards a node it built, so ids stay unique).
+        self._depth = 0
+        self._subtree_depths: dict[int, tuple[ASTNode, int]] = {}
 
     # ------------------------------------------------------------------
     # Helpers
@@ -87,6 +110,8 @@ class Parser:
     def _advance(self) -> Token:
         tok = self._current()
         self.pos += 1
+        if self._budget is not None and self.pos % 128 == 0:
+            self._budget.check(self._loc(tok), Phase.PARSER)
         return tok
 
     def _consume(self, tt: TokenType, msg: str = "") -> Token:
@@ -94,8 +119,8 @@ class Parser:
             return self._advance()
         cur = self._current()
         raise ParseError(
-            f"Expected {tt.name} got {cur.type.name}({cur.value!r}) "
-            f"L{cur.line}:{cur.col}. {msg}"
+            f"Expected {tt.name}, got {cur.type.name}({cur.value!r}). {msg}".strip(),
+            cur,
         )
 
     def _skip_newlines(self) -> None:
@@ -121,6 +146,52 @@ class Parser:
         node.loc = self._loc(tok)
         return node
 
+    # Nesting budget.  Recursive descent spends Python frames per level, and
+    # the tree it builds must stay shallow: freeing a tree some 4,000 levels
+    # deep overflows Pyodide's stack, fatally.
+
+    def _enter(self, tok: Token) -> None:
+        """Count one syntax level (a block, an ``else if``, a prefix operator
+        or a nested expression) before recursing into it."""
+        if self._depth >= MAX_NESTING_DEPTH:
+            raise limit_error(
+                f"Nesting depth exceeds {MAX_NESTING_DEPTH} levels.",
+                self._loc(tok), Phase.PARSER,
+            )
+        self._depth += 1
+
+    def _check_chain(self, node: ASTNode, tok: Token) -> ASTNode:
+        """Bound an operator or postfix chain, which grows without recursing."""
+        if self._subtree_depth(node) > MAX_NESTING_DEPTH:
+            raise limit_error(
+                f"AST nesting depth exceeds {MAX_NESTING_DEPTH} nodes.",
+                self._loc(tok), Phase.PARSER,
+            )
+        return node
+
+    def _subtree_depth(self, root: ASTNode) -> int:
+        """Depth of ``root``'s subtree, reusing the depths measured so far."""
+        known = self._subtree_depths
+        stack: list[tuple[ASTNode, bool]] = [(root, False)]
+        while stack:
+            node, expanded = stack.pop()
+            if id(node) in known:
+                continue
+            children = [
+                child for child in syntax_children(node)
+                if id(child) not in known
+            ]
+            if expanded or not children:
+                depth = 1 + max(
+                    (known[id(child)][1] for child in syntax_children(node)),
+                    default=0,
+                )
+                known[id(node)] = (node, depth)
+            else:
+                stack.append((node, True))
+                stack.extend((child, False) for child in children)
+        return known[id(root)][1]
+
     # ------------------------------------------------------------------
     # Top-level
     # ------------------------------------------------------------------
@@ -139,32 +210,51 @@ class Parser:
                         prog.body.extend(stmt)
                     else:
                         prog.body.append(stmt)
-            except ParseError:
-                # Error recovery: skip to next newline and continue
-                self._recover()
+                self._expect_statement_end()
+            except ParseError as error:
+                self._raise_syntax_error(error)
             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:
-        """Extract version number from //@version=N annotation in source."""
+        """The version of the script's ``//@version=N`` directive.
+
+        TradingView's rule (tests/test_version_directive.py, 46 probes): the
+        FIRST line holding nothing but ``//``, ``@version``, ``=`` and ASCII
+        digits, with optional spaces, tabs or form feeds around each, anywhere
+        in the script -- read line by line, where a carriage return ends a line
+        too, so such a line inside a multiline string counts as well. Case,
+        ``///``, a space after ``@``, trailing text, code before it on the line,
+        any other blank (vertical tab, no-break space) or a carriage return
+        inside it make it no directive.
+        """
         if not self._source:
             return None
-        m = re.search(r'//@version=(\d+)', self._source)
-        if m:
-            return int(m.group(1))
+        for line in _TRADINGVIEW_LINE_END_RE.split(self._source):
+            match = _VERSION_DIRECTIVE_RE.fullmatch(line)
+            if match is not None:
+                return int(match.group(1))
         return None
 
-    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):
-            self._advance()
+    def _raise_syntax_error(self, error: ParseError) -> None:
+        raise CompileError([Diagnostic(
+            level=Level.ERROR, phase=Phase.PARSER,
+            location=self._loc(error.token), message=str(error),
+        )]) from error
+
+    def _expect_statement_end(self) -> None:
+        """A second expression on the same Pine line is a syntax error."""
+        cur = self._current()
+        if cur.type in (TokenType.NEWLINE, TokenType.DEDENT, TokenType.EOF_TOKEN):
+            return
+        previous = self.tokens[self.pos - 1]
+        if previous.type == TokenType.DEDENT or cur.line > previous.line:
+            return
+        raise ParseError(
+            f"Unexpected token {cur.type.name}({cur.value!r}) after statement; "
+            "expected a line break or comma", cur,
+        )
 
     # ------------------------------------------------------------------
     # Statement parsing
@@ -211,6 +301,18 @@ class Parser:
             tok = self._advance()
             return self._set_loc(ContinueStmt(), tok)
 
+        # ``export`` starts a declaration in Pine libraries, but no strategy
+        # may export a function. Refuse it at the authored keyword instead of
+        # parsing it as a standalone expression and reporting its function
+        # name as an unrelated trailing token.
+        if cur.type == TokenType.IDENT and cur.value == "export":
+            if self._library:
+                return self._parse_export_decl()
+            raise ParseError(
+                "'export' declarations belong to Pine libraries; "
+                "PineForge transpiles strategies only", cur,
+            )
+
         # import statement
         if cur.type == TokenType.IMPORT:
             return self._parse_import_stmt()
@@ -243,8 +345,20 @@ class Parser:
                 and self._peek(3).type != TokenType.EQUALS
             )
             if typed_after_qual or bare_after_qual:
+                qualifier = cur.value
                 self._advance()  # consume the qualifier prefix
-                return self._parse_single_statement()
+                stmt = self._parse_single_statement()
+                if isinstance(stmt, VarDecl):
+                    # Kept for the ta.* length lowering: an explicit
+                    # ``series`` makes TradingView re-window the call.
+                    stmt.annotations = {**(stmt.annotations or {}),
+                                        "qualifier": qualifier}
+                if self._library and qualifier == "const" and isinstance(stmt, VarDecl):
+                    # A library's ``const`` declaration: the only globals an
+                    # exported function may read, and a v5 const operand.
+                    stmt.annotations = {**(stmt.annotations or {}),
+                                        "declared_const": True}
+                return stmt
 
         # Type-annotated declaration: float x = ..., int x = ...
         if cur.type in TYPE_KEYWORDS and self._peek().type == TokenType.IDENT:
@@ -292,6 +406,9 @@ class Parser:
             # strategy() / indicator() declaration
             if cur.value in ("strategy", "indicator") and self._peek().type == TokenType.LPAREN:
                 return self._parse_strategy_decl()
+            if (self._library and cur.value == "library"
+                    and self._peek().type == TokenType.LPAREN):
+                return self._parse_strategy_decl()
 
             # Check for function definition: name(params) =>
             if self._is_func_def():
@@ -350,8 +467,13 @@ class Parser:
             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 = base + 1
+        # A library type is qualified by its import alias: ``lib.Type x = ...``.
+        while (i + 1 < len(self.tokens)
+               and self.tokens[i].type == TokenType.DOT
+               and self.tokens[i + 1].type == TokenType.IDENT):
+            i += 2
+        # Skip past optional generic args after the type ident: IDENT [< ... >]
         if i < len(self.tokens) and self.tokens[i].type == TokenType.LT:
             depth = 1
             i += 1
@@ -364,6 +486,12 @@ class Parser:
                 elif tt in (TokenType.NEWLINE, TokenType.EOF_TOKEN):
                     return False
                 i += 1
+        # Postfix-array shorthand of a non-keyword type: ``color[] c = ...``,
+        # ``line[] ls = ...``. An empty ``[]`` cannot be a history subscript.
+        while (i + 1 < len(self.tokens)
+               and self.tokens[i].type == TokenType.LBRACKET
+               and self.tokens[i + 1].type == TokenType.RBRACKET):
+            i += 2
         # Now expect an IDENT (variable name).
         if i >= len(self.tokens) or self.tokens[i].type != TokenType.IDENT:
             return False
@@ -414,18 +542,58 @@ class Parser:
         }
         return self._set_loc(node, start_tok)
 
+    def _parse_export_decl(self):
+        """Parse a library's ``export`` declaration: a function, a method, a
+        type, an enum or a ``const`` variable, annotated ``exported``."""
+        export_tok = self._advance()  # consume 'export'
+        cur = self._current()
+        node = None
+        if cur.type == TokenType.METHOD:
+            node = self._parse_method_def()
+        elif cur.type == TokenType.IDENT:
+            if (cur.value in ("type", "enum")
+                    and self._peek().type == TokenType.IDENT
+                    and self._peek(2).type == TokenType.NEWLINE):
+                node = self._parse_type_or_enum_decl()
+            elif cur.value == "const":
+                node = self._parse_single_statement()
+                if not isinstance(node, VarDecl):
+                    node = None
+            elif self._is_func_def():
+                node = self._parse_func_def()
+        if node is None:
+            raise ParseError(
+                "'export' must precede a function, method, type, enum or "
+                "const declaration", export_tok,
+            )
+        node.annotations = {**(node.annotations or {}), "exported": True}
+        return node
+
     def _parse_import_stmt(self) -> ImportStmt:
-        """Parse: import path/to/library/version"""
+        """Parse: import <user>/<name>/<version> [as <alias>]"""
         start_tok = self._current()
         self._consume(TokenType.IMPORT)
-        # Consume the rest of the line as the import path
-        parts: list[str] = []
+        # Consume the rest of the line; any other spelling keeps it as
+        # written in ``path`` for the refusal.
+        tokens = []
         while (not self._at_end()
                and not self._check(TokenType.NEWLINE)
                and not self._check(TokenType.EOF_TOKEN)):
-            parts.append(self._advance().value)
-        path = "".join(parts)
-        node = ImportStmt(path=path)
+            tokens.append(self._advance())
+        values = [tok.value for tok in tokens]
+        node = ImportStmt(path="".join(values))
+
+        def word(index: int) -> bool:
+            return bool(re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", values[index]))
+
+        if (len(tokens) in (5, 7) and word(0) and word(2)
+                and values[1] == values[3] == "/"
+                and tokens[4].type == TokenType.NUMBER and values[4].isdigit()
+                and (len(tokens) == 5 or (values[5] == "as" and word(6)))):
+            node.user, node.name, node.version = values[0], values[2], int(values[4])
+            node.path = f"{node.user}/{node.name}/{node.version}"
+            if len(tokens) == 7:
+                node.alias = values[6]
         return self._set_loc(node, start_tok)
 
     def _parse_var_decl(self) -> VarDecl | list:
@@ -477,6 +645,10 @@ class Parser:
     def _parse_type_hint_string(self) -> str:
         """Parse primitive, UDT, array<T>, map<K,V>, or postfix-array (``T[]``) hints."""
         base = self._advance().value
+        # Library type qualified by its import alias: ``lib.Type``.
+        while self._check(TokenType.DOT) and self._peek().type == TokenType.IDENT:
+            self._advance()  # .
+            base = f"{base}.{self._advance().value}"
         if self._check(TokenType.LT):
             parts: list[str] = []
             depth = 0
@@ -549,6 +721,10 @@ class Parser:
         depth = 0
         i = self.pos
         while i < len(self.tokens):
+            # One look-ahead per ``.name<`` scans to the end of the line, so a
+            # long line of comparisons costs its length squared.
+            if self._budget is not None and (i - self.pos) % 1024 == 1023:
+                self._budget.check(self._loc(self.tokens[self.pos]), Phase.PARSER)
             tt = self.tokens[i].type
             if tt == TokenType.LT:
                 depth += 1
@@ -586,6 +762,12 @@ class Parser:
             # 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()
+        elif (self._current().type == TokenType.IDENT
+              and self._peek().type == TokenType.DOT
+              and self._is_ident_typed_var_decl()):
+            # Library type qualified by its import alias:
+            # ``var lib.Type name = ...``.
+            type_hint = self._parse_type_hint_string()
 
         name_tok = self._consume(TokenType.IDENT)
         self._consume(TokenType.EQUALS)
@@ -664,10 +846,13 @@ class Parser:
         """
         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",
-        ):
+        # Optional qualifiers — they do not affect the C++ param type. A
+        # qualifier word followed by ``,`` ``)`` or ``=`` is the parameter's
+        # own name.
+        while (self._check(TokenType.IDENT)
+               and self._current().value in ("series", "simple", "const")
+               and self._peek().type not in (
+                   TokenType.COMMA, TokenType.RPAREN, TokenType.EQUALS)):
             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
@@ -683,6 +868,19 @@ class Parser:
             nxt = self._peek().type
             if nxt in (TokenType.IDENT, TokenType.LBRACKET, TokenType.LT):
                 has_type = True
+            elif nxt == TokenType.DOT:
+                # A library type qualified by its import alias:
+                # ``lib.Type name`` / ``lib.Type[] names``.
+                i = self.pos + 1
+                while (i + 1 < len(self.tokens)
+                       and self.tokens[i].type == TokenType.DOT
+                       and self.tokens[i + 1].type == TokenType.IDENT):
+                    i += 2
+                has_type = (
+                    i < len(self.tokens)
+                    and self.tokens[i].type in (
+                        TokenType.IDENT, TokenType.LBRACKET, TokenType.LT)
+                )
         if not has_type:
             return None
         return self._parse_type_hint_string()
@@ -695,7 +893,9 @@ class Parser:
         params = []
         param_type_hints: list = []
         param_defaults: list = []
+        param_qualifiers: list = []
         while not self._check(TokenType.RPAREN):
+            param_qualifiers.append(self._param_qualifier_ahead())
             # 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
@@ -732,8 +932,24 @@ class Parser:
             "param_type_hints": param_type_hints,
             "param_defaults": param_defaults,
         }
+        if self._library:
+            # A library may overload a function by its parameters' qualifiers
+            # alone (TradingView/Request/3: ``simple string`` and ``series
+            # string``); ``library_inline`` picks the overload by them.
+            node.annotations["param_qualifiers"] = param_qualifiers
         return self._set_loc(node, start_tok)
 
+    def _param_qualifier_ahead(self) -> str | None:
+        """The ``series`` / ``simple`` / ``const`` word a parameter's
+        annotation starts with (``_parse_param_type_annotation`` consumes
+        it), or None."""
+        cur = self._current()
+        if (cur.type == TokenType.IDENT and cur.value in ("series", "simple", "const")
+                and self._peek().type not in (
+                    TokenType.COMMA, TokenType.RPAREN, TokenType.EQUALS)):
+            return cur.value
+        return None
+
     def _parse_type_or_enum_decl(self):
         """Parse type or enum block declarations."""
         start_tok = self._current()
@@ -811,14 +1027,10 @@ class Parser:
         # args. See data/validation/udt-method-probe-04-default-param.
         param_defaults: list = [None]
         while self._match(TokenType.COMMA):
-            # Skip optional type annotations
-            param_type = None
-            if self._current().type in TYPE_KEYWORDS:
-                param_type = self._parse_type_hint_string()
-            elif (self._current().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()
+            # Optional ``series``/``simple``/``const`` qualifiers and type
+            # annotation: ``line ln`` / ``float[] arr`` / ``array<float> xs``
+            # / ``series float x`` / ``lib.Type t``.
+            param_type = self._parse_param_type_annotation()
             p = self._consume(TokenType.IDENT).value
             pdefault = None
             if self._check(TokenType.EQUALS):
@@ -863,8 +1075,13 @@ class Parser:
         if self._check(TokenType.ELSE):
             self._advance()
             if self._check(TokenType.IF):
-                # else if -> nested IfStmt in else_body
-                else_body = [self._parse_if_stmt()]
+                # else if -> nested IfStmt in else_body.  The ladder recurses
+                # once per branch at one indentation.
+                self._enter(self._current())
+                try:
+                    else_body = [self._parse_if_stmt()]
+                finally:
+                    self._depth -= 1
             else:
                 self._consume(TokenType.NEWLINE)
                 self._consume(TokenType.INDENT)
@@ -959,7 +1176,7 @@ class Parser:
                     default_body = self._parse_block()
                     self._consume(TokenType.DEDENT)
                 else:
-                    default_body = [ExprStmt(expr=self._parse_expression())]
+                    default_body = self._parse_arm_line()
             else:
                 # case_expr => body
                 case_expr = self._parse_expression()
@@ -970,7 +1187,7 @@ class Parser:
                     case_body = self._parse_block()
                     self._consume(TokenType.DEDENT)
                 else:
-                    case_body = [ExprStmt(expr=self._parse_expression())]
+                    case_body = self._parse_arm_line()
                 cases.append((case_expr, case_body))
             self._skip_newlines()
 
@@ -978,9 +1195,74 @@ class Parser:
         node = SwitchStmt(expr=expr, cases=cases, default_body=default_body)
         return self._set_loc(node, start_tok)
 
+    def _parse_arm_line(self) -> list:
+        """The block of a ``switch`` arm written on its ``=>`` line.
+
+        Pine joins one-line statements with commas, and an arm's line is such
+        a block: TradingView's ``TradingView/Request/3`` library ends an arm
+        in ``=> runtime.error(...), ""``. TradingView runs the statements left
+        to right and the arm's value is the last one's, as for a block written
+        below the arrow; a declaration or an assignment may be one of them
+        (``tests/fixtures/tail_f_tv``). A lone expression is the node an arm
+        always held.
+        """
+        body: list = []
+        while True:
+            if self._arm_line_statement_ahead():
+                self._extend_statement_list(body, self._parse_single_statement())
+            else:
+                start_tok = self._current()
+                expr = self._parse_expression()
+                if self._current().type in COMPOUND_ASSIGN_OPS:
+                    # A field or element target: ``o.f := v``.
+                    op = COMPOUND_ASSIGN_OPS[self._advance().type]
+                    node = Assignment(target=expr, op=op, value=self._parse_expression())
+                    body.append(self._set_loc(node, start_tok))
+                else:
+                    body.append(ExprStmt(expr=expr))
+            if not self._match(TokenType.COMMA):
+                return body
+            if self._check(TokenType.NEWLINE) or self._check(TokenType.DEDENT) or self._at_end():
+                return body
+
+    def _arm_line_statement_ahead(self) -> bool:
+        """Whether an arm line's next statement is one no expression starts:
+        a declaration, an assignment to a name, ``break`` or ``continue``.
+        (A call is never a function definition here, so ``f(a)`` before the
+        next arm's ``=>`` stays a call.)"""
+        cur, nxt = self._current(), self._peek()
+        if cur.type in (TokenType.VAR, TokenType.VARIP,
+                        TokenType.BREAK, TokenType.CONTINUE):
+            return True
+        if cur.type in TYPE_KEYWORDS:
+            return ((nxt.type == TokenType.IDENT
+                     and self._peek(2).type == TokenType.EQUALS)
+                    or (nxt.type == TokenType.LBRACKET
+                        and self._peek(2).type == TokenType.RBRACKET))
+        if cur.type == TokenType.LBRACKET:
+            return self._is_tuple_assign()
+        if cur.type != TokenType.IDENT:
+            return False
+        if cur.value in ("const", "series", "simple") and (
+                nxt.type in TYPE_KEYWORDS
+                or (nxt.type == TokenType.IDENT
+                    and self._is_ident_typed_var_decl(offset=1))):
+            return True
+        return (self._is_ident_typed_var_decl()
+                or (nxt.type == TokenType.EQUALS
+                    and self._peek(2).type != TokenType.EQUALS)
+                or nxt.type in COMPOUND_ASSIGN_OPS)
+
     # -- Block parsing --
 
     def _parse_block(self) -> list:
+        self._enter(self._current())
+        try:
+            return self._parse_block_statements()
+        finally:
+            self._depth -= 1
+
+    def _parse_block_statements(self) -> list:
         stmts: list = []
         self._skip_newlines()
         while not self._check(TokenType.DEDENT) and not self._at_end():
@@ -991,8 +1273,9 @@ class Parser:
                         stmts.extend(stmt)
                     else:
                         stmts.append(stmt)
-            except ParseError:
-                self._recover()
+                self._expect_statement_end()
+            except ParseError as error:
+                self._raise_syntax_error(error)
             self._skip_newlines()
         return stmts
 
@@ -1020,12 +1303,16 @@ class Parser:
     }
 
     def _parse_expression(self):
-        # if/switch can be used as expressions (RHS of assignments)
-        if self._check(TokenType.IF):
-            return self._parse_if_expr()
-        if self._check(TokenType.SWITCH):
-            return self._parse_switch_expr()
-        return self._parse_ternary()
+        self._enter(self._current())
+        try:
+            # if/switch can be used as expressions (RHS of assignments)
+            if self._check(TokenType.IF):
+                return self._parse_if_expr()
+            if self._check(TokenType.SWITCH):
+                return self._parse_switch_expr()
+            return self._parse_ternary()
+        finally:
+            self._depth -= 1
 
     def _parse_if_expr(self):
         """Parse if/else as an expression (returns IfStmt, codegen handles it)."""
@@ -1073,12 +1360,14 @@ class Parser:
                 right = self._parse_and()
                 left = BinOp(left=left, op="or", right=right)
                 self._set_loc(left, start_tok)
+                self._check_chain(left, start_tok)
             elif not in_continuation and self._try_line_continuation(TokenType.OR):
                 in_continuation = True
                 self._advance()  # consume OR
                 right = self._parse_and()
                 left = BinOp(left=left, op="or", right=right)
                 self._set_loc(left, start_tok)
+                self._check_chain(left, start_tok)
             else:
                 break
         if in_continuation:
@@ -1095,12 +1384,14 @@ class Parser:
                 right = self._parse_not()
                 left = BinOp(left=left, op="and", right=right)
                 self._set_loc(left, start_tok)
+                self._check_chain(left, start_tok)
             elif not in_continuation and self._try_line_continuation(TokenType.AND):
                 in_continuation = True
                 self._advance()  # consume AND
                 right = self._parse_not()
                 left = BinOp(left=left, op="and", right=right)
                 self._set_loc(left, start_tok)
+                self._check_chain(left, start_tok)
             else:
                 break
         if in_continuation:
@@ -1116,8 +1407,12 @@ class Parser:
     def _parse_not(self):
         if self._check(TokenType.NOT):
             start_tok = self._current()
+            self._enter(start_tok)
             self._advance()
-            operand = self._parse_not()
+            try:
+                operand = self._parse_not()
+            finally:
+                self._depth -= 1
             node = UnaryOp(op="not", operand=operand)
             return self._set_loc(node, start_tok)
         return self._parse_comparison()
@@ -1135,6 +1430,7 @@ class Parser:
             right = self._parse_addition()
             left = BinOp(left=left, op=op, right=right)
             self._set_loc(left, start_tok)
+            self._check_chain(left, start_tok)
         return left
 
     def _parse_addition(self):
@@ -1145,6 +1441,7 @@ class Parser:
             right = self._parse_multiplication()
             left = BinOp(left=left, op=op, right=right)
             self._set_loc(left, start_tok)
+            self._check_chain(left, start_tok)
         return left
 
     def _parse_multiplication(self):
@@ -1156,24 +1453,34 @@ class Parser:
             right = self._parse_unary()
             left = BinOp(left=left, op=op, right=right)
             self._set_loc(left, start_tok)
+            self._check_chain(left, start_tok)
         return left
 
     def _parse_unary(self):
         if self._check(TokenType.MINUS):
             start_tok = self._current()
+            self._enter(start_tok)
             self._advance()
-            operand = self._parse_unary()
+            try:
+                operand = self._parse_unary()
+            finally:
+                self._depth -= 1
             node = UnaryOp(op="-", operand=operand)
             return self._set_loc(node, start_tok)
         if self._check(TokenType.PLUS):
             start_tok = self._current()
+            self._enter(start_tok)
             self._advance()
-            operand = self._parse_unary()
+            try:
+                operand = self._parse_unary()
+            finally:
+                self._depth -= 1
             node = UnaryOp(op="+", operand=operand)
             return self._set_loc(node, start_tok)
         return self._parse_postfix()
 
     def _parse_postfix(self):
+        chain_tok = self._current()
         expr = self._parse_primary()
         while True:
             # Subscript: expr[index]
@@ -1212,6 +1519,7 @@ class Parser:
                 expr = self._parse_call_with_callee(expr)
             else:
                 break
+            self._check_chain(expr, chain_tok)
         return expr
 
     def _is_call_position(self, expr) -> bool:
@@ -1234,7 +1542,7 @@ class Parser:
         node.annotations = {"call_arg_order": call_arg_order}
         return self._set_loc(node, start_tok)
 
-    def _parse_call_args(self) -> tuple[list, dict, list]:
+    def _parse_call_args(self) -> tuple[list, dict, ArgOrder]:
         """Parse function call arguments and keyword arguments."""
         args: list = []
         kwargs: dict = {}
@@ -1275,7 +1583,7 @@ class Parser:
 
             self._match(TokenType.COMMA)
 
-        return args, kwargs, call_arg_order
+        return args, kwargs, ArgOrder(call_arg_order)
 
     # -- Primary expressions --
 
@@ -1304,10 +1612,20 @@ class Parser:
         # Number literal
         if cur.type == TokenType.NUMBER:
             self._advance()
-            if "." in cur.value or "e" in cur.value or "E" in cur.value:
-                val = float(cur.value)
-            else:
-                val = int(cur.value)
+            try:
+                if "." in cur.value or "e" in cur.value or "E" in cur.value:
+                    val = float(cur.value)
+                    out_of_range = not math.isfinite(val)
+                else:
+                    val = int(cur.value)
+                    out_of_range = val > (1 << 64) - 1
+            except (ValueError, OverflowError):
+                out_of_range = True
+            if out_of_range:
+                raise limit_error(
+                    "Numeric literal exceeds the generated C++ range.",
+                    self._loc(cur), Phase.PARSER,
+                )
             node = NumberLiteral(value=val)
             return self._set_loc(node, cur)
 
@@ -1356,6 +1674,4 @@ class Parser:
             node = Identifier(name=cur.value)
             return self._set_loc(node, cur)
 
-        raise ParseError(
-            f"Unexpected token {cur.type.name}({cur.value!r}) at L{cur.line}:{cur.col}"
-        )
+        raise ParseError(f"Unexpected token {cur.type.name}({cur.value!r})", cur)