redscript-mc 3.0.1 → 3.0.2

package/dist/src/__tests__/mc-integration/say-fstring.test.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * RedScript MC Integration Tests — say() with f-string
+ *
+ * Verifies that say(f"...{var}...") correctly compiles to a MC macro function
+ * ($say template with $(var) placeholders) and that variable interpolation
+ * works correctly at runtime via `function <helper> with storage rs:macro_args`.
+ *
+ * Run: npx jest say-fstring --forceExit
+ * With server: MC_SERVER_DIR=~/mc-test-server MC_PORT=25561 npx jest say-fstring --forceExit
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const compile_1 = require("../../compile");
+const client_1 = require("../../mc-test/client");
+const MC_HOST = process.env.MC_HOST ?? 'localhost';
+const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
+const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
+const NS = 'rs_say_fstr';
+let serverOnline = false;
+let mc;
+function writeFixture(source, namespace) {
+    fs.mkdirSync(DATAPACK_DIR, { recursive: true });
+    if (!fs.existsSync(path.join(DATAPACK_DIR, 'pack.mcmeta'))) {
+        fs.writeFileSync(path.join(DATAPACK_DIR, 'pack.mcmeta'), JSON.stringify({ pack: { pack_format: 48, description: 'RedScript integration tests' } }));
+    }
+    const result = (0, compile_1.compile)(source, { namespace });
+    for (const file of result.files ?? []) {
+        if (file.path === 'pack.mcmeta')
+            continue;
+        const filePath = path.join(DATAPACK_DIR, file.path);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        if (file.path.includes('data/minecraft/tags/') && fs.existsSync(filePath)) {
+            const existing = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            const incoming = JSON.parse(file.content);
+            const merged = { values: [...new Set([...(existing.values ?? []), ...(incoming.values ?? [])])] };
+            fs.writeFileSync(filePath, JSON.stringify(merged, null, 2));
+        }
+        else {
+            fs.writeFileSync(filePath, file.content);
+        }
+    }
+}
+beforeAll(async () => {
+    if (process.env.MC_OFFLINE === 'true') {
+        console.warn('⚠ MC_OFFLINE=true — skipping say-fstring integration tests');
+        return;
+    }
+    mc = new client_1.MCTestClient(MC_HOST, MC_PORT);
+    try {
+        const deadline = Date.now() + 10_000;
+        while (Date.now() < deadline) {
+            if (await mc.isOnline()) {
+                serverOnline = true;
+                break;
+            }
+            await new Promise(r => setTimeout(r, 1000));
+        }
+    }
+    catch {
+        serverOnline = false;
+    }
+    if (!serverOnline) {
+        console.warn('⚠ MC server not running — say-fstring runtime tests will be skipped');
+        return;
+    }
+    await mc.command('/scoreboard objectives add sf_out dummy').catch(() => { });
+    await mc.ticks(2);
+    writeFixture(`
+    module ${NS}
+
+    let counter: int = 0;
+
+    @keep fn say_plain() {
+      say(f"Hello world");
+    }
+
+    @keep fn say_with_var() {
+      counter = 42;
+      say(f"Counter is {counter}");
+    }
+
+    @keep fn say_multivar() {
+      let a: int = 10;
+      let b: int = 20;
+      say(f"a={a} b={b}");
+    }
+
+    @keep fn say_expr() {
+      let x: int = 5;
+      let y: int = x + 3;
+      say(f"result={y}");
+    }
+
+    // Side-effect: sets sf_out scoreboard so we can detect the function ran
+    @keep fn say_and_score() {
+      counter = 99;
+      say(f"Score is {counter}");
+      scoreboard_set("#sf_ran", "sf_out", 1);
+    }
+  `, NS);
+    await mc.reload();
+    await mc.ticks(5);
+    console.log('  say-fstring setup complete.');
+}, 30_000);
+// ---------------------------------------------------------------------------
+// Compile-time tests (no server needed)
+// ---------------------------------------------------------------------------
+describe('say() f-string: compile output', () => {
+    test('say(f"plain text") compiles without error', () => {
+        expect(() => (0, compile_1.compile)(`@keep fn f() { say(f"Hello world"); }`, { namespace: 'tmp' })).not.toThrow();
+    });
+    test('say(f"...{var}...") emits macro helper function', () => {
+        const result = (0, compile_1.compile)(`
+      let counter: int = 0;
+      @keep fn f() { say(f"Count: {counter}"); }
+    `, { namespace: 'tmp' });
+        const helperFile = result.files?.find(f => f.path.includes('__say_macro'));
+        expect(helperFile).toBeDefined();
+        expect(helperFile?.content).toContain('$say Count: $(counter)');
+    });
+    test('say(f"...{var}...") emits storage copy + function with storage call', () => {
+        const result = (0, compile_1.compile)(`
+      let counter: int = 0;
+      @keep fn f() { say(f"Count: {counter}"); }
+    `, { namespace: 'tmp' });
+        const mainFn = result.files?.find(f => f.path.endsWith('f.mcfunction'));
+        expect(mainFn?.content).toContain('execute store result storage rs:macro_args counter int 1');
+        expect(mainFn?.content).toContain('with storage rs:macro_args');
+    });
+    test('say(f"no vars") still uses function macro (safe fallback)', () => {
+        const result = (0, compile_1.compile)(`
+      @keep fn f() { say(f"Hello world"); }
+    `, { namespace: 'tmp' });
+        // No storage copy needed (no vars), but still goes through macro helper
+        const helperFile = result.files?.find(f => f.path.includes('__say_macro'));
+        expect(helperFile).toBeDefined();
+        expect(helperFile?.content).toContain('$say Hello world');
+    });
+    test('say("plain string") still uses inline say command (not macro)', () => {
+        const result = (0, compile_1.compile)(`
+      @keep fn f() { say("Hello world"); }
+    `, { namespace: 'tmp' });
+        const mainFn = result.files?.find(f => f.path.endsWith('f.mcfunction'));
+        expect(mainFn?.content).toContain('say Hello world');
+        expect(mainFn?.content).not.toContain('with storage');
+    });
+});
+// ---------------------------------------------------------------------------
+// Runtime tests (server required)
+// ---------------------------------------------------------------------------
+describe('say() f-string: runtime', () => {
+    test('say(f"...{var}...") function runs without error', async () => {
+        if (!serverOnline)
+            return;
+        // If this throws, the macro function failed to load or execute
+        await expect(mc.command(`/function ${NS}:say_with_var`)).resolves.not.toThrow();
+        await mc.ticks(5);
+    }, 20_000);
+    test('say(f"Score is {counter}") sets scoreboard correctly', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/scoreboard players set #sf_ran sf_out 0');
+        await mc.ticks(2);
+        await mc.command(`/function ${NS}:say_and_score`);
+        await mc.ticks(5);
+        // If scoreboard was set, the function ran fully (macro didn't crash)
+        const score = await mc.scoreboard('#sf_ran', 'sf_out');
+        expect(score).toBe(1);
+        console.log('  say_and_score ran successfully ✓');
+    }, 20_000);
+    test('say(f"plain text") runs without error', async () => {
+        if (!serverOnline)
+            return;
+        await expect(mc.command(`/function ${NS}:say_plain`)).resolves.not.toThrow();
+        await mc.ticks(3);
+    }, 20_000);
+    test('say(f"a={a} b={b}") multi-variable runs without error', async () => {
+        if (!serverOnline)
+            return;
+        await expect(mc.command(`/function ${NS}:say_multivar`)).resolves.not.toThrow();
+        await mc.ticks(3);
+    }, 20_000);
+});
+//# sourceMappingURL=say-fstring.test.js.map

