redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/compiler/enum-payload.test.js

@@ -0,0 +1,272 @@
+"use strict";
+/**
+ * Enum with payload tests.
+ *
+ * Tests cover:
+ * - Parser: enum variants with payload fields, enum_construct expr, PatEnum
+ * - Type checker: payload field validation, binding type inference
+ * - MIR/E2E: construction emits NBT writes; match emits tag check + NBT reads
+ */
+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");
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens, source).parse();
+}
+function typeCheck(source) {
+    const program = parse(source);
+    const checker = new typechecker_1.TypeChecker(source);
+    return checker.check(program);
+}
+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);
+}
+// ===========================================================================
+// Parser tests
+// ===========================================================================
+describe('enum-payload: parser', () => {
+    test('parses enum variant with payload fields', () => {
+        const source = `
+      enum Color {
+        Red,
+        RGB(r: int, g: int, b: int),
+      }
+    `;
+        const ast = parse(source);
+        expect(ast.enums).toHaveLength(1);
+        const e = ast.enums[0];
+        expect(e.name).toBe('Color');
+        expect(e.variants).toHaveLength(2);
+        const red = e.variants[0];
+        expect(red.name).toBe('Red');
+        expect(red.fields).toBeUndefined();
+        const rgb = e.variants[1];
+        expect(rgb.name).toBe('RGB');
+        expect(rgb.fields).toHaveLength(3);
+        expect(rgb.fields[0]).toMatchObject({ name: 'r', type: { kind: 'named', name: 'int' } });
+        expect(rgb.fields[1]).toMatchObject({ name: 'g', type: { kind: 'named', name: 'int' } });
+        expect(rgb.fields[2]).toMatchObject({ name: 'b', type: { kind: 'named', name: 'int' } });
+    });
+    test('parses enum_construct expression', () => {
+        const source = `
+      enum Color { Red, RGB(r: int, g: int, b: int) }
+      fn test(): Color {
+        return Color::RGB(r: 10, g: 20, b: 30);
+      }
+    `;
+        const ast = parse(source);
+        const fn = ast.declarations[0];
+        const retStmt = fn.body[0];
+        expect(retStmt.kind).toBe('return');
+        if (retStmt.kind === 'return' && retStmt.value) {
+            expect(retStmt.value.kind).toBe('enum_construct');
+            if (retStmt.value.kind === 'enum_construct') {
+                expect(retStmt.value.enumName).toBe('Color');
+                expect(retStmt.value.variant).toBe('RGB');
+                expect(retStmt.value.args).toHaveLength(3);
+                expect(retStmt.value.args[0]).toMatchObject({ name: 'r' });
+                expect(retStmt.value.args[1]).toMatchObject({ name: 'g' });
+                expect(retStmt.value.args[2]).toMatchObject({ name: 'b' });
+            }
+        }
+    });
+    test('parses PatEnum in match (with bindings)', () => {
+        const source = `
+      enum Color { Red, RGB(r: int, g: int, b: int) }
+      fn test(c: Color): int {
+        match c {
+          Color::RGB(r, g, b) => { return r; }
+          Color::Red => { return 0; }
+        }
+        return -1;
+      }
+    `;
+        const ast = parse(source);
+        const fn = ast.declarations[0];
+        const matchStmt = fn.body[0];
+        expect(matchStmt.kind).toBe('match');
+        if (matchStmt.kind === 'match') {
+            const firstArm = matchStmt.arms[0];
+            expect(firstArm.pattern.kind).toBe('PatEnum');
+            if (firstArm.pattern.kind === 'PatEnum') {
+                expect(firstArm.pattern.enumName).toBe('Color');
+                expect(firstArm.pattern.variant).toBe('RGB');
+                expect(firstArm.pattern.bindings).toEqual(['r', 'g', 'b']);
+            }
+            const secondArm = matchStmt.arms[1];
+            expect(secondArm.pattern.kind).toBe('PatEnum');
+            if (secondArm.pattern.kind === 'PatEnum') {
+                expect(secondArm.pattern.bindings).toEqual([]);
+            }
+        }
+    });
+    test('parses simple no-binding PatEnum', () => {
+        const source = `
+      enum Dir { North, South(x: int) }
+      fn test(d: Dir): void {
+        match d {
+          Dir::North => { }
+          Dir::South(x) => { }
+        }
+      }
+    `;
+        const ast = parse(source);
+        const fn = ast.declarations[0];
+        const matchStmt = fn.body[0];
+        expect(matchStmt.kind).toBe('match');
+    });
+});
+// ===========================================================================
+// Type checker tests
+// ===========================================================================
+describe('enum-payload: typechecker', () => {
+    test('accepts valid enum_construct with correct fields', () => {
+        const source = `
+      enum Color { Red, RGB(r: int, g: int, b: int) }
+      fn test(): Color {
+        return Color::RGB(r: 10, g: 20, b: 30);
+      }
+    `;
+        const errors = typeCheck(source);
+        expect(errors).toHaveLength(0);
+    });
+    test('reports error for unknown field in enum_construct', () => {
+        const source = `
+      enum Color { Red, RGB(r: int, g: int, b: int) }
+      fn test(): Color {
+        return Color::RGB(x: 10, g: 20, b: 30);
+      }
+    `;
+        const errors = typeCheck(source);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors.some(e => e.message.includes('x'))).toBe(true);
+    });
+    test('accepts match with PatEnum bindings in scope', () => {
+        const source = `
+      enum Color { Red, RGB(r: int, g: int, b: int) }
+      fn test(c: Color): int {
+        match c {
+          Color::RGB(r, g, b) => { return r; }
+          Color::Red => { return 0; }
+        }
+        return -1;
+      }
+    `;
+        const errors = typeCheck(source);
+        expect(errors).toHaveLength(0);
+    });
+    test('enum_construct infers enum type', () => {
+        const source = `
+      enum Color { Red, RGB(r: int, g: int, b: int) }
+      fn test(): Color {
+        let c: Color = Color::RGB(r: 1, g: 2, b: 3);
+        return c;
+      }
+    `;
+        const errors = typeCheck(source);
+        expect(errors).toHaveLength(0);
+    });
+});
+// ===========================================================================
+// E2E compilation tests
+// ===========================================================================
+describe('enum-payload: e2e compilation', () => {
+    test('enum_construct emits tag scoreboard set and NBT writes', () => {
+        const source = `
+      enum Color { Red, RGB(r: int, g: int, b: int) }
+      fn make_color(): Color {
+        return Color::RGB(r: 10, g: 20, b: 30);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        const cmds = getCommands(source);
+        const allCmds = cmds.join('\n');
+        // Should set the tag to 1 (RGB = variant 1)
+        const tagSets = cmds.filter(c => c.includes('scoreboard players set') && c.includes(' 1'));
+        expect(tagSets.length).toBeGreaterThan(0);
+        // Should write payload fields to NBT storage rs:enums
+        expect(allCmds).toContain('storage rs:enums');
+        // Should store the r, g, b values (10, 20, 30)
+        expect(allCmds).toContain('Color_r');
+        expect(allCmds).toContain('Color_g');
+        expect(allCmds).toContain('Color_b');
+    });
+    test('match on PatEnum emits tag comparison and NBT reads', () => {
+        const source = `
+      enum Color { Red, RGB(r: int, g: int, b: int) }
+      fn use_color(c: Color): int {
+        match c {
+          Color::RGB(r, g, b) => { return r; }
+          Color::Red => { return 0; }
+        }
+        return -1;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        const cmds = getCommands(source);
+        const allCmds = cmds.join('\n');
+        // Tag comparison: execute if score ... matches 1 (RGB variant)
+        expect(allCmds).toContain('execute if score');
+        // NBT read for payload: data get storage rs:enums Color_r
+        expect(allCmds).toContain('storage rs:enums');
+        expect(allCmds).toContain('Color_r');
+    });
+    test('no-payload PatEnum (bare variant) compiles like existing enum match', () => {
+        const source = `
+      enum Color { Red, RGB(r: int, g: int, b: int) }
+      fn use_color(c: Color): int {
+        match c {
+          Color::Red => { return 0; }
+          Color::RGB(r, g, b) => { return 1; }
+        }
+        return -1;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+    });
+    test('mixed enum: payload and no-payload variants in same enum', () => {
+        const source = `
+      enum Shape {
+        Circle,
+        Rect(w: int, h: int),
+      }
+      fn area(s: Shape): int {
+        match s {
+          Shape::Circle => { return 0; }
+          Shape::Rect(w, h) => { return w; }
+        }
+        return -1;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        const cmds = getCommands(source);
+        const allCmds = cmds.join('\n');
+        expect(allCmds).toContain('Shape_w');
+    });
+    test('enum_construct for no-payload variant still compiles as integer constant', () => {
+        const source = `
+      enum Color { Red, RGB(r: int, g: int, b: int) }
+      fn test(): Color {
+        return Color::Red;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        const cmds = getCommands(source);
+        const zeroSets = cmds.filter(c => c.includes('scoreboard players set') && c.includes(' 0'));
+        expect(zeroSets.length).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=enum-payload.test.js.map

package/dist/src/__tests__/compiler/interface.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for the interface / trait system.
+ *
+ * RedScript supports:
+ *   - `interface <Name> { fn <method>(<params>): <ret> }` declarations
+ *   - `impl <Interface> for <Struct> { ... }` implementations
+ *   - Compile-time verification that all required methods are implemented
+ *   - Multiple structs implementing the same interface
+ */
+export {};

package/dist/src/__tests__/compiler/interface.test.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Tests for the interface / trait system.
+ *
+ * RedScript supports:
+ *   - `interface <Name> { fn <method>(<params>): <ret> }` declarations
+ *   - `impl <Interface> for <Struct> { ... }` implementations
+ *   - Compile-time verification that all required methods are implemented
+ *   - Multiple structs implementing the same interface
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const typechecker_1 = require("../../typechecker");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens, source).parse('test');
+}
+function typeCheck(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens, source).parse('test');
+    const checker = new typechecker_1.TypeChecker(source);
+    return checker.check(ast);
+}
+// ---------------------------------------------------------------------------
+// Sample sources
+// ---------------------------------------------------------------------------
+const DRAWABLE_INTERFACE = `
+interface Drawable {
+  fn draw(self, x: int, y: int)
+  fn get_bounds(self): (int, int, int, int)
+}
+`;
+const SPRITE_STRUCT = `
+struct Sprite {
+  tile_id: int,
+  width: int,
+  height: int,
+}
+`;
+const SPRITE_IMPL_FULL = `
+${DRAWABLE_INTERFACE}
+${SPRITE_STRUCT}
+
+impl Drawable for Sprite {
+  fn draw(self: Sprite, x: int, y: int) {
+    particle("dust", x, y, 0)
+  }
+  fn get_bounds(self: Sprite): (int, int, int, int) {
+    return (0, 0, self.width, self.height)
+  }
+}
+`;
+const SPRITE_IMPL_MISSING_METHOD = `
+${DRAWABLE_INTERFACE}
+${SPRITE_STRUCT}
+
+impl Drawable for Sprite {
+  fn draw(self: Sprite, x: int, y: int) {
+    particle("dust", x, y, 0)
+  }
+}
+`;
+const SPRITE_IMPL_MISSING_BOTH = `
+${DRAWABLE_INTERFACE}
+${SPRITE_STRUCT}
+
+impl Drawable for Sprite {
+}
+`;
+// ---------------------------------------------------------------------------
+// 1. Parser: interface declaration
+// ---------------------------------------------------------------------------
+describe('interface — parser', () => {
+    test('parses interface declaration', () => {
+        const ast = parse(DRAWABLE_INTERFACE);
+        expect(ast.interfaces).toHaveLength(1);
+        expect(ast.interfaces[0].name).toBe('Drawable');
+    });
+    test('interface has correct method count', () => {
+        const ast = parse(DRAWABLE_INTERFACE);
+        const iface = ast.interfaces[0];
+        expect(iface.methods).toHaveLength(2);
+    });
+    test('interface method names are correct', () => {
+        const ast = parse(DRAWABLE_INTERFACE);
+        const iface = ast.interfaces[0];
+        expect(iface.methods.map(m => m.name)).toEqual(['draw', 'get_bounds']);
+    });
+    test('interface method params are parsed', () => {
+        const ast = parse(DRAWABLE_INTERFACE);
+        const drawMethod = ast.interfaces[0].methods.find(m => m.name === 'draw');
+        expect(drawMethod).toBeDefined();
+        // self, x, y
+        expect(drawMethod.params).toHaveLength(3);
+        expect(drawMethod.params[0].name).toBe('self');
+        expect(drawMethod.params[1].name).toBe('x');
+        expect(drawMethod.params[2].name).toBe('y');
+    });
+    test('interface method return type is parsed', () => {
+        const ast = parse(DRAWABLE_INTERFACE);
+        const getBoundsMethod = ast.interfaces[0].methods.find(m => m.name === 'get_bounds');
+        expect(getBoundsMethod).toBeDefined();
+        expect(getBoundsMethod.returnType).toMatchObject({
+            kind: 'tuple',
+            elements: [
+                { kind: 'named', name: 'int' },
+                { kind: 'named', name: 'int' },
+                { kind: 'named', name: 'int' },
+                { kind: 'named', name: 'int' },
+            ],
+        });
+    });
+    test('interface with no methods is valid', () => {
+        const ast = parse(`interface Empty {}`);
+        expect(ast.interfaces).toHaveLength(1);
+        expect(ast.interfaces[0].methods).toHaveLength(0);
+    });
+    test('impl block traitName is set for trait impls', () => {
+        const ast = parse(SPRITE_IMPL_FULL);
+        const implBlock = ast.implBlocks.find(b => b.traitName === 'Drawable');
+        expect(implBlock).toBeDefined();
+        expect(implBlock.typeName).toBe('Sprite');
+    });
+});
+// ---------------------------------------------------------------------------
+// 2. TypeChecker: full implementation passes
+// ---------------------------------------------------------------------------
+describe('interface — typechecker: full implementation', () => {
+    test('full implementation produces no errors', () => {
+        const errors = typeCheck(SPRITE_IMPL_FULL);
+        const ifaceErrors = errors.filter(e => e.message.includes('does not implement'));
+        expect(ifaceErrors).toHaveLength(0);
+    });
+    test('impl without trait name is not interface-checked', () => {
+        const src = `
+      struct Vec2 { x: int, y: int }
+      impl Vec2 { fn len(self: Vec2): int { return self.x } }
+    `;
+        const errors = typeCheck(src);
+        const ifaceErrors = errors.filter(e => e.message.includes('does not implement'));
+        expect(ifaceErrors).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// 3. TypeChecker: missing methods produce errors
+// ---------------------------------------------------------------------------
+describe('interface — typechecker: missing methods', () => {
+    test('missing one method produces one error', () => {
+        const errors = typeCheck(SPRITE_IMPL_MISSING_METHOD);
+        const ifaceErrors = errors.filter(e => e.message.includes('does not implement'));
+        expect(ifaceErrors).toHaveLength(1);
+        expect(ifaceErrors[0].message).toContain("'get_bounds'");
+        expect(ifaceErrors[0].message).toContain('Drawable');
+    });
+    test('missing both methods produces two errors', () => {
+        const errors = typeCheck(SPRITE_IMPL_MISSING_BOTH);
+        const ifaceErrors = errors.filter(e => e.message.includes('does not implement'));
+        expect(ifaceErrors).toHaveLength(2);
+    });
+    test('error message includes struct name', () => {
+        const errors = typeCheck(SPRITE_IMPL_MISSING_METHOD);
+        const ifaceErrors = errors.filter(e => e.message.includes('does not implement'));
+        expect(ifaceErrors[0].message).toContain('Sprite');
+    });
+    test('error message includes interface name', () => {
+        const errors = typeCheck(SPRITE_IMPL_MISSING_METHOD);
+        const ifaceErrors = errors.filter(e => e.message.includes('does not implement'));
+        expect(ifaceErrors[0].message).toContain('Drawable');
+    });
+});
+// ---------------------------------------------------------------------------
+// 4. Multiple structs implementing the same interface
+// ---------------------------------------------------------------------------
+describe('interface — multiple structs', () => {
+    const MULTI_SRC = `
+${DRAWABLE_INTERFACE}
+
+struct Sprite {
+  tile_id: int,
+  width: int,
+  height: int,
+}
+
+struct Particle {
+  size: int,
+}
+
+impl Drawable for Sprite {
+  fn draw(self: Sprite, x: int, y: int) {
+    particle("dust", x, y, 0)
+  }
+  fn get_bounds(self: Sprite): (int, int, int, int) {
+    return (0, 0, self.width, self.height)
+  }
+}
+
+impl Drawable for Particle {
+  fn draw(self: Particle, x: int, y: int) {
+    particle("flame", x, y, 0)
+  }
+  fn get_bounds(self: Particle): (int, int, int, int) {
+    return (0, 0, self.size, self.size)
+  }
+}
+`;
+    test('two full implementations produce no errors', () => {
+        const errors = typeCheck(MULTI_SRC);
+        const ifaceErrors = errors.filter(e => e.message.includes('does not implement'));
+        expect(ifaceErrors).toHaveLength(0);
+    });
+    test('both structs found in AST impl blocks', () => {
+        const ast = parse(MULTI_SRC);
+        const drawableImpls = ast.implBlocks.filter(b => b.traitName === 'Drawable');
+        expect(drawableImpls).toHaveLength(2);
+        const typeNames = drawableImpls.map(b => b.typeName);
+        expect(typeNames).toContain('Sprite');
+        expect(typeNames).toContain('Particle');
+    });
+    test('partial second impl is detected', () => {
+        const src = `
+${DRAWABLE_INTERFACE}
+
+struct Sprite {
+  tile_id: int,
+  width: int,
+  height: int,
+}
+
+struct Particle {
+  size: int,
+}
+
+impl Drawable for Sprite {
+  fn draw(self: Sprite, x: int, y: int) {
+    particle("dust", x, y, 0)
+  }
+  fn get_bounds(self: Sprite): (int, int, int, int) {
+    return (0, 0, self.width, self.height)
+  }
+}
+
+impl Drawable for Particle {
+  fn draw(self: Particle, x: int, y: int) {
+    particle("flame", x, y, 0)
+  }
+}
+`;
+        const errors = typeCheck(src);
+        const ifaceErrors = errors.filter(e => e.message.includes('does not implement'));
+        expect(ifaceErrors).toHaveLength(1);
+        expect(ifaceErrors[0].message).toContain('Particle');
+    });
+});
+//# sourceMappingURL=interface.test.js.map

package/dist/src/__tests__/compiler/labeled-loops.test.d.ts

@@ -0,0 +1 @@
+export {};