pearc 0.1.0

package/dist/parser.js

@@ -0,0 +1,1047 @@
+"use strict";
+// Pear Language Parser
+// Recursive descent parser producing an AST
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = exports.PEAR_TYPE_MAP = void 0;
+exports.parse = parse;
+const lexer_1 = require("./lexer");
+// ─── Parser ──────────────────────────────────────────────────────────────────
+const TYPE_KEYWORDS = new Set([
+    lexer_1.TokenType.I8, lexer_1.TokenType.I16, lexer_1.TokenType.I32, lexer_1.TokenType.I64,
+    lexer_1.TokenType.U8, lexer_1.TokenType.U16, lexer_1.TokenType.U32, lexer_1.TokenType.U64,
+    lexer_1.TokenType.F32, lexer_1.TokenType.F64,
+    lexer_1.TokenType.V, lexer_1.TokenType.C, lexer_1.TokenType.B, lexer_1.TokenType.SZ,
+]);
+const PEAR_TYPE_MAP = {
+    i8: 'int8_t',
+    i16: 'int16_t',
+    i32: 'int32_t',
+    i64: 'int64_t',
+    u8: 'uint8_t',
+    u16: 'uint16_t',
+    u32: 'uint32_t',
+    u64: 'uint64_t',
+    f32: 'float',
+    f64: 'double',
+    v: 'void',
+    c: 'char',
+    b: 'bool',
+    sz: 'size_t',
+};
+exports.PEAR_TYPE_MAP = PEAR_TYPE_MAP;
+class Parser {
+    constructor(tokens) {
+        this.pos = 0;
+        // Filter newlines for the parser (they're only relevant for preprocessor which we handle specially)
+        this.tokens = tokens.filter(t => t.type !== lexer_1.TokenType.NEWLINE);
+    }
+    peek(offset = 0) {
+        const idx = this.pos + offset;
+        return this.tokens[idx] ?? { type: lexer_1.TokenType.EOF, value: '', line: 0, col: 0 };
+    }
+    advance() {
+        const tok = this.tokens[this.pos];
+        this.pos++;
+        return tok;
+    }
+    check(...types) {
+        return types.includes(this.peek().type);
+    }
+    eat(type) {
+        const tok = this.peek();
+        if (tok.type !== type) {
+            throw new Error(`Expected ${type} but got ${tok.type} ('${tok.value}') at line ${tok.line}:${tok.col}`);
+        }
+        return this.advance();
+    }
+    tryEat(...types) {
+        if (types.includes(this.peek().type))
+            return this.advance();
+        return null;
+    }
+    // Accept any token that can serve as an identifier name
+    // This handles cases like parameter named 'b', 'c', 'v', 'sz', etc.
+    eatIdent() {
+        const tok = this.peek();
+        // Allow IDENT plus any short keyword/type that might be used as a name
+        const identLike = new Set([
+            lexer_1.TokenType.IDENT,
+            lexer_1.TokenType.B, lexer_1.TokenType.C, lexer_1.TokenType.V, lexer_1.TokenType.SZ,
+            lexer_1.TokenType.I8, lexer_1.TokenType.I16, lexer_1.TokenType.I32, lexer_1.TokenType.I64,
+            lexer_1.TokenType.U8, lexer_1.TokenType.U16, lexer_1.TokenType.U32, lexer_1.TokenType.U64,
+            lexer_1.TokenType.F32, lexer_1.TokenType.F64,
+            // Also allow Pear keywords that might appear as identifiers in context
+            lexer_1.TokenType.IN, // 'in' can be a variable name
+        ]);
+        if (identLike.has(tok.type))
+            return this.advance();
+        throw new Error(`Expected identifier but got ${tok.type} ('${tok.value}') at line ${tok.line}:${tok.col}`);
+    }
+    // ─── Type Parsing ──────────────────────────────────────────────────────────
+    parseQualifiers() {
+        let isConst = false, isVolatile = false, isStatic = false, isExtern = false, isInline = false;
+        while (true) {
+            if (this.tryEat(lexer_1.TokenType.CN)) {
+                isConst = true;
+                continue;
+            }
+            if (this.tryEat(lexer_1.TokenType.VL)) {
+                isVolatile = true;
+                continue;
+            }
+            if (this.tryEat(lexer_1.TokenType.SC)) {
+                isStatic = true;
+                continue;
+            }
+            if (this.tryEat(lexer_1.TokenType.EX)) {
+                isExtern = true;
+                continue;
+            }
+            if (this.tryEat(lexer_1.TokenType.IN)) {
+                isInline = true;
+                continue;
+            }
+            break;
+        }
+        return { isConst, isVolatile, isStatic, isExtern, isInline };
+    }
+    parseType() {
+        const quals = this.parseQualifiers();
+        // Additional qualifiers after the first
+        let isConst = quals.isConst;
+        let isVolatile = quals.isVolatile;
+        // Pear supports *T syntax for pointer-to-T (prefix stars)
+        let prefixPointers = 0;
+        while (this.check(lexer_1.TokenType.STAR)) {
+            this.advance();
+            prefixPointers++;
+        }
+        let base = '';
+        if (TYPE_KEYWORDS.has(this.peek().type)) {
+            const tok = this.advance();
+            base = PEAR_TYPE_MAP[tok.value] ?? tok.value;
+        }
+        else if (this.check(lexer_1.TokenType.ST)) {
+            this.advance();
+            const name = this.peek().type === lexer_1.TokenType.IDENT ? this.advance().value : '';
+            base = 'struct ' + name;
+        }
+        else if (this.check(lexer_1.TokenType.UN)) {
+            this.advance();
+            const name = this.peek().type === lexer_1.TokenType.IDENT ? this.advance().value : '';
+            base = 'union ' + name;
+        }
+        else if (this.check(lexer_1.TokenType.EN)) {
+            this.advance();
+            const name = this.peek().type === lexer_1.TokenType.IDENT ? this.advance().value : '';
+            base = 'enum ' + name;
+        }
+        else if (this.check(lexer_1.TokenType.IDENT)) {
+            base = this.advance().value;
+        }
+        else if (prefixPointers > 0) {
+            // e.g. *v means void pointer — base type already consumed
+            throw new Error(`Expected base type after '*' at line ${this.peek().line}:${this.peek().col}, got '${this.peek().value}'`);
+        }
+        else {
+            throw new Error(`Expected type at line ${this.peek().line}:${this.peek().col}, got '${this.peek().value}'`);
+        }
+        // Count trailing pointer levels (C-style, after base type)
+        let pointers = prefixPointers;
+        while (this.check(lexer_1.TokenType.STAR)) {
+            this.advance();
+            pointers++;
+            // const after * applies to pointer
+            if (this.check(lexer_1.TokenType.CN)) {
+                this.advance();
+                isConst = true;
+            }
+        }
+        return {
+            base,
+            pointers,
+            isConst,
+            isVolatile,
+            isStatic: quals.isStatic,
+            isExtern: quals.isExtern,
+            isInline: quals.isInline,
+            arraySize: null,
+        };
+    }
+    // ─── Top Level ─────────────────────────────────────────────────────────────
+    parse() {
+        const body = [];
+        while (!this.check(lexer_1.TokenType.EOF)) {
+            const node = this.parseTopLevel();
+            if (node)
+                body.push(node);
+        }
+        return { kind: 'Program', body };
+    }
+    parseTopLevel() {
+        // Raw preprocessor (from # tokens)
+        if (this.check(lexer_1.TokenType.HASH)) {
+            return { kind: 'RawPreprocessor', text: this.advance().value };
+        }
+        // im <path> or im "path"
+        if (this.check(lexer_1.TokenType.IM)) {
+            return this.parseInclude();
+        }
+        // df NAME value
+        if (this.check(lexer_1.TokenType.DF)) {
+            return this.parseDefine();
+        }
+        // nd NAME (include guard)
+        if (this.check(lexer_1.TokenType.ND)) {
+            this.advance();
+            const name = this.eat(lexer_1.TokenType.IDENT).value;
+            return { kind: 'IncludeGuardStart', name };
+        }
+        // dn (#endif)
+        if (this.check(lexer_1.TokenType.DN)) {
+            this.advance();
+            return { kind: 'IncludeGuardEnd' };
+        }
+        // pr value
+        if (this.check(lexer_1.TokenType.PR)) {
+            this.advance();
+            let val = '';
+            while (!this.check(lexer_1.TokenType.EOF) && !this.check(lexer_1.TokenType.NEWLINE)) {
+                val += this.advance().value + ' ';
+            }
+            return { kind: 'PragmaDirective', value: val.trim() };
+        }
+        // tp (typedef)
+        if (this.check(lexer_1.TokenType.TP)) {
+            return this.parseTypedef();
+        }
+        // st / un / en at top level (struct/union/enum definition)
+        if (this.check(lexer_1.TokenType.ST)) {
+            return this.parseStructDecl(false);
+        }
+        if (this.check(lexer_1.TokenType.UN)) {
+            return this.parseUnionDecl(false);
+        }
+        if (this.check(lexer_1.TokenType.EN)) {
+            return this.parseEnumDecl(false);
+        }
+        // fn (function)
+        if (this.check(lexer_1.TokenType.FN)) {
+            return this.parseFunctionDecl();
+        }
+        // Variable declaration at top level (qualifiers + type + name : type)
+        // or just a type followed by name
+        return this.parseVarOrFuncDecl();
+    }
+    parseInclude() {
+        this.eat(lexer_1.TokenType.IM);
+        // path token was already consumed by the lexer and placed as STRING
+        const pathTok = this.eat(lexer_1.TokenType.STRING);
+        return { kind: 'IncludeDirective', path: pathTok.value };
+    }
+    parseDefine() {
+        this.eat(lexer_1.TokenType.DF);
+        const name = this.advance().value; // macro name
+        let params = null;
+        let body = '';
+        // function-like macro: df NAME(a,b) body
+        if (this.check(lexer_1.TokenType.LPAREN)) {
+            this.advance();
+            params = [];
+            while (!this.check(lexer_1.TokenType.RPAREN) && !this.check(lexer_1.TokenType.EOF)) {
+                if (this.check(lexer_1.TokenType.ELLIPSIS)) {
+                    params.push('...');
+                    this.advance();
+                }
+                else {
+                    params.push(this.advance().value);
+                }
+                this.tryEat(lexer_1.TokenType.COMMA);
+            }
+            this.eat(lexer_1.TokenType.RPAREN);
+        }
+        // rest of line is body
+        // We collect tokens until EOF or newline (but newlines were filtered — collect until semicolon or next keyword that starts a declaration)
+        // Actually define body can be complex; we gather remaining tokens on the "logical line"
+        // Since newlines are filtered, we use a heuristic: collect everything that could be part of an expression
+        const bodyToks = [];
+        // Gather tokens that are likely part of the define body
+        // Stop at top-level declaration starters
+        while (!this.check(lexer_1.TokenType.EOF) &&
+            !this.check(lexer_1.TokenType.FN) &&
+            !this.check(lexer_1.TokenType.ST) &&
+            !this.check(lexer_1.TokenType.UN) &&
+            !this.check(lexer_1.TokenType.EN) &&
+            !this.check(lexer_1.TokenType.TP) &&
+            !this.check(lexer_1.TokenType.IM) &&
+            !this.check(lexer_1.TokenType.DF) &&
+            !this.check(lexer_1.TokenType.ND) &&
+            !this.check(lexer_1.TokenType.DN) &&
+            !this.check(lexer_1.TokenType.PR) &&
+            !this.check(lexer_1.TokenType.HASH)) {
+            bodyToks.push(this.advance());
+        }
+        // Smart join: don't put spaces around punctuation/operators
+        const noSpaceBefore = new Set(['(', ')', '[', ']', ',', ';', '.', '->', '++', '--']);
+        const noSpaceAfter = new Set(['(', '[', '.', '->']);
+        body = bodyToks.map((t, i) => {
+            const prev = bodyToks[i - 1];
+            if (!prev)
+                return t.value;
+            if (noSpaceBefore.has(t.value) || noSpaceAfter.has(prev.value))
+                return t.value;
+            // identifiers and numbers need a space before them
+            if (t.type === lexer_1.TokenType.IDENT || t.type === lexer_1.TokenType.NUMBER ||
+                t.type === lexer_1.TokenType.STRING)
+                return ' ' + t.value;
+            return t.value;
+        }).join('').trim();
+        return { kind: 'DefineDirective', name, params, body };
+    }
+    parseTypedef() {
+        this.eat(lexer_1.TokenType.TP);
+        if (this.check(lexer_1.TokenType.ST)) {
+            const st = this.parseStructDecl(true);
+            return st;
+        }
+        if (this.check(lexer_1.TokenType.UN)) {
+            const un = this.parseUnionDecl(true);
+            return un;
+        }
+        if (this.check(lexer_1.TokenType.EN)) {
+            const en = this.parseEnumDecl(true);
+            return en;
+        }
+        // tp i32 MyInt
+        const type = this.parseType();
+        const alias = this.eat(lexer_1.TokenType.IDENT).value;
+        this.tryEat(lexer_1.TokenType.SEMICOLON);
+        return { kind: 'TypedefDecl', inner: { kind: 'VarDecl', name: '', type, init: null, qualifiers: [] }, alias };
+    }
+    parseStructDecl(isTypedef) {
+        this.eat(lexer_1.TokenType.ST);
+        let name = null;
+        if (this.check(lexer_1.TokenType.IDENT))
+            name = this.advance().value;
+        const fields = [];
+        if (this.check(lexer_1.TokenType.LBRACE)) {
+            this.eat(lexer_1.TokenType.LBRACE);
+            while (!this.check(lexer_1.TokenType.RBRACE) && !this.check(lexer_1.TokenType.EOF)) {
+                fields.push(this.parseFieldDecl());
+                this.tryEat(lexer_1.TokenType.SEMICOLON);
+            }
+            this.eat(lexer_1.TokenType.RBRACE);
+        }
+        let typedefName = null;
+        if (isTypedef) {
+            typedefName = this.eat(lexer_1.TokenType.IDENT).value;
+        }
+        this.tryEat(lexer_1.TokenType.SEMICOLON);
+        return { kind: 'StructDecl', name, fields, isTypedef, typedefName };
+    }
+    parseUnionDecl(isTypedef) {
+        this.eat(lexer_1.TokenType.UN);
+        let name = null;
+        if (this.check(lexer_1.TokenType.IDENT))
+            name = this.advance().value;
+        const fields = [];
+        if (this.check(lexer_1.TokenType.LBRACE)) {
+            this.eat(lexer_1.TokenType.LBRACE);
+            while (!this.check(lexer_1.TokenType.RBRACE) && !this.check(lexer_1.TokenType.EOF)) {
+                fields.push(this.parseFieldDecl());
+                this.tryEat(lexer_1.TokenType.SEMICOLON);
+            }
+            this.eat(lexer_1.TokenType.RBRACE);
+        }
+        let typedefName = null;
+        if (isTypedef)
+            typedefName = this.eat(lexer_1.TokenType.IDENT).value;
+        this.tryEat(lexer_1.TokenType.SEMICOLON);
+        return { kind: 'UnionDecl', name, fields, isTypedef, typedefName };
+    }
+    parseFieldDecl() {
+        const name = this.eatIdent().value;
+        this.eat(lexer_1.TokenType.COLON);
+        const type = this.parseType();
+        // array field
+        if (this.check(lexer_1.TokenType.LBRACKET)) {
+            this.advance();
+            if (!this.check(lexer_1.TokenType.RBRACKET)) {
+                type.arraySize = this.parseExpr();
+            }
+            this.eat(lexer_1.TokenType.RBRACKET);
+        }
+        // bitfield
+        let bitfield;
+        if (this.check(lexer_1.TokenType.COLON)) {
+            this.advance();
+            bitfield = this.parseExpr();
+        }
+        return { name, type, bitfield };
+    }
+    parseEnumDecl(isTypedef) {
+        this.eat(lexer_1.TokenType.EN);
+        let name = null;
+        if (this.check(lexer_1.TokenType.IDENT))
+            name = this.advance().value;
+        const members = [];
+        if (this.check(lexer_1.TokenType.LBRACE)) {
+            this.eat(lexer_1.TokenType.LBRACE);
+            while (!this.check(lexer_1.TokenType.RBRACE) && !this.check(lexer_1.TokenType.EOF)) {
+                const mname = this.advance().value;
+                let value = null;
+                if (this.tryEat(lexer_1.TokenType.ASSIGN)) {
+                    value = this.parseExpr();
+                }
+                members.push({ name: mname, value });
+                if (!this.tryEat(lexer_1.TokenType.COMMA))
+                    break;
+            }
+            this.eat(lexer_1.TokenType.RBRACE);
+        }
+        let typedefName = null;
+        if (isTypedef)
+            typedefName = this.eat(lexer_1.TokenType.IDENT).value;
+        this.tryEat(lexer_1.TokenType.SEMICOLON);
+        return { kind: 'EnumDecl', name, members, isTypedef, typedefName };
+    }
+    parseFunctionDecl() {
+        this.eat(lexer_1.TokenType.FN);
+        const name = this.eat(lexer_1.TokenType.IDENT).value;
+        this.eat(lexer_1.TokenType.LPAREN);
+        const params = [];
+        while (!this.check(lexer_1.TokenType.RPAREN) && !this.check(lexer_1.TokenType.EOF)) {
+            if (this.check(lexer_1.TokenType.ELLIPSIS)) {
+                params.push({ name: '...', type: { base: '', pointers: 0, isConst: false, isVolatile: false, isStatic: false, isExtern: false, isInline: false, arraySize: null }, isVararg: true });
+                this.advance();
+                break;
+            }
+            const pname = this.eatIdent().value;
+            this.eat(lexer_1.TokenType.COLON);
+            const ptype = this.parseType();
+            // array param
+            if (this.check(lexer_1.TokenType.LBRACKET)) {
+                this.advance();
+                if (!this.check(lexer_1.TokenType.RBRACKET))
+                    ptype.arraySize = this.parseExpr();
+                this.eat(lexer_1.TokenType.RBRACKET);
+                ptype.pointers = Math.max(ptype.pointers, 1);
+            }
+            params.push({ name: pname, type: ptype });
+            if (!this.tryEat(lexer_1.TokenType.COMMA))
+                break;
+        }
+        this.eat(lexer_1.TokenType.RPAREN);
+        let returnType = { base: 'void', pointers: 0, isConst: false, isVolatile: false, isStatic: false, isExtern: false, isInline: false, arraySize: null };
+        // Optional return type
+        if (this.check(lexer_1.TokenType.ARROW)) {
+            this.advance();
+            returnType = this.parseType();
+        }
+        // Body or semicolon (forward decl)
+        let body = null;
+        if (this.check(lexer_1.TokenType.LBRACE)) {
+            body = this.parseBlock();
+        }
+        else {
+            this.tryEat(lexer_1.TokenType.SEMICOLON);
+        }
+        return { kind: 'FunctionDecl', name, params, returnType, body, qualifiers: [] };
+    }
+    parseVarOrFuncDecl() {
+        // Handle qualifiers
+        const qualifiers = [];
+        while (this.check(lexer_1.TokenType.SC, lexer_1.TokenType.EX, lexer_1.TokenType.IN, lexer_1.TokenType.CN, lexer_1.TokenType.VL)) {
+            qualifiers.push(this.advance().value);
+        }
+        // name:type[=init] or just type-based declarations
+        // In Pear, declarations are: name:type[=init]
+        // But we might also have identifiers being used as statements
+        if (this.isIdentLike(this.peek()) && this.peek(1).type === lexer_1.TokenType.COLON) {
+            return this.parseVarDecl(qualifiers);
+        }
+        // Expression statement
+        const expr = this.parseExpr();
+        this.tryEat(lexer_1.TokenType.SEMICOLON);
+        return { kind: 'ExprStmt', expr };
+    }
+    parseVarDecl(qualifiers = []) {
+        const name = this.eatIdent().value;
+        this.eat(lexer_1.TokenType.COLON);
+        const type = this.parseType();
+        // Array declaration: name:type[size]
+        if (this.check(lexer_1.TokenType.LBRACKET)) {
+            this.advance();
+            if (!this.check(lexer_1.TokenType.RBRACKET)) {
+                type.arraySize = this.parseExpr();
+            }
+            this.eat(lexer_1.TokenType.RBRACKET);
+        }
+        let init = null;
+        if (this.tryEat(lexer_1.TokenType.ASSIGN)) {
+            if (this.check(lexer_1.TokenType.LBRACE)) {
+                init = this.parseInitList();
+            }
+            else {
+                init = this.parseExpr();
+            }
+        }
+        this.tryEat(lexer_1.TokenType.SEMICOLON);
+        return { kind: 'VarDecl', name, type, init, qualifiers };
+    }
+    // ─── Statements ────────────────────────────────────────────────────────────
+    parseStatement() {
+        if (this.check(lexer_1.TokenType.HASH)) {
+            return { kind: 'RawPreprocessor', text: this.advance().value };
+        }
+        if (this.check(lexer_1.TokenType.LBRACE))
+            return this.parseBlock();
+        if (this.check(lexer_1.TokenType.IF))
+            return this.parseIf();
+        if (this.check(lexer_1.TokenType.LP))
+            return this.parseFor();
+        if (this.check(lexer_1.TokenType.WH))
+            return this.parseWhile();
+        if (this.check(lexer_1.TokenType.DW))
+            return this.parseDoWhile();
+        if (this.check(lexer_1.TokenType.SW))
+            return this.parseSwitch();
+        if (this.check(lexer_1.TokenType.RT))
+            return this.parseReturn();
+        if (this.check(lexer_1.TokenType.BK)) {
+            this.advance();
+            this.tryEat(lexer_1.TokenType.SEMICOLON);
+            return { kind: 'BreakStmt' };
+        }
+        if (this.check(lexer_1.TokenType.CT)) {
+            this.advance();
+            this.tryEat(lexer_1.TokenType.SEMICOLON);
+            return { kind: 'ContinueStmt' };
+        }
+        if (this.check(lexer_1.TokenType.GT))
+            return this.parseGoto();
+        if (this.check(lexer_1.TokenType.ST))
+            return this.parseStructDecl(false);
+        if (this.check(lexer_1.TokenType.UN))
+            return this.parseUnionDecl(false);
+        if (this.check(lexer_1.TokenType.EN))
+            return this.parseEnumDecl(false);
+        if (this.check(lexer_1.TokenType.TP))
+            return this.parseTypedef();
+        if (this.check(lexer_1.TokenType.DF))
+            return this.parseDefine();
+        if (this.check(lexer_1.TokenType.IM))
+            return this.parseInclude();
+        if (this.check(lexer_1.TokenType.ND)) {
+            this.advance();
+            const name = this.eat(lexer_1.TokenType.IDENT).value;
+            return { kind: 'IncludeGuardStart', name };
+        }
+        if (this.check(lexer_1.TokenType.DN)) {
+            this.advance();
+            return { kind: 'IncludeGuardEnd' };
+        }
+        // Qualifiers
+        if (this.check(lexer_1.TokenType.SC, lexer_1.TokenType.EX, lexer_1.TokenType.IN, lexer_1.TokenType.VL)) {
+            return this.parseVarOrFuncDecl();
+        }
+        // cn might be a qualifier or part of something else
+        if (this.check(lexer_1.TokenType.CN)) {
+            return this.parseVarOrFuncDecl();
+        }
+        // var decl: name:type
+        // name can be IDENT or a short keyword used as identifier (b, c, v, sz, i32, etc.)
+        if (this.isIdentLike(this.peek()) && this.peek(1).type === lexer_1.TokenType.COLON) {
+            // Determine if this is a label or a variable declaration.
+            // It's a label only if:
+            //   1. The token is a plain IDENT (not a type keyword)
+            //   2. After the colon there's NO type (no type keyword, no IDENT, no STAR)
+            //   3. After the colon is a statement keyword or structural token
+            const afterColon = this.peek(2);
+            const isLabel = this.check(lexer_1.TokenType.IDENT) &&
+                !this.isTypeToken(afterColon) &&
+                !this.isTypeStartToken(afterColon) &&
+                afterColon.type !== lexer_1.TokenType.STAR &&
+                afterColon.type !== lexer_1.TokenType.IDENT; // IDENT after colon = typedef'd type name → var decl
+            if (isLabel) {
+                const label = this.advance().value;
+                this.advance(); // colon
+                const body = this.parseStatement();
+                return { kind: 'LabelStmt', label, body };
+            }
+            return this.parseVarDecl();
+        }
+        // cs (case)
+        if (this.check(lexer_1.TokenType.CS)) {
+            this.advance();
+            const val = this.parseExpr();
+            this.eat(lexer_1.TokenType.COLON);
+            const body = [];
+            while (!this.check(lexer_1.TokenType.CS) && !this.check(lexer_1.TokenType.DV) && !this.check(lexer_1.TokenType.RBRACE) && !this.check(lexer_1.TokenType.EOF)) {
+                body.push(this.parseStatement());
+            }
+            return { kind: 'CaseStmt', value: val, body };
+        }
+        // dv (default)
+        if (this.check(lexer_1.TokenType.DV)) {
+            this.advance();
+            this.eat(lexer_1.TokenType.COLON);
+            const body = [];
+            while (!this.check(lexer_1.TokenType.CS) && !this.check(lexer_1.TokenType.RBRACE) && !this.check(lexer_1.TokenType.EOF)) {
+                body.push(this.parseStatement());
+            }
+            return { kind: 'DefaultStmt', body };
+        }
+        // expression statement
+        const expr = this.parseExpr();
+        this.tryEat(lexer_1.TokenType.SEMICOLON);
+        return { kind: 'ExprStmt', expr };
+    }
+    isIdentLike(tok) {
+        return tok.type === lexer_1.TokenType.IDENT ||
+            tok.type === lexer_1.TokenType.B || tok.type === lexer_1.TokenType.C ||
+            tok.type === lexer_1.TokenType.V || tok.type === lexer_1.TokenType.SZ ||
+            tok.type === lexer_1.TokenType.I8 || tok.type === lexer_1.TokenType.I16 ||
+            tok.type === lexer_1.TokenType.I32 || tok.type === lexer_1.TokenType.I64 ||
+            tok.type === lexer_1.TokenType.U8 || tok.type === lexer_1.TokenType.U16 ||
+            tok.type === lexer_1.TokenType.U32 || tok.type === lexer_1.TokenType.U64 ||
+            tok.type === lexer_1.TokenType.F32 || tok.type === lexer_1.TokenType.F64 ||
+            tok.type === lexer_1.TokenType.IN;
+    }
+    isTypeToken(tok) {
+        return TYPE_KEYWORDS.has(tok.type) || tok.type === lexer_1.TokenType.ST || tok.type === lexer_1.TokenType.UN || tok.type === lexer_1.TokenType.EN;
+    }
+    isTypeStartToken(tok) {
+        if (this.isTypeToken(tok))
+            return true;
+        if (tok.type === lexer_1.TokenType.CN || tok.type === lexer_1.TokenType.VL ||
+            tok.type === lexer_1.TokenType.SC || tok.type === lexer_1.TokenType.EX ||
+            tok.type === lexer_1.TokenType.IN)
+            return true;
+        // Could also be a typedef'd name (IDENT) — assume it is if followed by reasonable stuff
+        return false;
+    }
+    parseBlock() {
+        this.eat(lexer_1.TokenType.LBRACE);
+        const body = [];
+        while (!this.check(lexer_1.TokenType.RBRACE) && !this.check(lexer_1.TokenType.EOF)) {
+            body.push(this.parseStatement());
+        }
+        this.eat(lexer_1.TokenType.RBRACE);
+        return { kind: 'BlockStmt', body };
+    }
+    parseIf() {
+        this.eat(lexer_1.TokenType.IF);
+        this.eat(lexer_1.TokenType.LPAREN);
+        const condition = this.parseExpr();
+        this.eat(lexer_1.TokenType.RPAREN);
+        const consequent = this.parseStatement();
+        let alternate = null;
+        if (this.check(lexer_1.TokenType.EI)) {
+            this.advance();
+            this.eat(lexer_1.TokenType.LPAREN);
+            const eicond = this.parseExpr();
+            this.eat(lexer_1.TokenType.RPAREN);
+            const eibody = this.parseStatement();
+            alternate = { kind: 'IfStmt', condition: eicond, consequent: eibody, alternate: null };
+            // chain else-ifs
+            let cur = alternate;
+            while (this.check(lexer_1.TokenType.EI)) {
+                this.advance();
+                this.eat(lexer_1.TokenType.LPAREN);
+                const c2 = this.parseExpr();
+                this.eat(lexer_1.TokenType.RPAREN);
+                const b2 = this.parseStatement();
+                const next = { kind: 'IfStmt', condition: c2, consequent: b2, alternate: null };
+                cur.alternate = next;
+                cur = next;
+            }
+            if (this.check(lexer_1.TokenType.EL)) {
+                this.advance();
+                cur.alternate = this.parseStatement();
+            }
+        }
+        else if (this.check(lexer_1.TokenType.EL)) {
+            this.advance();
+            alternate = this.parseStatement();
+        }
+        return { kind: 'IfStmt', condition, consequent, alternate };
+    }
+    parseFor() {
+        this.eat(lexer_1.TokenType.LP);
+        this.eat(lexer_1.TokenType.LPAREN);
+        let init = null;
+        if (!this.check(lexer_1.TokenType.SEMICOLON)) {
+            if (this.isIdentLike(this.peek()) && this.peek(1).type === lexer_1.TokenType.COLON) {
+                // var decl without trailing semicolon eaten
+                const name = this.advance().value;
+                this.advance(); // colon
+                const type = this.parseType();
+                let initExpr = null;
+                if (this.tryEat(lexer_1.TokenType.ASSIGN)) {
+                    initExpr = this.parseExpr();
+                }
+                init = { kind: 'VarDecl', name, type, init: initExpr, qualifiers: [] };
+            }
+            else {
+                const expr = this.parseExpr();
+                init = { kind: 'ExprStmt', expr };
+            }
+        }
+        this.eat(lexer_1.TokenType.SEMICOLON);
+        let condition = null;
+        if (!this.check(lexer_1.TokenType.SEMICOLON)) {
+            condition = this.parseExpr();
+        }
+        this.eat(lexer_1.TokenType.SEMICOLON);
+        let update = null;
+        if (!this.check(lexer_1.TokenType.RPAREN)) {
+            update = this.parseExpr();
+        }
+        this.eat(lexer_1.TokenType.RPAREN);
+        const body = this.parseStatement();
+        return { kind: 'ForStmt', init, condition, update, body };
+    }
+    parseWhile() {
+        this.eat(lexer_1.TokenType.WH);
+        this.eat(lexer_1.TokenType.LPAREN);
+        const condition = this.parseExpr();
+        this.eat(lexer_1.TokenType.RPAREN);
+        const body = this.parseStatement();
+        return { kind: 'WhileStmt', condition, body };
+    }
+    parseDoWhile() {
+        this.eat(lexer_1.TokenType.DW);
+        const body = this.parseStatement();
+        this.eat(lexer_1.TokenType.WH);
+        this.eat(lexer_1.TokenType.LPAREN);
+        const condition = this.parseExpr();
+        this.eat(lexer_1.TokenType.RPAREN);
+        this.tryEat(lexer_1.TokenType.SEMICOLON);
+        return { kind: 'DoWhileStmt', body, condition };
+    }
+    parseSwitch() {
+        this.eat(lexer_1.TokenType.SW);
+        this.eat(lexer_1.TokenType.LPAREN);
+        const expr = this.parseExpr();
+        this.eat(lexer_1.TokenType.RPAREN);
+        const body = this.parseBlock();
+        return { kind: 'SwitchStmt', expr, body };
+    }
+    parseReturn() {
+        this.eat(lexer_1.TokenType.RT);
+        let value = null;
+        if (!this.check(lexer_1.TokenType.SEMICOLON) && !this.check(lexer_1.TokenType.RBRACE) && !this.check(lexer_1.TokenType.EOF)) {
+            value = this.parseExpr();
+        }
+        this.tryEat(lexer_1.TokenType.SEMICOLON);
+        return { kind: 'ReturnStmt', value };
+    }
+    parseGoto() {
+        this.eat(lexer_1.TokenType.GT);
+        const label = this.eat(lexer_1.TokenType.IDENT).value;
+        this.tryEat(lexer_1.TokenType.SEMICOLON);
+        return { kind: 'GotoStmt', label };
+    }
+    parseInitList() {
+        this.eat(lexer_1.TokenType.LBRACE);
+        const elements = [];
+        while (!this.check(lexer_1.TokenType.RBRACE) && !this.check(lexer_1.TokenType.EOF)) {
+            if (this.check(lexer_1.TokenType.LBRACE)) {
+                elements.push(this.parseInitList());
+            }
+            else {
+                elements.push(this.parseExpr());
+            }
+            if (!this.tryEat(lexer_1.TokenType.COMMA))
+                break;
+        }
+        this.eat(lexer_1.TokenType.RBRACE);
+        return { kind: 'InitListExpr', elements };
+    }
+    // ─── Expression Parsing (Pratt-style) ──────────────────────────────────────
+    parseExpr(minPrec = 0) {
+        return this.parseAssignment();
+    }
+    parseAssignment() {
+        const left = this.parseTernary();
+        const assignOps = [
+            lexer_1.TokenType.ASSIGN, lexer_1.TokenType.PLUS_ASSIGN, lexer_1.TokenType.MINUS_ASSIGN,
+            lexer_1.TokenType.STAR_ASSIGN, lexer_1.TokenType.SLASH_ASSIGN, lexer_1.TokenType.PERCENT_ASSIGN,
+            lexer_1.TokenType.AMP_ASSIGN, lexer_1.TokenType.PIPE_ASSIGN, lexer_1.TokenType.CARET_ASSIGN,
+            lexer_1.TokenType.LSHIFT_ASSIGN, lexer_1.TokenType.RSHIFT_ASSIGN,
+        ];
+        if (assignOps.includes(this.peek().type)) {
+            const op = this.advance().value;
+            const right = this.parseAssignment();
+            return { kind: 'AssignExpr', op, left, right };
+        }
+        return left;
+    }
+    parseTernary() {
+        const cond = this.parseOr();
+        if (this.tryEat(lexer_1.TokenType.QUESTION)) {
+            const consequent = this.parseExpr();
+            this.eat(lexer_1.TokenType.COLON);
+            const alternate = this.parseTernary();
+            return { kind: 'TernaryExpr', condition: cond, consequent, alternate };
+        }
+        return cond;
+    }
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.check(lexer_1.TokenType.OR)) {
+            const op = this.advance().value;
+            left = { kind: 'BinaryExpr', op, left, right: this.parseAnd() };
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseBitOr();
+        while (this.check(lexer_1.TokenType.AND)) {
+            const op = this.advance().value;
+            left = { kind: 'BinaryExpr', op, left, right: this.parseBitOr() };
+        }
+        return left;
+    }
+    parseBitOr() {
+        let left = this.parseBitXor();
+        while (this.check(lexer_1.TokenType.PIPE)) {
+            const op = this.advance().value;
+            left = { kind: 'BinaryExpr', op, left, right: this.parseBitXor() };
+        }
+        return left;
+    }
+    parseBitXor() {
+        let left = this.parseBitAnd();
+        while (this.check(lexer_1.TokenType.CARET)) {
+            const op = this.advance().value;
+            left = { kind: 'BinaryExpr', op, left, right: this.parseBitAnd() };
+        }
+        return left;
+    }
+    parseBitAnd() {
+        let left = this.parseEquality();
+        while (this.check(lexer_1.TokenType.AMP)) {
+            const op = this.advance().value;
+            left = { kind: 'BinaryExpr', op, left, right: this.parseEquality() };
+        }
+        return left;
+    }
+    parseEquality() {
+        let left = this.parseRelational();
+        while (this.check(lexer_1.TokenType.EQ) || this.check(lexer_1.TokenType.NEQ)) {
+            const op = this.advance().value;
+            left = { kind: 'BinaryExpr', op, left, right: this.parseRelational() };
+        }
+        return left;
+    }
+    parseRelational() {
+        let left = this.parseShift();
+        while (this.check(lexer_1.TokenType.LT) || this.check(lexer_1.TokenType.GT_OP) || this.check(lexer_1.TokenType.LTE) || this.check(lexer_1.TokenType.GTE)) {
+            const op = this.advance().value;
+            left = { kind: 'BinaryExpr', op, left, right: this.parseShift() };
+        }
+        return left;
+    }
+    parseShift() {
+        let left = this.parseAddSub();
+        while (this.check(lexer_1.TokenType.LSHIFT) || this.check(lexer_1.TokenType.RSHIFT)) {
+            const op = this.advance().value;
+            left = { kind: 'BinaryExpr', op, left, right: this.parseAddSub() };
+        }
+        return left;
+    }
+    parseAddSub() {
+        let left = this.parseMulDiv();
+        while (this.check(lexer_1.TokenType.PLUS) || this.check(lexer_1.TokenType.MINUS)) {
+            const op = this.advance().value;
+            left = { kind: 'BinaryExpr', op, left, right: this.parseMulDiv() };
+        }
+        return left;
+    }
+    parseMulDiv() {
+        let left = this.parseUnary();
+        while (this.check(lexer_1.TokenType.STAR) || this.check(lexer_1.TokenType.SLASH) || this.check(lexer_1.TokenType.PERCENT)) {
+            const op = this.advance().value;
+            left = { kind: 'BinaryExpr', op, left, right: this.parseUnary() };
+        }
+        return left;
+    }
+    parseUnary() {
+        // Prefix operators
+        if (this.check(lexer_1.TokenType.MINUS)) {
+            this.advance();
+            return { kind: 'UnaryExpr', op: '-', operand: this.parseUnary(), prefix: true };
+        }
+        if (this.check(lexer_1.TokenType.NOT)) {
+            this.advance();
+            return { kind: 'UnaryExpr', op: '!', operand: this.parseUnary(), prefix: true };
+        }
+        if (this.check(lexer_1.TokenType.TILDE)) {
+            this.advance();
+            return { kind: 'UnaryExpr', op: '~', operand: this.parseUnary(), prefix: true };
+        }
+        if (this.check(lexer_1.TokenType.INC)) {
+            this.advance();
+            return { kind: 'UnaryExpr', op: '++', operand: this.parseUnary(), prefix: true };
+        }
+        if (this.check(lexer_1.TokenType.DEC)) {
+            this.advance();
+            return { kind: 'UnaryExpr', op: '--', operand: this.parseUnary(), prefix: true };
+        }
+        // Address-of & and dereference *
+        if (this.check(lexer_1.TokenType.AMP)) {
+            this.advance();
+            return { kind: 'UnaryExpr', op: '&', operand: this.parseUnary(), prefix: true };
+        }
+        if (this.check(lexer_1.TokenType.STAR)) {
+            this.advance();
+            return { kind: 'UnaryExpr', op: '*', operand: this.parseUnary(), prefix: true };
+        }
+        if (this.check(lexer_1.TokenType.PLUS)) {
+            this.advance();
+            return { kind: 'UnaryExpr', op: '+', operand: this.parseUnary(), prefix: true };
+        }
+        // sizeof
+        if (this.check(lexer_1.TokenType.SO)) {
+            this.advance();
+            this.eat(lexer_1.TokenType.LPAREN);
+            // Check if it's a type or expression
+            if (this.isTypeStartToken(this.peek()) || TYPE_KEYWORDS.has(this.peek().type)) {
+                const t = this.parseType();
+                this.eat(lexer_1.TokenType.RPAREN);
+                return { kind: 'SizeofExpr', operand: t, isType: true };
+            }
+            const expr = this.parseExpr();
+            this.eat(lexer_1.TokenType.RPAREN);
+            return { kind: 'SizeofExpr', operand: expr, isType: false };
+        }
+        return this.parsePostfix();
+    }
+    parsePostfix() {
+        let expr = this.parsePrimary();
+        while (true) {
+            if (this.check(lexer_1.TokenType.INC)) {
+                this.advance();
+                expr = { kind: 'PostfixExpr', op: '++', operand: expr };
+                continue;
+            }
+            if (this.check(lexer_1.TokenType.DEC)) {
+                this.advance();
+                expr = { kind: 'PostfixExpr', op: '--', operand: expr };
+                continue;
+            }
+            if (this.check(lexer_1.TokenType.LBRACKET)) {
+                this.advance();
+                const idx = this.parseExpr();
+                this.eat(lexer_1.TokenType.RBRACKET);
+                expr = { kind: 'IndexExpr', object: expr, index: idx };
+                continue;
+            }
+            if (this.check(lexer_1.TokenType.LPAREN)) {
+                this.advance();
+                const args = [];
+                while (!this.check(lexer_1.TokenType.RPAREN) && !this.check(lexer_1.TokenType.EOF)) {
+                    args.push(this.parseExpr());
+                    if (!this.tryEat(lexer_1.TokenType.COMMA))
+                        break;
+                }
+                this.eat(lexer_1.TokenType.RPAREN);
+                expr = { kind: 'CallExpr', callee: expr, args };
+                continue;
+            }
+            if (this.check(lexer_1.TokenType.DOT)) {
+                this.advance();
+                const member = this.advance().value;
+                expr = { kind: 'MemberExpr', object: expr, member, arrow: false };
+                continue;
+            }
+            if (this.check(lexer_1.TokenType.ARROW)) {
+                this.advance();
+                const member = this.advance().value;
+                expr = { kind: 'MemberExpr', object: expr, member, arrow: true };
+                continue;
+            }
+            break;
+        }
+        return expr;
+    }
+    parsePrimary() {
+        const tok = this.peek();
+        if (tok.type === lexer_1.TokenType.NUMBER) {
+            this.advance();
+            return { kind: 'NumberLiteral', value: tok.value };
+        }
+        if (tok.type === lexer_1.TokenType.STRING) {
+            this.advance();
+            // Handle adjacent string literal concatenation
+            let val = tok.value;
+            while (this.check(lexer_1.TokenType.STRING)) {
+                val = val.slice(0, -1) + this.advance().value.slice(1);
+            }
+            return { kind: 'StringLiteral', value: val };
+        }
+        if (tok.type === lexer_1.TokenType.CHAR) {
+            this.advance();
+            return { kind: 'CharLiteral', value: tok.value };
+        }
+        // Parenthesized expression or cast
+        if (tok.type === lexer_1.TokenType.LPAREN) {
+            this.advance();
+            // Check for cast: (type)expr
+            if (this.isTypeStartToken(this.peek()) || TYPE_KEYWORDS.has(this.peek().type)) {
+                // Could be cast or just grouped expr
+                const savedPos = this.pos;
+                try {
+                    const type = this.parseType();
+                    if (this.check(lexer_1.TokenType.RPAREN)) {
+                        this.advance();
+                        // Check it's followed by something that can be an expression
+                        if (!this.check(lexer_1.TokenType.SEMICOLON) && !this.check(lexer_1.TokenType.COMMA) &&
+                            !this.check(lexer_1.TokenType.RPAREN) && !this.check(lexer_1.TokenType.RBRACKET) &&
+                            !this.check(lexer_1.TokenType.EOF)) {
+                            const expr = this.parseUnary();
+                            return { kind: 'CastExpr', targetType: type, expr };
+                        }
+                    }
+                }
+                catch {
+                    // not a cast
+                }
+                this.pos = savedPos;
+            }
+            const expr = this.parseExpr();
+            this.eat(lexer_1.TokenType.RPAREN);
+            return expr;
+        }
+        // Identifiers (including keywords used as identifiers in context)
+        if (tok.type === lexer_1.TokenType.IDENT ||
+            tok.type === lexer_1.TokenType.B || // 'b' as a type used in expression context might just be an identifier
+            tok.type === lexer_1.TokenType.C ||
+            tok.type === lexer_1.TokenType.V) {
+            this.advance();
+            if (tok.value === 'NULL')
+                return { kind: 'NullLiteral' };
+            if (tok.value === 'true')
+                return { kind: 'BoolLiteral', value: true };
+            if (tok.value === 'false')
+                return { kind: 'BoolLiteral', value: false };
+            return { kind: 'Identifier', name: tok.value };
+        }
+        // Any keyword that might be used as an identifier
+        if (tok.type !== lexer_1.TokenType.EOF) {
+            this.advance();
+            return { kind: 'Identifier', name: tok.value };
+        }
+        throw new Error(`Unexpected token '${tok.value}' (${tok.type}) at line ${tok.line}:${tok.col}`);
+    }
+}
+exports.Parser = Parser;
+function parse(source) {
+    const lexer = new lexer_1.Lexer(source);
+    const tokens = lexer.tokenize();
+    const parser = new Parser(tokens);
+    return parser.parse();
+}
+//# sourceMappingURL=parser.js.map