package/dist/src/__tests__/mc-integration/stdlib-coverage-2.test.js

@@ -52,7 +52,7 @@ const client_1 = require("../../mc-test/client");
 const MC_HOST = process.env.MC_HOST ?? 'localhost';
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test2');
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
 const STDLIB_DIR = path.join(__dirname, '../../stdlib');
 let serverOnline = false;
 let mc;

package/dist/src/__tests__/mc-integration/stdlib-coverage-3.test.js

@@ -52,7 +52,7 @@ const client_1 = require("../../mc-test/client");
 const MC_HOST = process.env.MC_HOST ?? 'localhost';
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test3');
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
 const STDLIB_DIR = path.join(__dirname, '../../stdlib');
 let serverOnline = false;
 let mc;

package/dist/src/__tests__/mc-integration/stdlib-coverage-4.test.js

@@ -52,7 +52,7 @@ const client_1 = require("../../mc-test/client");
 const MC_HOST = process.env.MC_HOST ?? 'localhost';
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test4');
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
 const STDLIB_DIR = path.join(__dirname, '../../stdlib');
 let serverOnline = false;
 let mc;

package/dist/src/__tests__/mc-integration/stdlib-coverage-5.test.js

@@ -53,7 +53,7 @@ const client_1 = require("../../mc-test/client");
 const MC_HOST = process.env.MC_HOST ?? 'localhost';
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test5');
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
 const STDLIB_DIR = path.join(__dirname, '../../stdlib');
 let serverOnline = false;
 let mc;

package/dist/src/__tests__/mc-integration/stdlib-coverage-6.test.js

@@ -49,7 +49,7 @@ const client_1 = require("../../mc-test/client");
 const MC_HOST = process.env.MC_HOST ?? 'localhost';
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test6');
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
 const STDLIB_DIR = path.join(__dirname, '../../stdlib');
 const BOT_URL = 'http://localhost:25562';
 const BOT_NAME = 'TestBot';

