Mirror from SNAPKITTYWEST: parser/parser.py

parser/parser.py

@@ -0,0 +1,317 @@
+# parser/parser.py
+from __future__ import annotations
+from lexer.lexer import tokenize, Token
+from mantra_ast.nodes import *
+from typing import List, Iterator
+
+class ParseError(Exception):
+    pass
+
+class Parser:
+    def __init__(self, tokens):
+        self.tokens = list(tokens)
+        self.i = 0
+
+    def peek(self) -> Token:
+        return self.tokens[self.i] if self.i < len(self.tokens) else Token('EOF', '', 0, 0)
+
+    def peek2(self) -> Token:
+        return self.tokens[self.i+1] if self.i+1 < len(self.tokens) else Token('EOF', '', 0, 0)
+
+    def advance(self) -> Token:
+        t = self.peek()
+        self.i += 1
+        return t
+
+    def expect(self, typ: str) -> Token:
+        t = self.advance()
+        if t.type != typ:
+            raise ParseError(f"Expected {typ} at {t.line}:{t.col}, got {t.type!r} ({t.value!r})")
+        return t
+
+    def match(self, *types) -> bool:
+        return self.peek().type in types
+
+    # ── top level ─────────────────────────────────────────────────────────
+
+    def parse(self) -> Program:
+        modules, items = [], []
+        while not self.match('EOF'):
+            if self.match('MODULE'):
+                modules.append(self._parse_module())
+            else:
+                items.append(self._parse_item())
+        if not modules:
+            modules = [Module(name='main', items=items)]
+        return Program(modules=modules)
+
+    def _parse_module(self) -> Module:
+        self.expect('MODULE')
+        name = self.expect('IDENT').value
+        self.expect('LBRACE')
+        items = []
+        while not self.match('RBRACE', 'EOF'):
+            items.append(self._parse_item())
+        self.expect('RBRACE')
+        return Module(name=name, items=items)
+
+    # ── item ──────────────────────────────────────────────────────────────
+
+    def _parse_item(self) -> Node:
+        ann = self._parse_annotations()
+        t = self.peek()
+        if t.type == 'CONST':
+            return self._parse_const(ann)
+        if t.type == 'LET':
+            return self._parse_let(ann)
+        if t.type == 'DEFINE':
+            return self._parse_define(ann)
+        if t.type == 'ASSERT':
+            self.advance()
+            return Assert(expr=self._parse_expr())
+        # expression statement
+        return self._parse_expr()
+
+    def _parse_annotations(self) -> List[Annotation]:
+        ann = []
+        while self.match('ANNOT'):
+            raw = self.advance().value
+            if '(' in raw:
+                name, rest = raw.split('(', 1)
+                ann.append(Annotation(name=name[1:], args=rest.rstrip(')')))
+            else:
+                ann.append(Annotation(name=raw[1:], args=None))
+        return ann
+
+    def _parse_const(self, ann) -> ConstDecl:
+        self.expect('CONST')
+        name = self.expect('IDENT').value
+        self.expect('ASSIGN')
+        val = self._parse_expr()
+        return ConstDecl(name=name, value=val, annotations=ann)
+
+    def _parse_let(self, ann) -> LetDecl:
+        self.expect('LET')
+        name = self.expect('IDENT').value
+        self.expect('ASSIGN')
+        val = self._parse_expr()
+        return LetDecl(name=name, value=val, annotations=ann)
+
+    def _parse_define(self, ann) -> FunctionDecl:
+        self.expect('DEFINE')
+        name = self.expect('IDENT').value
+        self.expect('LPAREN')
+        params = []
+        while not self.match('RPAREN', 'EOF'):
+            params.append(self.expect('IDENT').value)
+            if self.match('COMMA'):
+                self.advance()
+        self.expect('RPAREN')
+        self.expect('BEGIN')
+        body = []
+        while not self.match('END', 'EOF'):
+            if self.match('RETURN'):
+                self.advance()
+                body.append(Return(expr=self._parse_expr()))
+            elif self.match('ASSERT'):
+                self.advance()
+                body.append(Assert(expr=self._parse_expr()))
+            elif self.match('LET'):
+                body.append(self._parse_let([]))
+            elif self.match('CONST'):
+                body.append(self._parse_const([]))
+            else:
+                body.append(self._parse_expr())
+        self.expect('END')
+        return FunctionDecl(name=name, params=params, body=body, annotations=ann)
+
+    # ── expressions (Pratt-style precedence climbing) ─────────────────────
+
+    def _parse_expr(self) -> Node:
+        return self._parse_or()
+
+    def _parse_or(self) -> Node:
+        left = self._parse_and()
+        while self.match('OR', 'PIPE'):
+            op = self.advance().value
+            left = BinaryExpr(op='or', left=left, right=self._parse_and())
+        return left
+
+    def _parse_and(self) -> Node:
+        left = self._parse_equality()
+        while self.match('AND', 'AMP'):
+            op = self.advance().value
+            left = BinaryExpr(op='and', left=left, right=self._parse_equality())
+        return left
+
+    def _parse_equality(self) -> Node:
+        left = self._parse_relational()
+        while self.match('EQ', 'NEQ'):
+            op = self.advance().value
+            left = BinaryExpr(op=op, left=left, right=self._parse_relational())
+        return left
+
+    def _parse_relational(self) -> Node:
+        left = self._parse_shift()
+        while self.match('LT', 'GT', 'LE', 'GE'):
+            op = self.advance().value
+            left = BinaryExpr(op=op, left=left, right=self._parse_shift())
+        return left
+
+    def _parse_shift(self) -> Node:
+        left = self._parse_bitor()
+        while self.match('LSH', 'RSH'):
+            op = self.advance().value
+            left = BinaryExpr(op=op, left=left, right=self._parse_bitor())
+        return left
+
+    def _parse_bitor(self) -> Node:
+        left = self._parse_bitxor()
+        while self.match('PIPE'):
+            self.advance()
+            left = BinaryExpr(op='|', left=left, right=self._parse_bitxor())
+        return left
+
+    def _parse_bitxor(self) -> Node:
+        left = self._parse_bitand()
+        while self.match('CARET'):
+            self.advance()
+            left = BinaryExpr(op='^', left=left, right=self._parse_bitand())
+        return left
+
+    def _parse_bitand(self) -> Node:
+        left = self._parse_add()
+        while self.match('AMP'):
+            self.advance()
+            left = BinaryExpr(op='&', left=left, right=self._parse_add())
+        return left
+
+    def _parse_add(self) -> Node:
+        left = self._parse_mul()
+        while self.match('PLUS', 'MINUS'):
+            op = self.advance().value
+            left = BinaryExpr(op=op, left=left, right=self._parse_mul())
+        return left
+
+    def _parse_mul(self) -> Node:
+        left = self._parse_unary()
+        while self.match('STAR', 'SLASH', 'PERCENT', 'POW'):
+            op = self.advance().value
+            left = BinaryExpr(op=op, left=left, right=self._parse_unary())
+        return left
+
+    def _parse_unary(self) -> Node:
+        if self.match('MINUS', 'TILDE', 'NOT'):
+            op = self.advance().value
+            return UnaryExpr(op=op, operand=self._parse_unary())
+        return self._parse_postfix()
+
+    def _parse_postfix(self) -> Node:
+        node = self._parse_primary()
+        while self.match('DOT'):
+            self.advance()
+            field = self.expect('IDENT').value
+            node = FieldAccess(obj=node, field=field)
+        return node
+
+    def _parse_primary(self) -> Node:
+        t = self.peek()
+
+        if t.type == 'NUMBER':
+            self.advance()
+            return IntegerLiteral(int(t.value))
+
+        if t.type == 'HEX':
+            self.advance()
+            return HexLiteral(raw=t.value)
+
+        if t.type in ('TRUE', 'FALSE'):
+            self.advance()
+            return BoolLiteral(t.type == 'TRUE')
+
+        if t.type == 'STRING':
+            self.advance()
+            s = t.value[1:-1].encode('utf-8').decode('unicode_escape')
+            return StringLiteral(s)
+
+        if t.type == 'BYTES':
+            self.advance()
+            raw = t.value[2:-1]
+            b = raw.encode('utf-8').decode('unicode_escape').encode('latin1')
+            return BytesLiteral(b)
+
+        if t.type == 'SOME':
+            self.advance()
+            self.expect('LPAREN')
+            v = self._parse_expr()
+            self.expect('RPAREN')
+            return OptionLiteral(tag='some', value=v)
+
+        if t.type == 'NONE':
+            self.advance()
+            return OptionLiteral(tag='none', value=None)
+
+        # identifiers and keyword-named builtins (concat, len, slice, sha256_hex, etc.)
+        _CALLABLE_KEYWORDS = {'CONCAT', 'LEN', 'SLICE', 'SOME', 'OK', 'ERR',
+                               'BYTES', 'BYTE', 'OPTION', 'RESULT'}
+        if t.type == 'IDENT' or t.type in _CALLABLE_KEYWORDS:
+            name = self.advance().value
+            if self.match('LPAREN'):
+                self.advance()
+                args = []
+                while not self.match('RPAREN', 'EOF'):
+                    args.append(self._parse_expr())
+                    if self.match('COMMA'):
+                        self.advance()
+                self.expect('RPAREN')
+                return Call(callee=name, args=args)
+            return Identifier(name=name)
+
+        if t.type == 'LPAREN':
+            self.advance()
+            expr = self._parse_expr()
+            self.expect('RPAREN')
+            return expr
+
+        if t.type == 'LBRACE':
+            return self._parse_dict_or_list()
+
+        if t.type == 'LBRACKET':
+            self.advance()
+            items = []
+            while not self.match('RBRACKET', 'EOF'):
+                items.append(self._parse_expr())
+                if self.match('COMMA'):
+                    self.advance()
+            self.expect('RBRACKET')
+            return ListLiteral(items=items)
+
+        raise ParseError(f"Unexpected token {t.type!r} ({t.value!r}) at {t.line}:{t.col}")
+
+    def _parse_dict_or_list(self) -> Node:
+        self.expect('LBRACE')
+        # peek: if next is IDENT COLON → dict
+        if self.peek().type == 'IDENT' and self.peek2().type == 'COLON':
+            pairs = []
+            while not self.match('RBRACE', 'EOF'):
+                key = self.expect('IDENT').value
+                self.expect('COLON')
+                val = self._parse_expr()
+                pairs.append((key, val))
+                if self.match('COMMA'):
+                    self.advance()
+            self.expect('RBRACE')
+            return DictLiteral(pairs=pairs)
+        else:
+            items = []
+            while not self.match('RBRACE', 'EOF'):
+                items.append(self._parse_expr())
+                if self.match('COMMA'):
+                    self.advance()
+            self.expect('RBRACE')
+            return ListLiteral(items=items)
+
+
+def parse(code: str) -> Program:
+    tokens = tokenize(code)
+    return Parser(tokens).parse()