redscript-mc 2.0.0 → 2.1.1

package/dist/__tests__/parser.test.js

@@ -1,807 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const lexer_1 = require("../lexer");
-const parser_1 = require("../parser");
-function parse(source, namespace = 'test') {
-    const tokens = new lexer_1.Lexer(source).tokenize();
-    return new parser_1.Parser(tokens).parse(namespace);
-}
-function parseExpr(source) {
-    const program = parse(`fn _test() { ${source}; }`);
-    const stmt = program.declarations[0].body[0];
-    if (stmt.kind !== 'expr')
-        throw new Error('Expected expr stmt');
-    return stmt.expr;
-}
-function parseStmt(source) {
-    const program = parse(`fn _test() { ${source} }`);
-    return program.declarations[0].body[0];
-}
-describe('Parser', () => {
-    describe('program structure', () => {
-        it('parses empty program', () => {
-            const program = parse('');
-            expect(program.namespace).toBe('test');
-            expect(program.declarations).toEqual([]);
-            expect(program.implBlocks).toEqual([]);
-            expect(program.enums).toEqual([]);
-            expect(program.consts).toEqual([]);
-        });
-        it('parses namespace declaration', () => {
-            const program = parse('namespace mypack;', 'default');
-            expect(program.namespace).toBe('mypack');
-        });
-        it('parses function declaration', () => {
-            const program = parse('fn foo() {}');
-            expect(program.declarations).toHaveLength(1);
-            expect(program.declarations[0].name).toBe('foo');
-        });
-        it('parses top-level const declarations', () => {
-            const program = parse('const MAX_HP: int = 100\nconst NAME: string = "Arena"');
-            expect(program.consts).toEqual([
-                { name: 'MAX_HP', type: { kind: 'named', name: 'int' }, value: { kind: 'int_lit', value: 100 } },
-                { name: 'NAME', type: { kind: 'named', name: 'string' }, value: { kind: 'str_lit', value: 'Arena' } },
-            ]);
-        });
-    });
-    describe('function declarations', () => {
-        it('parses function with no params', () => {
-            const program = parse('fn hello() {}');
-            const fn = program.declarations[0];
-            expect(fn.name).toBe('hello');
-            expect(fn.params).toEqual([]);
-            expect(fn.returnType).toEqual({ kind: 'named', name: 'void' });
-        });
-        it('parses function with params', () => {
-            const program = parse('fn add(a: int, b: int) -> int { return a + b; }');
-            const fn = program.declarations[0];
-            expect(fn.name).toBe('add');
-            expect(fn.params).toEqual([
-                { name: 'a', type: { kind: 'named', name: 'int' }, default: undefined },
-                { name: 'b', type: { kind: 'named', name: 'int' }, default: undefined },
-            ]);
-            expect(fn.returnType).toEqual({ kind: 'named', name: 'int' });
-        });
-        it('parses function params with defaults', () => {
-            const program = parse('fn greet(name: string, formal: bool = false) {}');
-            expect(program.declarations[0].params).toEqual([
-                { name: 'name', type: { kind: 'named', name: 'string' }, default: undefined },
-                { name: 'formal', type: { kind: 'named', name: 'bool' }, default: { kind: 'bool_lit', value: false } },
-            ]);
-        });
-        it('parses function with decorators', () => {
-            const program = parse('@tick\nfn game_loop() {}');
-            const fn = program.declarations[0];
-            expect(fn.decorators).toEqual([{ name: 'tick' }]);
-        });
-        it('parses decorator with args', () => {
-            const program = parse('@tick(rate=20)\nfn slow_loop() {}');
-            const fn = program.declarations[0];
-            expect(fn.decorators).toEqual([{ name: 'tick', args: { rate: 20 } }]);
-        });
-        it('parses multiple decorators', () => {
-            const program = parse('@tick\n@on_trigger\nfn both() {}');
-            const fn = program.declarations[0];
-            expect(fn.decorators).toHaveLength(2);
-        });
-        it('parses advancement and death decorators', () => {
-            const program = parse('@on_advancement("story/mine_diamond")\n@on_death\nfn handler() {}');
-            expect(program.declarations[0].decorators).toEqual([
-                { name: 'on_advancement', args: { advancement: 'story/mine_diamond' } },
-                { name: 'on_death' },
-            ]);
-        });
-        it('parses @on event decorators', () => {
-            const program = parse('@on(PlayerDeath)\nfn handle_death(player: Player) {}');
-            expect(program.declarations[0].decorators).toEqual([
-                { name: 'on', args: { eventType: 'PlayerDeath' } },
-            ]);
-        });
-    });
-    describe('types', () => {
-        it('parses primitive types', () => {
-            const program = parse('fn f(a: int, b: bool, c: float, d: string) {}');
-            const params = program.declarations[0].params;
-            expect(params.map(p => p.type)).toEqual([
-                { kind: 'named', name: 'int' },
-                { kind: 'named', name: 'bool' },
-                { kind: 'named', name: 'float' },
-                { kind: 'named', name: 'string' },
-            ]);
-        });
-        it('parses array types', () => {
-            const program = parse('fn f(a: int[]) {}');
-            const param = program.declarations[0].params[0];
-            expect(param.type).toEqual({ kind: 'array', elem: { kind: 'named', name: 'int' } });
-        });
-        it('parses BlockPos types', () => {
-            const program = parse('fn f(pos: BlockPos) {}');
-            const param = program.declarations[0].params[0];
-            expect(param.type).toEqual({ kind: 'named', name: 'BlockPos' });
-        });
-        it('parses function types', () => {
-            const program = parse('fn apply(val: int, cb: (int) -> int) -> int { return cb(val); }');
-            expect(program.declarations[0].params[1].type).toEqual({
-                kind: 'function_type',
-                params: [{ kind: 'named', name: 'int' }],
-                return: { kind: 'named', name: 'int' },
-            });
-        });
-        it('parses enum declarations', () => {
-            const program = parse('enum Direction { North, South = 3, East, West }');
-            expect(program.enums).toEqual([
-                {
-                    name: 'Direction',
-                    variants: [
-                        { name: 'North', value: 0 },
-                        { name: 'South', value: 3 },
-                        { name: 'East', value: 4 },
-                        { name: 'West', value: 5 },
-                    ],
-                },
-            ]);
-        });
-        it('parses impl blocks', () => {
-            const program = parse(`
-struct Timer { duration: int }
-
-impl Timer {
-  fn new(duration: int): Timer {
-    return { duration: duration };
-  }
-
-  fn start(self) {}
-}
-`);
-            expect(program.implBlocks).toHaveLength(1);
-            expect(program.implBlocks[0].typeName).toBe('Timer');
-            expect(program.implBlocks[0].methods.map(method => method.name)).toEqual(['new', 'start']);
-            expect(program.implBlocks[0].methods[1].params[0]).toEqual({
-                name: 'self',
-                type: { kind: 'struct', name: 'Timer' },
-                default: undefined,
-            });
-        });
-        it('parses impl blocks with static and instance methods', () => {
-            const program = parse(`
-struct Point { x: int, y: int }
-
-impl Point {
-  fn new(x: int, y: int) -> Point {
-    return { x: x, y: y };
-  }
-
-  fn distance(self) -> int {
-    return self.x + self.y;
-  }
-}
-`);
-            expect(program.implBlocks).toHaveLength(1);
-            expect(program.implBlocks[0].typeName).toBe('Point');
-            expect(program.implBlocks[0].methods[0].params.map(param => param.name)).toEqual(['x', 'y']);
-            expect(program.implBlocks[0].methods[1].params[0]).toEqual({
-                name: 'self',
-                type: { kind: 'struct', name: 'Point' },
-                default: undefined,
-            });
-        });
-    });
-    describe('statements', () => {
-        it('parses let statement', () => {
-            const stmt = parseStmt('let x: int = 5;');
-            expect(stmt).toEqual({
-                kind: 'let',
-                name: 'x',
-                type: { kind: 'named', name: 'int' },
-                init: { kind: 'int_lit', value: 5 },
-            });
-        });
-        it('parses let without type annotation', () => {
-            const stmt = parseStmt('let x = 5;');
-            expect(stmt.kind).toBe('let');
-            expect(stmt.type).toBeUndefined();
-        });
-        it('parses return statement', () => {
-            const stmt = parseStmt('return 42;');
-            expect(stmt).toEqual({
-                kind: 'return',
-                value: { kind: 'int_lit', value: 42 },
-            });
-        });
-        it('parses empty return', () => {
-            const stmt = parseStmt('return;');
-            expect(stmt).toEqual({ kind: 'return', value: undefined });
-        });
-        it('parses if statement', () => {
-            const stmt = parseStmt('if (x > 0) { y = 1; }');
-            expect(stmt.kind).toBe('if');
-            expect(stmt.cond.kind).toBe('binary');
-            expect(stmt.then).toHaveLength(1);
-            expect(stmt.else_).toBeUndefined();
-        });
-        it('parses if-else statement', () => {
-            const stmt = parseStmt('if (x > 0) { y = 1; } else { y = 2; }');
-            expect(stmt.kind).toBe('if');
-            expect(stmt.else_).toHaveLength(1);
-        });
-        it('parses entity is-checks in if conditions', () => {
-            const stmt = parseStmt('if (e is Player) { kill(@s); }');
-            expect(stmt.kind).toBe('if');
-            expect(stmt.cond).toEqual({
-                kind: 'is_check',
-                expr: { kind: 'ident', name: 'e' },
-                entityType: 'Player',
-            });
-        });
-        it('parses entity is-checks inside foreach bodies', () => {
-            const stmt = parseStmt('foreach (e in @e) { if (e is Zombie) { kill(e); } }');
-            expect(stmt.kind).toBe('foreach');
-            const innerIf = stmt.body[0];
-            expect(innerIf.kind).toBe('if');
-            expect(innerIf.cond).toEqual({
-                kind: 'is_check',
-                expr: { kind: 'ident', name: 'e' },
-                entityType: 'Zombie',
-            });
-        });
-        it('parses while statement', () => {
-            const stmt = parseStmt('while (i > 0) { i = i - 1; }');
-            expect(stmt.kind).toBe('while');
-            expect(stmt.cond.kind).toBe('binary');
-            expect(stmt.body).toHaveLength(1);
-        });
-        it('parses for statement', () => {
-            const stmt = parseStmt('for (let i: int = 0; i < 10; i = i + 1) { say("loop"); }');
-            expect(stmt.kind).toBe('for');
-            expect(stmt.init.kind).toBe('let');
-            expect(stmt.init.name).toBe('i');
-            expect(stmt.cond.kind).toBe('binary');
-            expect(stmt.cond.op).toBe('<');
-            expect(stmt.step.kind).toBe('assign');
-            expect(stmt.body).toHaveLength(1);
-        });
-        it('parses for statement without init', () => {
-            const stmt = parseStmt('for (; i < 10; i = i + 1) { say("loop"); }');
-            expect(stmt.kind).toBe('for');
-            expect(stmt.init).toBeUndefined();
-            expect(stmt.cond.kind).toBe('binary');
-        });
-        it('parses foreach statement', () => {
-            const stmt = parseStmt('foreach (z in @e[type=zombie]) { kill(z); }');
-            expect(stmt.kind).toBe('foreach');
-            expect(stmt.binding).toBe('z');
-            expect(stmt.iterable.kind).toBe('selector');
-            expect(stmt.iterable.sel.kind).toBe('@e');
-        });
-        it('parses match statement', () => {
-            const stmt = parseStmt('match (choice) { 1 => { say("one"); } 2 => { say("two"); } _ => { say("other"); } }');
-            expect(stmt.kind).toBe('match');
-            expect(stmt.expr).toEqual({ kind: 'ident', name: 'choice' });
-            expect(stmt.arms).toEqual([
-                { pattern: { kind: 'int_lit', value: 1 }, body: [{ kind: 'expr', expr: { kind: 'call', fn: 'say', args: [{ kind: 'str_lit', value: 'one' }] } }] },
-                { pattern: { kind: 'int_lit', value: 2 }, body: [{ kind: 'expr', expr: { kind: 'call', fn: 'say', args: [{ kind: 'str_lit', value: 'two' }] } }] },
-                { pattern: null, body: [{ kind: 'expr', expr: { kind: 'call', fn: 'say', args: [{ kind: 'str_lit', value: 'other' }] } }] },
-            ]);
-        });
-        it('parses as block', () => {
-            const stmt = parseStmt('as @a { say("hello"); }');
-            expect(stmt.kind).toBe('as_block');
-            expect(stmt.selector.kind).toBe('@a');
-        });
-        it('parses at block', () => {
-            const stmt = parseStmt('at @s { summon("zombie"); }');
-            expect(stmt.kind).toBe('at_block');
-            expect(stmt.selector.kind).toBe('@s');
-        });
-        it('parses as at combined', () => {
-            const stmt = parseStmt('as @a at @s { particle("flame"); }');
-            expect(stmt.kind).toBe('as_at');
-            expect(stmt.as_sel.kind).toBe('@a');
-            expect(stmt.at_sel.kind).toBe('@s');
-        });
-        it('parses raw command', () => {
-            const stmt = parseStmt('raw("say hello");');
-            expect(stmt).toEqual({ kind: 'raw', cmd: 'say hello' });
-        });
-        it('parses execute as run block', () => {
-            const stmt = parseStmt('execute as @a run { say("hello"); }');
-            expect(stmt.kind).toBe('execute');
-            expect(stmt.subcommands).toHaveLength(1);
-            expect(stmt.subcommands[0]).toEqual({ kind: 'as', selector: { kind: '@a' } });
-            expect(stmt.body).toHaveLength(1);
-        });
-        it('parses execute as at run block', () => {
-            const stmt = parseStmt('execute as @a at @s run { particle("flame"); }');
-            expect(stmt.kind).toBe('execute');
-            expect(stmt.subcommands).toHaveLength(2);
-            expect(stmt.subcommands[0]).toEqual({ kind: 'as', selector: { kind: '@a' } });
-            expect(stmt.subcommands[1]).toEqual({ kind: 'at', selector: { kind: '@s' } });
-        });
-        it('parses execute with if entity condition', () => {
-            const stmt = parseStmt('execute as @a if entity @s[tag=admin] run { give(@s, "diamond", 1); }');
-            expect(stmt.kind).toBe('execute');
-            expect(stmt.subcommands).toHaveLength(2);
-            expect(stmt.subcommands[1].kind).toBe('if_entity');
-            expect(stmt.subcommands[1].selector.filters.tag).toEqual(['admin']);
-        });
-        it('parses execute with unless entity condition', () => {
-            const stmt = parseStmt('execute as @a unless entity @s[tag=dead] run { effect(@s, "regeneration", 5); }');
-            expect(stmt.kind).toBe('execute');
-            expect(stmt.subcommands).toHaveLength(2);
-            expect(stmt.subcommands[1].kind).toBe('unless_entity');
-        });
-        it('parses execute with in dimension', () => {
-            const stmt = parseStmt('execute in the_nether run { say("in nether"); }');
-            expect(stmt.kind).toBe('execute');
-            expect(stmt.subcommands).toHaveLength(1);
-            expect(stmt.subcommands[0]).toEqual({ kind: 'in', dimension: 'the_nether' });
-        });
-        it('parses complex execute chain', () => {
-            const stmt = parseStmt('execute as @a at @s if entity @s[tag=vip] in overworld run { particle("heart"); }');
-            expect(stmt.kind).toBe('execute');
-            expect(stmt.subcommands).toHaveLength(4);
-        });
-    });
-    describe('lambda expressions', () => {
-        it('parses expression-body lambdas', () => {
-            const stmt = parseStmt('let double = (x: int) => x * 2;');
-            expect(stmt.kind).toBe('let');
-            expect(stmt.init).toEqual({
-                kind: 'lambda',
-                params: [{ name: 'x', type: { kind: 'named', name: 'int' } }],
-                returnType: undefined,
-                body: {
-                    kind: 'binary',
-                    op: '*',
-                    left: { kind: 'ident', name: 'x' },
-                    right: { kind: 'int_lit', value: 2 },
-                },
-            });
-        });
-        it('parses block-body lambdas', () => {
-            const stmt = parseStmt('let process: (int) -> int = (x: int) => { let doubled: int = x * 2; return doubled + 1; };');
-            expect(stmt.kind).toBe('let');
-            expect(stmt.init.kind).toBe('lambda');
-            expect(Array.isArray(stmt.init.body)).toBe(true);
-        });
-        it('parses single-parameter lambdas without parens', () => {
-            const stmt = parseStmt('let double: (int) -> int = x => x * 2;');
-            expect(stmt.kind).toBe('let');
-            expect(stmt.init).toEqual({
-                kind: 'lambda',
-                params: [{ name: 'x' }],
-                returnType: undefined,
-                body: {
-                    kind: 'binary',
-                    op: '*',
-                    left: { kind: 'ident', name: 'x' },
-                    right: { kind: 'int_lit', value: 2 },
-                },
-            });
-        });
-        it('parses immediately-invoked lambdas', () => {
-            const expr = parseExpr('((x: int) => x * 2)(5)');
-            expect(expr).toEqual({
-                kind: 'invoke',
-                callee: {
-                    kind: 'lambda',
-                    params: [{ name: 'x', type: { kind: 'named', name: 'int' } }],
-                    returnType: undefined,
-                    body: {
-                        kind: 'binary',
-                        op: '*',
-                        left: { kind: 'ident', name: 'x' },
-                        right: { kind: 'int_lit', value: 2 },
-                    },
-                },
-                args: [{ kind: 'int_lit', value: 5 }],
-            });
-        });
-    });
-    describe('expressions', () => {
-        describe('literals', () => {
-            it('parses integer literal', () => {
-                const expr = parseExpr('42');
-                expect(expr).toEqual({ kind: 'int_lit', value: 42 });
-            });
-            it('parses float literal', () => {
-                const expr = parseExpr('3.14');
-                expect(expr).toEqual({ kind: 'float_lit', value: 3.14 });
-            });
-            it('parses string literal', () => {
-                const expr = parseExpr('"hello"');
-                expect(expr).toEqual({ kind: 'str_lit', value: 'hello' });
-            });
-            it('parses interpolated string literal', () => {
-                const expr = parseExpr('"Hello ${name}, score is ${score + 1}"');
-                expect(expr).toEqual({
-                    kind: 'str_interp',
-                    parts: [
-                        'Hello ',
-                        { kind: 'ident', name: 'name' },
-                        ', score is ',
-                        {
-                            kind: 'binary',
-                            op: '+',
-                            left: { kind: 'ident', name: 'score' },
-                            right: { kind: 'int_lit', value: 1 },
-                        },
-                    ],
-                });
-            });
-            it('parses f-string literal', () => {
-                const expr = parseExpr('f"Score: {x}"');
-                expect(expr).toEqual({
-                    kind: 'f_string',
-                    parts: [
-                        { kind: 'text', value: 'Score: ' },
-                        { kind: 'expr', expr: { kind: 'ident', name: 'x' } },
-                    ],
-                });
-            });
-            it('parses boolean literals', () => {
-                expect(parseExpr('true')).toEqual({ kind: 'bool_lit', value: true });
-                expect(parseExpr('false')).toEqual({ kind: 'bool_lit', value: false });
-            });
-            it('parses range literals', () => {
-                expect(parseExpr('..5')).toEqual({ kind: 'range_lit', range: { max: 5 } });
-                expect(parseExpr('1..')).toEqual({ kind: 'range_lit', range: { min: 1 } });
-                expect(parseExpr('1..10')).toEqual({ kind: 'range_lit', range: { min: 1, max: 10 } });
-            });
-            it('parses absolute block positions', () => {
-                expect(parseExpr('(0, 64, 0)')).toEqual({
-                    kind: 'blockpos',
-                    x: { kind: 'absolute', value: 0 },
-                    y: { kind: 'absolute', value: 64 },
-                    z: { kind: 'absolute', value: 0 },
-                });
-            });
-            it('parses relative block positions', () => {
-                expect(parseExpr('(~1, ~0, ~-1)')).toEqual({
-                    kind: 'blockpos',
-                    x: { kind: 'relative', offset: 1 },
-                    y: { kind: 'relative', offset: 0 },
-                    z: { kind: 'relative', offset: -1 },
-                });
-            });
-            it('parses local block positions', () => {
-                expect(parseExpr('(^0, ^1, ^0)')).toEqual({
-                    kind: 'blockpos',
-                    x: { kind: 'local', offset: 0 },
-                    y: { kind: 'local', offset: 1 },
-                    z: { kind: 'local', offset: 0 },
-                });
-            });
-            it('parses mixed block positions', () => {
-                expect(parseExpr('(~0, 64, ~0)')).toEqual({
-                    kind: 'blockpos',
-                    x: { kind: 'relative', offset: 0 },
-                    y: { kind: 'absolute', value: 64 },
-                    z: { kind: 'relative', offset: 0 },
-                });
-            });
-        });
-        describe('identifiers and calls', () => {
-            it('parses identifier', () => {
-                const expr = parseExpr('foo');
-                expect(expr).toEqual({ kind: 'ident', name: 'foo' });
-            });
-            it('parses function call', () => {
-                const expr = parseExpr('foo(1, 2)');
-                expect(expr).toEqual({
-                    kind: 'call',
-                    fn: 'foo',
-                    args: [
-                        { kind: 'int_lit', value: 1 },
-                        { kind: 'int_lit', value: 2 },
-                    ],
-                });
-            });
-            it('parses no-arg call', () => {
-                const expr = parseExpr('foo()');
-                expect(expr).toEqual({ kind: 'call', fn: 'foo', args: [] });
-            });
-            it('parses enum variant member access', () => {
-                const expr = parseExpr('Direction.North');
-                expect(expr).toEqual({
-                    kind: 'member',
-                    obj: { kind: 'ident', name: 'Direction' },
-                    field: 'North',
-                });
-            });
-        });
-        it('parses static method calls', () => {
-            const expr = parseExpr('Timer::new(100)');
-            expect(expr).toEqual({
-                kind: 'static_call',
-                type: 'Timer',
-                method: 'new',
-                args: [{ kind: 'int_lit', value: 100 }],
-            });
-        });
-        describe('binary operators', () => {
-            it('parses arithmetic', () => {
-                const expr = parseExpr('1 + 2');
-                expect(expr).toEqual({
-                    kind: 'binary',
-                    op: '+',
-                    left: { kind: 'int_lit', value: 1 },
-                    right: { kind: 'int_lit', value: 2 },
-                });
-            });
-            it('respects precedence (mul before add)', () => {
-                const expr = parseExpr('1 + 2 * 3');
-                expect(expr.kind).toBe('binary');
-                expect(expr.op).toBe('+');
-                expect(expr.right.op).toBe('*');
-            });
-            it('respects precedence (compare before logical)', () => {
-                const expr = parseExpr('a < b && c > d');
-                expect(expr.kind).toBe('binary');
-                expect(expr.op).toBe('&&');
-                expect(expr.left.op).toBe('<');
-                expect(expr.right.op).toBe('>');
-            });
-            it('is left associative', () => {
-                const expr = parseExpr('1 - 2 - 3');
-                // Should be (1 - 2) - 3
-                expect(expr.kind).toBe('binary');
-                expect(expr.op).toBe('-');
-                expect(expr.left.kind).toBe('binary');
-                expect(expr.right.kind).toBe('int_lit');
-            });
-        });
-        describe('unary operators', () => {
-            it('parses negation', () => {
-                const expr = parseExpr('-5');
-                expect(expr).toEqual({
-                    kind: 'unary',
-                    op: '-',
-                    operand: { kind: 'int_lit', value: 5 },
-                });
-            });
-            it('parses logical not', () => {
-                const expr = parseExpr('!flag');
-                expect(expr).toEqual({
-                    kind: 'unary',
-                    op: '!',
-                    operand: { kind: 'ident', name: 'flag' },
-                });
-            });
-        });
-        describe('assignment', () => {
-            it('parses simple assignment', () => {
-                const expr = parseExpr('x = 5');
-                expect(expr).toEqual({
-                    kind: 'assign',
-                    target: 'x',
-                    op: '=',
-                    value: { kind: 'int_lit', value: 5 },
-                });
-            });
-            it('parses compound assignment', () => {
-                const expr = parseExpr('x += 1');
-                expect(expr).toEqual({
-                    kind: 'assign',
-                    target: 'x',
-                    op: '+=',
-                    value: { kind: 'int_lit', value: 1 },
-                });
-            });
-        });
-        describe('selectors', () => {
-            it('parses simple selector', () => {
-                const expr = parseExpr('@a');
-                expect(expr).toEqual({
-                    kind: 'selector',
-                    raw: '@a',
-                    isSingle: false,
-                    sel: { kind: '@a' },
-                });
-            });
-            it('marks single-entity selectors', () => {
-                expect(parseExpr('@p')).toEqual({
-                    kind: 'selector',
-                    raw: '@p',
-                    isSingle: true,
-                    sel: { kind: '@p' },
-                });
-                expect(parseExpr('@e[limit=1, tag=target]')).toEqual({
-                    kind: 'selector',
-                    raw: '@e[limit=1, tag=target]',
-                    isSingle: true,
-                    sel: {
-                        kind: '@e',
-                        filters: { limit: 1, tag: ['target'] },
-                    },
-                });
-            });
-            it('parses selector with type filter', () => {
-                const expr = parseExpr('@e[type=zombie]');
-                expect(expr).toEqual({
-                    kind: 'selector',
-                    raw: '@e[type=zombie]',
-                    isSingle: false,
-                    sel: {
-                        kind: '@e',
-                        filters: { type: 'zombie' },
-                    },
-                });
-            });
-            it('parses selector with distance filter', () => {
-                const expr = parseExpr('@e[distance=..5]');
-                expect(expr.sel.filters.distance).toEqual({ max: 5 });
-            });
-            it('parses selector with tag filter', () => {
-                const expr = parseExpr('@e[tag=boss, tag=!excluded]');
-                expect(expr.sel.filters.tag).toEqual(['boss']);
-                expect(expr.sel.filters.notTag).toEqual(['excluded']);
-            });
-            it('parses selector with limit and sort', () => {
-                const expr = parseExpr('@e[limit=1, sort=nearest]');
-                expect(expr.sel.filters.limit).toBe(1);
-                expect(expr.sel.filters.sort).toBe('nearest');
-            });
-            it('parses selector with scores', () => {
-                const expr = parseExpr('@a[scores={kills=1..}]');
-                expect(expr.sel.filters.scores).toEqual({
-                    kills: { min: 1 },
-                });
-            });
-        });
-        describe('member access', () => {
-            it('parses member access', () => {
-                const expr = parseExpr('entity.health');
-                expect(expr).toEqual({
-                    kind: 'member',
-                    obj: { kind: 'ident', name: 'entity' },
-                    field: 'health',
-                });
-            });
-            it('parses array len property', () => {
-                const expr = parseExpr('arr.len');
-                expect(expr).toEqual({
-                    kind: 'member',
-                    obj: { kind: 'ident', name: 'arr' },
-                    field: 'len',
-                });
-            });
-        });
-        describe('arrays', () => {
-            it('parses array literal', () => {
-                expect(parseExpr('[1, 2, 3]')).toEqual({
-                    kind: 'array_lit',
-                    elements: [
-                        { kind: 'int_lit', value: 1 },
-                        { kind: 'int_lit', value: 2 },
-                        { kind: 'int_lit', value: 3 },
-                    ],
-                });
-            });
-            it('parses array index access', () => {
-                expect(parseExpr('arr[i]')).toEqual({
-                    kind: 'index',
-                    obj: { kind: 'ident', name: 'arr' },
-                    index: { kind: 'ident', name: 'i' },
-                });
-            });
-            it('parses array push call', () => {
-                expect(parseExpr('arr.push(4)')).toEqual({
-                    kind: 'call',
-                    fn: '__array_push',
-                    args: [
-                        { kind: 'ident', name: 'arr' },
-                        { kind: 'int_lit', value: 4 },
-                    ],
-                });
-            });
-            it('parses array pop call', () => {
-                expect(parseExpr('arr.pop()')).toEqual({
-                    kind: 'call',
-                    fn: '__array_pop',
-                    args: [
-                        { kind: 'ident', name: 'arr' },
-                    ],
-                });
-            });
-        });
-        describe('grouping', () => {
-            it('parses parenthesized expression', () => {
-                const expr = parseExpr('(1 + 2) * 3');
-                expect(expr.kind).toBe('binary');
-                expect(expr.op).toBe('*');
-                expect(expr.left.kind).toBe('binary');
-            });
-        });
-    });
-    describe('complex programs', () => {
-        it('parses add function', () => {
-            const source = `
-fn add(a: int, b: int) -> int {
-    return a + b;
-}
-`;
-            const program = parse(source);
-            expect(program.declarations).toHaveLength(1);
-            const fn = program.declarations[0];
-            expect(fn.name).toBe('add');
-            expect(fn.body).toHaveLength(1);
-            expect(fn.body[0].kind).toBe('return');
-        });
-        it('parses abs function with if/else', () => {
-            const source = `
-fn abs(x: int) -> int {
-    if (x < 0) {
-        return -x;
-    } else {
-        return x;
-    }
-}
-`;
-            const program = parse(source);
-            const fn = program.declarations[0];
-            expect(fn.body).toHaveLength(1);
-            const ifStmt = fn.body[0];
-            expect(ifStmt.kind).toBe('if');
-        });
-        it('parses tick function', () => {
-            const source = `
-@tick(rate=20)
-fn heartbeat() {
-    say("still alive");
-}
-`;
-            const program = parse(source);
-            const fn = program.declarations[0];
-            expect(fn.decorators).toEqual([{ name: 'tick', args: { rate: 20 } }]);
-            expect(fn.body).toHaveLength(1);
-        });
-        it('parses foreach with kill', () => {
-            const source = `
-fn kill_zombies() {
-    foreach (z in @e[type=zombie, distance=..10]) {
-        kill(z);
-    }
-}
-`;
-            const program = parse(source);
-            const fn = program.declarations[0];
-            const stmt = fn.body[0];
-            expect(stmt.kind).toBe('foreach');
-            expect(stmt.binding).toBe('z');
-            expect(stmt.iterable.sel.filters.type).toBe('zombie');
-            expect(stmt.iterable.sel.filters.distance).toEqual({ max: 10 });
-        });
-        it('parses foreach over array', () => {
-            const source = `
-fn walk() {
-    let arr: int[] = [1, 2, 3];
-    foreach (x in arr) {
-        say("tick");
-    }
-}
-`;
-            const program = parse(source);
-            const stmt = program.declarations[0].body[1];
-            expect(stmt.kind).toBe('foreach');
-            expect(stmt.binding).toBe('x');
-            expect(stmt.iterable).toEqual({ kind: 'ident', name: 'arr' });
-        });
-        it('parses while loop', () => {
-            const source = `
-fn count_down() {
-    let i: int = 10;
-    while (i > 0) {
-        i = i - 1;
-    }
-}
-`;
-            const program = parse(source);
-            const fn = program.declarations[0];
-            expect(fn.body).toHaveLength(2);
-            expect(fn.body[0].kind).toBe('let');
-            expect(fn.body[1].kind).toBe('while');
-        });
-    });
-});
-//# sourceMappingURL=parser.test.js.map