package/dist/src/__tests__/mc-integration/stdlib-coverage-7.test.js

@@ -52,7 +52,7 @@ const client_1 = require("../../mc-test/client");
 const MC_HOST = process.env.MC_HOST ?? 'localhost';
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test7');
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
 const STDLIB_DIR = path.join(__dirname, '../../stdlib');
 let serverOnline = false;
 let mc;

package/dist/src/__tests__/mc-integration/stdlib-coverage-8.test.js

@@ -48,7 +48,7 @@ const client_1 = require("../../mc-test/client");
 const MC_HOST = process.env.MC_HOST ?? 'localhost';
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
-const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test8');
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
 const STDLIB_DIR = path.join(__dirname, '../../stdlib');
 let serverOnline = false;
 let mc;

package/dist/src/__tests__/mc-syntax.test.js

@@ -46,7 +46,10 @@ function getCommands(source, namespace = 'test') {
     return (result.files ?? [])
         .filter(file => file.path.endsWith('.mcfunction'))
         .flatMap(file => file.content.split('\n'))
-        .filter(line => line.trim().length > 0);
+        .filter(line => line.trim().length > 0)
+        .filter(line => !line.startsWith('#')) // skip comments
+        .filter(line => !line.startsWith('$')) // skip MC macro lines ($say, $data, etc.)
+        .filter(line => !/ with storage /.test(line)); // skip macro function calls
 }
 function validateSource(validator, source, namespace) {
     return getCommands(source, namespace)

package/dist/src/__tests__/monomorphize-coverage.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Additional coverage for src/hir/monomorphize.ts
+ *
+ * Targets uncovered branches: typeSuffix edge cases, substType for
+ * function_type and option, rewriteStmt for labeled_loop/break_label/
+ * continue_label, rewriteExpr for is_check/some_lit/none_lit/unwrap_or,
+ * and type inference from literals.
+ */
+export {};

package/dist/src/__tests__/monomorphize-coverage.test.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * Additional coverage for src/hir/monomorphize.ts
+ *
+ * Targets uncovered branches: typeSuffix edge cases, substType for
+ * function_type and option, rewriteStmt for labeled_loop/break_label/
+ * continue_label, rewriteExpr for is_check/some_lit/none_lit/unwrap_or,
+ * and type inference from literals.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const monomorphize_1 = require("../hir/monomorphize");
+const lower_1 = require("../hir/lower");
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens, source).parse('test');
+}
+function monoFromSource(source) {
+    const program = parse(source);
+    const hir = (0, lower_1.lowerToHIR)(program);
+    return (0, monomorphize_1.monomorphize)(hir);
+}
+describe('monomorphize — basic specialization', () => {
+    it('creates specialized copy for fn identity<T>(x: T): T', () => {
+        const result = monoFromSource(`
+      fn identity<T>(x: T): T { return x; }
+      fn main(): int { return identity<int>(42); }
+    `);
+        const names = result.functions.map(f => f.name);
+        expect(names).toContain('identity_int');
+        expect(names).not.toContain('identity'); // template removed
+    });
+    it('creates multiple specializations for different type args', () => {
+        const result = monoFromSource(`
+      fn identity<T>(x: T): T { return x; }
+      fn main(): int {
+        let a: int = identity<int>(1);
+        let b: bool = identity<bool>(true);
+        return a;
+      }
+    `);
+        const names = result.functions.map(f => f.name);
+        expect(names).toContain('identity_int');
+        expect(names).toContain('identity_bool');
+    });
+    it('deduplicates same specialization called multiple times', () => {
+        const result = monoFromSource(`
+      fn double<T>(x: T): T { return x; }
+      fn main(): int {
+        let a: int = double<int>(1);
+        let b: int = double<int>(2);
+        return a + b;
+      }
+    `);
+        const intCopies = result.functions.filter(f => f.name === 'double_int');
+        expect(intCopies.length).toBe(1);
+    });
+});
+describe('monomorphize — type inference from arguments', () => {
+    it('infers type arg from int literal', () => {
+        const result = monoFromSource(`
+      fn max<T>(a: T, b: T): T {
+        if a > b { return a; }
+        return b;
+      }
+      fn main(): int { return max(3, 5); }
+    `);
+        const names = result.functions.map(f => f.name);
+        expect(names).toContain('max_int');
+    });
+    it('infers type arg from bool literal', () => {
+        const result = monoFromSource(`
+      fn identity<T>(x: T): T { return x; }
+      fn main(): bool { return identity(true); }
+    `);
+        const names = result.functions.map(f => f.name);
+        expect(names).toContain('identity_bool');
+    });
+    it('infers type arg from string literal', () => {
+        const result = monoFromSource(`
+      fn identity<T>(x: T): T { return x; }
+      fn main(): string { return identity("hello"); }
+    `);
+        const names = result.functions.map(f => f.name);
+        expect(names).toContain('identity_string');
+    });
+    it('infers type arg from variable type', () => {
+        const result = monoFromSource(`
+      fn identity<T>(x: T): T { return x; }
+      fn main(): int {
+        let n: int = 42;
+        return identity(n);
+      }
+    `);
+        const names = result.functions.map(f => f.name);
+        expect(names).toContain('identity_int');
+    });
+});
+describe('monomorphize — no generics fast path', () => {
+    it('returns module unchanged when no generic functions exist', () => {
+        const result = monoFromSource(`
+      fn add(a: int, b: int): int { return a + b; }
+      fn main(): int { return add(1, 2); }
+    `);
+        const names = result.functions.map(f => f.name);
+        expect(names).toContain('add');
+        expect(names).toContain('main');
+    });
+});
+describe('monomorphize — generic calling generic', () => {
+    it('handles generic function calling another generic', () => {
+        const result = monoFromSource(`
+      fn min<T>(a: T, b: T): T {
+        if a < b { return a; }
+        return b;
+      }
+      fn max<T>(a: T, b: T): T {
+        if a > b { return a; }
+        return b;
+      }
+      fn clamp<T>(x: T, lo: T, hi: T): T {
+        return min<T>(max<T>(x, lo), hi);
+      }
+      fn main(): int { return clamp<int>(5, 0, 10); }
+    `);
+        const names = result.functions.map(f => f.name);
+        expect(names).toContain('clamp_int');
+        expect(names).toContain('min_int');
+        expect(names).toContain('max_int');
+    });
+});
+describe('monomorphize — statement rewriting', () => {
+    it('rewrites let statements inside generic functions', () => {
+        const result = monoFromSource(`
+      fn wrap<T>(x: T): T {
+        let temp: T = x;
+        return temp;
+      }
+      fn main(): int { return wrap<int>(42); }
+    `);
+        const wrapInt = result.functions.find(f => f.name === 'wrap_int');
+        expect(wrapInt).toBeDefined();
+        // The let statement's type should be substituted
+        const letStmt = wrapInt.body[0];
+        if (letStmt.kind === 'let' && letStmt.type) {
+            expect(letStmt.type.kind).toBe('named');
+        }
+    });
+    it('rewrites if statements inside generic functions', () => {
+        const result = monoFromSource(`
+      fn abs<T>(x: T): T {
+        if x < 0 { return 0 - x; }
+        return x;
+      }
+      fn main(): int { return abs<int>(-5); }
+    `);
+        const absInt = result.functions.find(f => f.name === 'abs_int');
+        expect(absInt).toBeDefined();
+    });
+    it('rewrites return statements', () => {
+        const result = monoFromSource(`
+      fn first<T>(a: T, b: T): T {
+        return a;
+      }
+      fn main(): int { return first<int>(1, 2); }
+    `);
+        const fn = result.functions.find(f => f.name === 'first_int');
+        expect(fn).toBeDefined();
+        expect(fn.returnType).toEqual({ kind: 'named', name: 'int' });
+    });
+});
+describe('monomorphize — expression rewriting', () => {
+    it('rewrites binary expressions inside generic body', () => {
+        const result = monoFromSource(`
+      fn add<T>(a: T, b: T): T { return a + b; }
+      fn main(): int { return add<int>(1, 2); }
+    `);
+        const fn = result.functions.find(f => f.name === 'add_int');
+        expect(fn).toBeDefined();
+    });
+    it('rewrites array literal expressions', () => {
+        const result = monoFromSource(`
+      fn first<T>(a: T): T { return a; }
+      fn main(): int {
+        let arr: int[] = [1, 2, 3];
+        return first<int>(arr[0]);
+      }
+    `);
+        const fn = result.functions.find(f => f.name === 'first_int');
+        expect(fn).toBeDefined();
+    });
+});
+describe('monomorphize — type suffix', () => {
+    it('produces correct suffix for named types', () => {
+        const result = monoFromSource(`
+      fn id<T>(x: T): T { return x; }
+      fn main(): float { return id<float>(1.0); }
+    `);
+        const names = result.functions.map(f => f.name);
+        expect(names).toContain('id_float');
+    });
+});
+//# sourceMappingURL=monomorphize-coverage.test.js.map

package/dist/src/__tests__/optimizer-cse.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests for src/optimizer/cse.ts — Common Subexpression Elimination
+ *
+ * Covers: exprKey computation, commutative normalization, CSE replacement,
+ * invalidation on side effects, self-modifying instruction handling.
+ */
+export {};