redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/compiler/string-advanced.test.js

@@ -0,0 +1,281 @@
+"use strict";
+/**
+ * Tests for enhanced string features:
+ * - Enhanced f-string interpolation (expressions, function calls, array indexing)
+ * - Multi-line triple-quoted strings
+ * - int_to_str / bool_to_str builtin functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+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('test');
+}
+function compileSource(source, namespace = 'test') {
+    return (0, compile_1.compile)(source, { namespace });
+}
+function typeCheck(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens, source).parse('test');
+    const tc = new typechecker_1.TypeChecker(source, 'test');
+    return tc.check(ast);
+}
+// ---------------------------------------------------------------------------
+// Multi-line strings
+// ---------------------------------------------------------------------------
+describe('multi-line triple-quoted strings', () => {
+    test('lexer tokenizes triple-quoted string as string_lit', () => {
+        const tokens = new lexer_1.Lexer('"""Hello\nWorld"""').tokenize();
+        expect(tokens[0].kind).toBe('string_lit');
+        expect(tokens[0].value).toBe('Hello\nWorld');
+    });
+    test('triple-quoted string with leading/trailing newlines is trimmed', () => {
+        const tokens = new lexer_1.Lexer('"""\nHello\nWorld\n"""').tokenize();
+        expect(tokens[0].kind).toBe('string_lit');
+        expect(tokens[0].value).toBe('Hello\nWorld');
+    });
+    test('triple-quoted string compiles in let binding', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let msg: string = """
+Hello
+World
+"""
+        say(msg)
+      }
+    `)).not.toThrow();
+    });
+    test('typechecker accepts triple-quoted string as string type', () => {
+        const errors = typeCheck(`
+fn test() {
+  let msg: string = """
+  Hello
+  World
+  """
+}
+`);
+        expect(errors).toHaveLength(0);
+    });
+    test('triple-quoted string with interpolation content parses correctly', () => {
+        const ast = parse(`
+fn test() {
+  let s: string = """Line 1
+Line 2"""
+}
+`);
+        expect(ast.declarations).toHaveLength(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// Enhanced f-string interpolation
+// ---------------------------------------------------------------------------
+describe('enhanced f-string interpolation', () => {
+    test('f-string with simple variable compiles', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let x: int = 5
+        tellraw(@a, f"Value: {x}")
+      }
+    `)).not.toThrow();
+    });
+    test('f-string with binary expression compiles', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let x: int = 5
+        tellraw(@a, f"Result: {x + 1}")
+      }
+    `)).not.toThrow();
+    });
+    test('f-string with arithmetic expression compiles', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let a: int = 3
+        let b: int = 4
+        tellraw(@a, f"Product: {a * b}")
+      }
+    `)).not.toThrow();
+    });
+    test('f-string with function call expression compiles', () => {
+        expect(() => compileSource(`
+      fn double(n: int): int {
+        return n * 2
+      }
+      fn test() {
+        let x: int = 5
+        tellraw(@a, f"Doubled: {double(x)}")
+      }
+    `)).not.toThrow();
+    });
+    test('f-string passes MIR verification with expression interpolation', () => {
+        const source = `
+      fn test() {
+        let x: int = 5
+        tellraw(@a, f"Result: {x + 1}")
+      }
+    `;
+        const ast = parse(source);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const mir = (0, lower_2.lowerToMIR)(hir);
+        expect((0, verify_1.verifyMIR)(mir)).toEqual([]);
+    });
+    test('f-string with multiple complex parts compiles', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let a: int = 3
+        let b: int = 4
+        tellraw(@a, f"Sum: {a + b}, Product: {a * b}")
+      }
+    `)).not.toThrow();
+    });
+    test('f-string with text-only parts still works', () => {
+        expect(() => compileSource(`
+      fn test() {
+        tellraw(@a, f"Hello World")
+      }
+    `)).not.toThrow();
+    });
+    test('f-string generates JSON text component with score reference for ident', () => {
+        const source = `
+      fn test() {
+        let score: int = 10
+        tellraw(@a, f"Score: {score}")
+      }
+    `;
+        const result = compileSource(source, 'myns');
+        // result is CompileResult with .files array of { path, content }
+        const allContent = result.files.map(f => f.content).join('\n');
+        expect(allContent).toContain('tellraw');
+        // Should contain a JSON text component with 'text' or 'score'
+        expect(allContent.includes('score') || allContent.includes('text')).toBe(true);
+    });
+    test('f-string with expression generates precomputed temp in MIR', () => {
+        const source = `
+      fn test() {
+        let x: int = 5
+        tellraw(@a, f"Val: {x + 1}")
+      }
+    `;
+        const ast = parse(source);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const mir = (0, lower_2.lowerToMIR)(hir);
+        const fn = mir.functions.find(f => f.name === 'test');
+        expect(fn).toBeDefined();
+        // Should have emitted arithmetic instructions for x + 1
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        // MIR arithmetic uses 'add', 'sub', 'mul', etc. (not 'arith')
+        const arithInstrs = allInstrs.filter(i => ['add', 'sub', 'mul', 'div'].includes(i.kind));
+        expect(arithInstrs.length).toBeGreaterThan(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// int_to_str and bool_to_str
+// ---------------------------------------------------------------------------
+describe('int_to_str builtin', () => {
+    test('int_to_str is accepted by typechecker', () => {
+        const errors = typeCheck(`
+fn test() {
+  let n: int = 42
+  let s: string = int_to_str(n)
+}
+`);
+        expect(errors).toHaveLength(0);
+    });
+    test('int_to_str in f-string compiles', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let n: int = 42
+        tellraw(@a, f"Value: {int_to_str(n)}")
+      }
+    `)).not.toThrow();
+    });
+    test('int_to_str standalone compiles', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let n: int = 42
+        let s: string = int_to_str(n)
+      }
+    `)).not.toThrow();
+    });
+    test('int_to_str passes MIR verification', () => {
+        const source = `
+      fn test() {
+        let n: int = 42
+        let s: string = int_to_str(n)
+      }
+    `;
+        const ast = parse(source);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const mir = (0, lower_2.lowerToMIR)(hir);
+        expect((0, verify_1.verifyMIR)(mir)).toEqual([]);
+    });
+});
+describe('bool_to_str builtin', () => {
+    test('bool_to_str is accepted by typechecker', () => {
+        const errors = typeCheck(`
+fn test() {
+  let b: bool = true
+  let s: string = bool_to_str(b)
+}
+`);
+        expect(errors).toHaveLength(0);
+    });
+    test('bool_to_str in f-string compiles', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let b: bool = true
+        tellraw(@a, f"Active: {bool_to_str(b)}")
+      }
+    `)).not.toThrow();
+    });
+    test('bool_to_str passes MIR verification', () => {
+        const source = `
+      fn test() {
+        let b: bool = false
+        let s: string = bool_to_str(b)
+      }
+    `;
+        const ast = parse(source);
+        const hir = (0, lower_1.lowerToHIR)(ast);
+        const mir = (0, lower_2.lowerToMIR)(hir);
+        expect((0, verify_1.verifyMIR)(mir)).toEqual([]);
+    });
+    test('bool_to_str in title builtin compiles', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let active: bool = true
+        title(@a, f"Active: {bool_to_str(active)}")
+      }
+    `)).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// Integration: combined features
+// ---------------------------------------------------------------------------
+describe('combined string features', () => {
+    test('multi-line string with f-string expression compiles', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let x: int = 10
+        let msg: string = """Hello World"""
+        tellraw(@a, f"Score: {x + 5}")
+      }
+    `)).not.toThrow();
+    });
+    test('int_to_str and f-string with arithmetic in same function', () => {
+        expect(() => compileSource(`
+      fn test() {
+        let n: int = 5
+        let doubled: int = n * 2
+        let s: string = int_to_str(doubled)
+        tellraw(@a, f"Value: {n + 1}, Doubled str: {int_to_str(n * 2)}")
+      }
+    `)).not.toThrow();
+    });
+});
+//# sourceMappingURL=string-advanced.test.js.map

package/dist/src/__tests__/compiler/struct-extends.test.d.ts

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

package/dist/src/__tests__/compiler/struct-extends.test.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+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('test');
+}
+function typeCheck(source) {
+    const program = parse(source);
+    return new typechecker_1.TypeChecker(source).check(program);
+}
+describe('struct-extends: parser', () => {
+    test('parses extends clause on struct declarations', () => {
+        const program = parse(`
+      struct Animal { name: string, hp: int }
+      struct Dog extends Animal { breed: string }
+    `);
+        expect(program.structs).toHaveLength(2);
+        expect(program.structs[1].name).toBe('Dog');
+        expect(program.structs[1].extends).toBe('Animal');
+        expect(program.structs[1].fields.map(field => field.name)).toEqual(['breed']);
+    });
+});
+describe('struct-extends: HIR lowering', () => {
+    test('expands inherited fields before child fields', () => {
+        const hir = (0, lower_1.lowerToHIR)(parse(`
+      struct Animal { name: string, hp: int }
+      struct Dog extends Animal { breed: string }
+    `));
+        expect(hir.structs[1].fields.map(field => field.name)).toEqual(['name', 'hp', 'breed']);
+    });
+    test('expands multi-level inheritance transitively', () => {
+        const hir = (0, lower_1.lowerToHIR)(parse(`
+      struct Base { id: int }
+      struct Animal extends Base { hp: int }
+      struct Dog extends Animal { breed: string }
+    `));
+        expect(hir.structs[2].fields.map(field => field.name)).toEqual(['id', 'hp', 'breed']);
+    });
+});
+describe('struct-extends: typechecker', () => {
+    test('accepts inherited fields in struct literals', () => {
+        const errors = typeCheck(`
+      struct Animal { name: string, hp: int }
+      struct Dog extends Animal { breed: string }
+      fn make(): Dog {
+        return Dog { name: "Rex", hp: 10, breed: "Corgi" }
+      }
+    `);
+        expect(errors).toHaveLength(0);
+    });
+    test('accepts multi-level inherited field access', () => {
+        const errors = typeCheck(`
+      struct Base { id: int }
+      struct Animal extends Base { hp: int }
+      struct Dog extends Animal { breed: string }
+      fn id_of(d: Dog): int {
+        return d.id
+      }
+    `);
+        expect(errors).toHaveLength(0);
+    });
+    test('reports overriding an inherited field', () => {
+        const errors = typeCheck(`
+      struct Animal { name: string, hp: int }
+      struct Dog extends Animal { hp: int, breed: string }
+    `);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain("Struct 'Dog' cannot override inherited field 'hp'");
+    });
+    test('reports unknown parent struct', () => {
+        const errors = typeCheck(`
+      struct Dog extends Animal { breed: string }
+    `);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain("Struct 'Dog' extends unknown struct 'Animal'");
+    });
+});
+describe('struct-extends: compile', () => {
+    test('compiles inherited structs as flattened plain structs', () => {
+        expect(() => (0, compile_1.compile)(`
+      struct Animal { name: string, hp: int }
+      struct Dog extends Animal { breed: string }
+      @keep fn main(): void {
+        let dog: Dog = Dog { name: "Rex", hp: 10, breed: "Corgi" }
+        let hp: int = dog.hp
+      }
+    `, { namespace: 'test' })).not.toThrow();
+    });
+});
+//# sourceMappingURL=struct-extends.test.js.map

package/dist/src/__tests__/compiler/throttle-retry.test.d.ts

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

package/dist/src/__tests__/compiler/throttle-retry.test.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const typechecker_1 = require("../../typechecker");
+function getFile(files, path) {
+    const file = files.find(entry => entry.path === path);
+    if (!file) {
+        throw new Error(`Missing file: ${path}\nFiles:\n${files.map(entry => entry.path).join('\n')}`);
+    }
+    return file.content;
+}
+function parseDecorators(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    return ast.declarations[0]?.decorators ?? [];
+}
+function typeCheck(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    return new typechecker_1.TypeChecker(source).check(ast);
+}
+// ---------------------------------------------------------------------------
+// @throttle tests
+// ---------------------------------------------------------------------------
+describe('@throttle decorator', () => {
+    test('parser records @throttle with ticks argument', () => {
+        const decorators = parseDecorators(`
+      @throttle(ticks=20)
+      fn on_player_move() {}
+    `);
+        expect(decorators).toHaveLength(1);
+        expect(decorators[0].name).toBe('throttle');
+        expect(decorators[0].args?.ticks).toBe(20);
+    });
+    test('typechecker rejects @throttle without ticks argument', () => {
+        const errors = typeCheck(`
+      @throttle(ticks=0)
+      fn on_player_move() {}
+    `);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('@throttle');
+    });
+    test('typechecker rejects duplicate @throttle decorators', () => {
+        const errors = typeCheck(`
+      @throttle(ticks=10)
+      @throttle(ticks=20)
+      fn on_player_move() {}
+    `);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('multiple @throttle');
+    });
+    test('typechecker accepts valid @throttle decorator', () => {
+        const errors = typeCheck(`
+      @throttle(ticks=20)
+      fn on_player_move() {}
+    `);
+        expect(errors).toHaveLength(0);
+    });
+    test('emits throttle objective in load.mcfunction', () => {
+        const result = (0, compile_1.compile)(`
+      @throttle(ticks=20)
+      fn on_player_move() {
+        say("moved");
+      }
+    `, { namespace: 'throttle_test' });
+        const load = getFile(result.files, 'data/throttle_test/function/load.mcfunction');
+        expect(load).toContain('scoreboard objectives add __throttle dummy');
+    });
+    test('emits throttle dispatcher mcfunction with correct scoreboard commands', () => {
+        const result = (0, compile_1.compile)(`
+      @throttle(ticks=20)
+      fn on_player_move() {
+        say("moved");
+      }
+    `, { namespace: 'throttle_test' });
+        const dispatcher = getFile(result.files, 'data/throttle_test/function/__throttle_on_player_move.mcfunction');
+        expect(dispatcher).toContain('scoreboard players add __throttle_on_player_move __throttle 1');
+        expect(dispatcher).toContain('execute if score __throttle_on_player_move __throttle matches 20.. run function throttle_test:on_player_move_inner');
+        expect(dispatcher).toContain('execute if score __throttle_on_player_move __throttle matches 20.. run scoreboard players set __throttle_on_player_move __throttle 0');
+    });
+    test('registers throttle dispatcher in tick.json', () => {
+        const result = (0, compile_1.compile)(`
+      @throttle(ticks=20)
+      fn on_player_move() {
+        say("moved");
+      }
+    `, { namespace: 'throttle_test' });
+        const tick = JSON.parse(getFile(result.files, 'data/minecraft/tags/function/tick.json'));
+        expect(tick.values).toContain('throttle_test:__throttle_on_player_move');
+    });
+});
+// ---------------------------------------------------------------------------
+// @retry tests
+// ---------------------------------------------------------------------------
+describe('@retry decorator', () => {
+    test('parser records @retry with max argument', () => {
+        const decorators = parseDecorators(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `);
+        expect(decorators).toHaveLength(1);
+        expect(decorators[0].name).toBe('retry');
+        expect(decorators[0].args?.max).toBe(3);
+    });
+    test('typechecker rejects @retry without max argument', () => {
+        const errors = typeCheck(`
+      @retry(max=0)
+      fn try_spawn_mob(): int { 0 }
+    `);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('@retry');
+    });
+    test('typechecker rejects duplicate @retry decorators', () => {
+        const errors = typeCheck(`
+      @retry(max=3)
+      @retry(max=5)
+      fn try_spawn_mob(): int { 0 }
+    `);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('multiple @retry');
+    });
+    test('typechecker accepts valid @retry decorator', () => {
+        const errors = typeCheck(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `);
+        expect(errors).toHaveLength(0);
+    });
+    test('emits retry objective in load.mcfunction', () => {
+        const result = (0, compile_1.compile)(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `, { namespace: 'retry_test' });
+        const load = getFile(result.files, 'data/retry_test/function/load.mcfunction');
+        expect(load).toContain('scoreboard objectives add __retry dummy');
+    });
+    test('emits retry dispatcher mcfunction with correct scoreboard commands', () => {
+        const result = (0, compile_1.compile)(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `, { namespace: 'retry_test' });
+        const dispatcher = getFile(result.files, 'data/retry_test/function/__retry_try_spawn_mob.mcfunction');
+        expect(dispatcher).toContain('execute if score __retry_try_spawn_mob __retry matches 1.. run function retry_test:try_spawn_mob');
+        expect(dispatcher).toContain('execute if score __retry_try_spawn_mob __retry matches 1.. if score $ret __retry matches 0 run scoreboard players remove __retry_try_spawn_mob __retry 1');
+        expect(dispatcher).toContain('execute if score __retry_try_spawn_mob __retry matches 1.. unless score $ret __retry matches 0 run scoreboard players set __retry_try_spawn_mob __retry 0');
+    });
+    test('emits retry start helper function with max count', () => {
+        const result = (0, compile_1.compile)(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `, { namespace: 'retry_test' });
+        const start = getFile(result.files, 'data/retry_test/function/try_spawn_mob_start.mcfunction');
+        expect(start).toContain('scoreboard players set __retry_try_spawn_mob __retry 3');
+    });
+    test('registers retry dispatcher in tick.json', () => {
+        const result = (0, compile_1.compile)(`
+      @retry(max=3)
+      fn try_spawn_mob(): int { 0 }
+    `, { namespace: 'retry_test' });
+        const tick = JSON.parse(getFile(result.files, 'data/minecraft/tags/function/tick.json'));
+        expect(tick.values).toContain('retry_test:__retry_try_spawn_mob');
+    });
+});
+//# sourceMappingURL=throttle-retry.test.js.map

package/dist/src/__tests__/compiler/tuple-type.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for tuple types and destructuring.
+ *
+ * RedScript supports:
+ *   - Tuple type annotations:  (int, int)
+ *   - Tuple literal expressions: (a, b)
+ *   - Destructuring let-bindings: let (lo, hi) = expr
+ *   - Functions that return tuples: fn foo(): (int, int) { return (a, b) }
+ */
+export {};