redscript-mc 2.0.0 → 2.1.0

package/dist/src/__tests__/enum.test.js

@@ -0,0 +1,389 @@
+"use strict";
+/**
+ * Enum + pattern matching tests for Phase 2a.
+ *
+ * Tests cover:
+ * - Lexer/Parser: enum declarations, :: path operator
+ * - TypeChecker: enum type checking, variant resolution
+ * - HIR/MIR/LIR: enum compilation to integer scoreboard slots
+ * - E2E: match on enum variants → execute if score ... matches N
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const compile_1 = require("../emit/compile");
+const typechecker_1 = require("../typechecker");
+// Helper: parse source → AST
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens, source).parse();
+}
+// Helper: type check source → errors
+function typeCheck(source) {
+    const program = parse(source);
+    const checker = new typechecker_1.TypeChecker(source);
+    return checker.check(program);
+}
+// Helper: compile and get all mcfunction content
+function getCommands(source, namespace = 'test') {
+    const result = (0, compile_1.compile)(source, { namespace });
+    expect(result.success).toBe(true);
+    return (result.files ?? [])
+        .filter(f => f.path.endsWith('.mcfunction'))
+        .flatMap(f => f.content.split('\n'))
+        .filter(line => line.trim().length > 0);
+}
+// Helper: get specific mcfunction file content
+function getFile(files, pathSubstr) {
+    return files.find(f => f.path.includes(pathSubstr))?.content;
+}
+// =========================================================================
+// Lexer tests
+// =========================================================================
+describe('enum: lexer', () => {
+    test('tokenizes enum keyword', () => {
+        const tokens = new lexer_1.Lexer('enum Phase').tokenize();
+        expect(tokens[0].kind).toBe('enum');
+        expect(tokens[1].kind).toBe('ident');
+        expect(tokens[1].value).toBe('Phase');
+    });
+    test('tokenizes :: operator', () => {
+        const tokens = new lexer_1.Lexer('Phase::Idle').tokenize();
+        expect(tokens.map(t => t.kind)).toEqual(['ident', '::', 'ident', 'eof']);
+    });
+    test(':: does not conflict with single :', () => {
+        const tokens = new lexer_1.Lexer('a: int :: b').tokenize();
+        expect(tokens.map(t => t.kind)).toEqual(['ident', ':', 'int', '::', 'ident', 'eof']);
+    });
+});
+// =========================================================================
+// Parser tests
+// =========================================================================
+describe('enum: parser', () => {
+    test('parses basic enum declaration', () => {
+        const program = parse('enum Phase { Idle, Moving, Attacking }');
+        expect(program.enums).toEqual([
+            {
+                name: 'Phase',
+                variants: [
+                    { name: 'Idle', value: 0 },
+                    { name: 'Moving', value: 1 },
+                    { name: 'Attacking', value: 2 },
+                ],
+            },
+        ]);
+    });
+    test('parses enum with explicit values', () => {
+        const program = parse('enum Color { Red = 10, Green, Blue = 20 }');
+        expect(program.enums[0].variants).toEqual([
+            { name: 'Red', value: 10 },
+            { name: 'Green', value: 11 },
+            { name: 'Blue', value: 20 },
+        ]);
+    });
+    test('parses enum variant access with :: operator', () => {
+        const program = parse(`
+      enum Phase { Idle, Moving }
+      fn test() {
+        let p: Phase = Phase::Idle;
+      }
+    `);
+        const letStmt = program.declarations[0].body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init).toMatchObject({
+                kind: 'path_expr',
+                enumName: 'Phase',
+                variant: 'Idle',
+            });
+        }
+    });
+    test('parses match with enum variant patterns', () => {
+        const program = parse(`
+      enum Phase { Idle, Moving }
+      fn test() {
+        let p: Phase = Phase::Idle;
+        match (p) {
+          Phase::Idle => { }
+          Phase::Moving => { }
+        }
+      }
+    `);
+        const matchStmt = program.declarations[0].body[1];
+        expect(matchStmt.kind).toBe('match');
+        if (matchStmt.kind === 'match') {
+            expect(matchStmt.arms).toHaveLength(2);
+            expect(matchStmt.arms[0].pattern).toMatchObject({
+                kind: 'path_expr',
+                enumName: 'Phase',
+                variant: 'Idle',
+            });
+            expect(matchStmt.arms[1].pattern).toMatchObject({
+                kind: 'path_expr',
+                enumName: 'Phase',
+                variant: 'Moving',
+            });
+        }
+    });
+    test(':: with () is still static_call', () => {
+        const program = parse(`
+      struct Timer { x: int }
+      impl Timer {
+        fn new(): void { }
+      }
+      fn test() { Timer::new(); }
+    `);
+        const exprStmt = program.declarations[0].body[0];
+        expect(exprStmt.kind).toBe('expr');
+        if (exprStmt.kind === 'expr') {
+            expect(exprStmt.expr.kind).toBe('static_call');
+        }
+    });
+    test('enum type annotation in function params', () => {
+        const program = parse(`
+      enum Direction { North, South }
+      fn move(dir: Direction) { }
+    `);
+        expect(program.declarations[0].params[0].type).toEqual({
+            kind: 'struct',
+            name: 'Direction',
+        });
+    });
+});
+// =========================================================================
+// Type checker tests
+// =========================================================================
+describe('enum: type checker', () => {
+    test('no errors for valid enum usage', () => {
+        const errors = typeCheck(`
+      enum Phase { Idle, Moving, Attacking }
+      fn test() {
+        let p: Phase = Phase::Idle;
+      }
+    `);
+        expect(errors).toHaveLength(0);
+    });
+    test('error for unknown enum in path_expr', () => {
+        const errors = typeCheck(`
+      fn test() {
+        let x: int = NoSuchEnum::Variant;
+      }
+    `);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('NoSuchEnum');
+    });
+    test('error for unknown variant', () => {
+        const errors = typeCheck(`
+      enum Phase { Idle, Moving }
+      fn test() {
+        let p: Phase = Phase::Flying;
+      }
+    `);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('Flying');
+    });
+    test('no errors for match on enum', () => {
+        const errors = typeCheck(`
+      enum Phase { Idle, Moving }
+      fn test() {
+        let p: Phase = Phase::Idle;
+        match (p) {
+          Phase::Idle => { }
+          Phase::Moving => { }
+        }
+      }
+    `);
+        expect(errors).toHaveLength(0);
+    });
+    test('enum as function parameter and return value', () => {
+        const errors = typeCheck(`
+      enum State { On, Off }
+      fn toggle(s: State): State {
+        return State::Off;
+      }
+      fn test() {
+        let s: State = State::On;
+        let result: State = toggle(s);
+      }
+    `);
+        expect(errors).toHaveLength(0);
+    });
+});
+// =========================================================================
+// E2E compilation tests
+// =========================================================================
+describe('enum: e2e compilation', () => {
+    test('enum variable compiles to scoreboard set', () => {
+        const source = `
+      enum Phase { Idle, Moving, Attacking }
+      fn test(): int {
+        let phase: Phase = Phase::Attacking;
+        return phase;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        const cmds = getCommands(source);
+        // Phase::Attacking = 2, should see a set with value 2
+        const setCmds = cmds.filter(c => c.includes('scoreboard players set') && c.includes(' 2'));
+        expect(setCmds.length).toBeGreaterThan(0);
+    });
+    test('enum variant values map to correct integers', () => {
+        const source = `
+      enum Phase { Idle, Moving, Attacking }
+      fn test_idle(): int {
+        return Phase::Idle;
+      }
+      fn test_moving(): int {
+        return Phase::Moving;
+      }
+      fn test_attacking(): int {
+        return Phase::Attacking;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        const cmds = getCommands(source);
+        // Should contain set commands for 0, 1, 2
+        const hasCmdWith = (val) => cmds.some(c => c.includes('scoreboard players set') && c.includes(` ${val}`));
+        expect(hasCmdWith('0')).toBe(true);
+        expect(hasCmdWith('1')).toBe(true);
+        expect(hasCmdWith('2')).toBe(true);
+    });
+    test('match on enum compiles to score comparison chain', () => {
+        // Use function parameter to prevent constant folding
+        const source = `
+      enum Phase { Idle, Moving, Attacking }
+      fn game(phase: Phase): int {
+        match (phase) {
+          Phase::Idle => {
+            return 1;
+          }
+          Phase::Moving => {
+            return 2;
+          }
+          Phase::Attacking => {
+            return 3;
+          }
+        }
+        return 0;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        const cmds = getCommands(source);
+        // Match compiles to 'execute if score ... matches' or comparison chain
+        const matchCmds = cmds.filter(c => c.includes('execute if score') || c.includes('execute unless score'));
+        expect(matchCmds.length).toBeGreaterThan(0);
+    });
+    test('match with default arm compiles', () => {
+        const source = `
+      enum Phase { Idle, Moving, Attacking }
+      fn game() {
+        let phase: Phase = Phase::Idle;
+        match (phase) {
+          Phase::Idle => {
+            let x: int = 0;
+          }
+          _ => {
+            let x: int = 99;
+          }
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+    });
+    test('enum as function parameter', () => {
+        const source = `
+      enum Direction { North, South, East, West }
+      fn handle_dir(dir: Direction) {
+        match (dir) {
+          Direction::North => { let x: int = 0; }
+          Direction::South => { let x: int = 1; }
+          Direction::East => { let x: int = 2; }
+          Direction::West => { let x: int = 3; }
+        }
+      }
+      fn main() {
+        handle_dir(Direction::East);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        // Direction::East = 2, should see score set with value 2
+        const cmds = getCommands(source);
+        const setCmds = cmds.filter(c => c.includes('scoreboard players set') && c.includes(' 2'));
+        expect(setCmds.length).toBeGreaterThan(0);
+    });
+    test('enum assignment and reassignment', () => {
+        const source = `
+      enum State { Off, On }
+      fn toggle(): int {
+        let s: State = State::Off;
+        s = State::On;
+        return s;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        const cmds = getCommands(source);
+        // Optimizer may constant-fold: Off=0 → On=1 → return 1
+        // Just verify it compiles and has a set command
+        const setCmds = cmds.filter(c => c.includes('scoreboard players set'));
+        expect(setCmds.length).toBeGreaterThanOrEqual(1);
+    });
+    test('enum comparison in if statement', () => {
+        const source = `
+      enum Phase { Idle, Active }
+      fn check() {
+        let p: Phase = Phase::Active;
+        if (p == Phase::Active) {
+          let x: int = 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+    });
+    test('enum with explicit values compiles correctly', () => {
+        const source = `
+      enum Priority { Low = 10, Medium = 20, High = 30 }
+      fn test(): int {
+        return Priority::High;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        const cmds = getCommands(source);
+        // High = 30
+        const setCmds = cmds.filter(c => c.includes('scoreboard players set') && c.includes(' 30'));
+        expect(setCmds.length).toBeGreaterThan(0);
+    });
+    test('multiple enums in same program', () => {
+        const source = `
+      enum Phase { Idle, Active }
+      enum Color { Red, Green, Blue }
+      fn test() {
+        let p: Phase = Phase::Active;
+        let c: Color = Color::Blue;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+    });
+    test('enum return value from function', () => {
+        const source = `
+      enum Direction { North, South }
+      fn get_dir(): Direction {
+        return Direction::North;
+      }
+      fn test() {
+        let d: Direction = get_dir();
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+    });
+});
+//# sourceMappingURL=enum.test.js.map

package/dist/src/__tests__/generics.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tests for Phase 2c: Generic functions (monomorphization)
+ *
+ * Covers:
+ * - Parsing fn<T> declarations and typeParams
+ * - Parsing explicit call<int>() type args
+ * - Type inference from arguments (max(3, 5) → max_int)
+ * - Monomorphization: unique specialized copies per type
+ * - Mangled names: max_int, max_float
+ * - Generic calling generic (clamp<T> calls min<T> and max<T>)
+ * - Interaction with enum + tuple
+ * - Correct scoreboard output
+ */
+export {};