redscript-mc 3.0.1 → 3.0.2

package/dist/src/__tests__/optimizer-cse.test.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * Tests for src/optimizer/cse.ts — Common Subexpression Elimination
+ *
+ * Covers: exprKey computation, commutative normalization, CSE replacement,
+ * invalidation on side effects, self-modifying instruction handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cse_1 = require("../optimizer/cse");
+function temp(name) {
+    return name;
+}
+function tempOp(name) {
+    return { kind: 'temp', name };
+}
+function constOp(value) {
+    return { kind: 'const', value };
+}
+function makeBlock(instrs) {
+    return { id: 'b0', instrs, term: { kind: 'return' }, preds: [] };
+}
+function makeFn(blocks) {
+    return {
+        name: 'test',
+        params: [],
+        returnType: { kind: 'named', name: 'void' },
+        blocks,
+        temps: [],
+    };
+}
+describe('CSE — basic elimination', () => {
+    it('replaces duplicate add with copy', () => {
+        const block = makeBlock([
+            { kind: 'add', dst: temp('t1'), a: tempOp('t0'), b: constOp(1) },
+            { kind: 'add', dst: temp('t2'), a: tempOp('t0'), b: constOp(1) },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        const instrs = result.blocks[0].instrs;
+        expect(instrs[0].kind).toBe('add');
+        expect(instrs[1].kind).toBe('copy');
+        if (instrs[1].kind === 'copy') {
+            expect(instrs[1].dst).toBe('t2');
+            expect(instrs[1].src).toEqual(tempOp('t1'));
+        }
+    });
+    it('replaces duplicate sub with copy', () => {
+        const block = makeBlock([
+            { kind: 'sub', dst: temp('t1'), a: tempOp('t0'), b: constOp(2) },
+            { kind: 'sub', dst: temp('t2'), a: tempOp('t0'), b: constOp(2) },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[1].kind).toBe('copy');
+    });
+    it('replaces duplicate mul with copy', () => {
+        const block = makeBlock([
+            { kind: 'mul', dst: temp('t1'), a: tempOp('x'), b: tempOp('y') },
+            { kind: 'mul', dst: temp('t2'), a: tempOp('x'), b: tempOp('y') },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[1].kind).toBe('copy');
+    });
+    it('replaces duplicate neg with copy', () => {
+        const block = makeBlock([
+            { kind: 'neg', dst: temp('t1'), src: tempOp('t0') },
+            { kind: 'neg', dst: temp('t2'), src: tempOp('t0') },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[1].kind).toBe('copy');
+    });
+    it('replaces duplicate not with copy', () => {
+        const block = makeBlock([
+            { kind: 'not', dst: temp('t1'), src: tempOp('t0') },
+            { kind: 'not', dst: temp('t2'), src: tempOp('t0') },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[1].kind).toBe('copy');
+    });
+    it('replaces duplicate cmp with copy', () => {
+        const block = makeBlock([
+            { kind: 'cmp', dst: temp('t1'), op: 'lt', a: tempOp('x'), b: tempOp('y') },
+            { kind: 'cmp', dst: temp('t2'), op: 'lt', a: tempOp('x'), b: tempOp('y') },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[1].kind).toBe('copy');
+    });
+});
+describe('CSE — commutative normalization', () => {
+    it('treats a+b and b+a as same expression', () => {
+        const block = makeBlock([
+            { kind: 'add', dst: temp('t1'), a: tempOp('x'), b: tempOp('y') },
+            { kind: 'add', dst: temp('t2'), a: tempOp('y'), b: tempOp('x') },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[1].kind).toBe('copy');
+    });
+    it('treats a*b and b*a as same expression', () => {
+        const block = makeBlock([
+            { kind: 'mul', dst: temp('t1'), a: tempOp('x'), b: tempOp('y') },
+            { kind: 'mul', dst: temp('t2'), a: tempOp('y'), b: tempOp('x') },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[1].kind).toBe('copy');
+    });
+    it('does NOT treat a-b and b-a as same (sub is non-commutative)', () => {
+        const block = makeBlock([
+            { kind: 'sub', dst: temp('t1'), a: tempOp('x'), b: tempOp('y') },
+            { kind: 'sub', dst: temp('t2'), a: tempOp('y'), b: tempOp('x') },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[1].kind).toBe('sub');
+    });
+    it('does NOT treat a/b and b/a as same (div is non-commutative)', () => {
+        const block = makeBlock([
+            { kind: 'div', dst: temp('t1'), a: tempOp('x'), b: tempOp('y') },
+            { kind: 'div', dst: temp('t2'), a: tempOp('y'), b: tempOp('x') },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[1].kind).toBe('div');
+    });
+});
+describe('CSE — invalidation', () => {
+    it('invalidates expression when operand is redefined', () => {
+        const block = makeBlock([
+            { kind: 'add', dst: temp('t1'), a: tempOp('x'), b: constOp(1) },
+            { kind: 'copy', dst: temp('x'), src: constOp(99) },
+            { kind: 'add', dst: temp('t2'), a: tempOp('x'), b: constOp(1) },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        // t2 should NOT be replaced because x was modified
+        expect(result.blocks[0].instrs[2].kind).toBe('add');
+    });
+    it('invalidates all expressions after a call', () => {
+        const block = makeBlock([
+            { kind: 'add', dst: temp('t1'), a: tempOp('x'), b: constOp(1) },
+            { kind: 'call', dst: temp('t_ret'), fn: 'sideEffect', args: [] },
+            { kind: 'add', dst: temp('t2'), a: tempOp('x'), b: constOp(1) },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[2].kind).toBe('add');
+    });
+    it('invalidates all expressions after score_write', () => {
+        const block = makeBlock([
+            { kind: 'add', dst: temp('t1'), a: tempOp('x'), b: constOp(1) },
+            { kind: 'score_write', target: '@s', objective: 'test', src: tempOp('v') },
+            { kind: 'add', dst: temp('t2'), a: tempOp('x'), b: constOp(1) },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[2].kind).toBe('add');
+    });
+});
+describe('CSE — self-modifying skip', () => {
+    it('does not CSE self-modifying instruction (t5 = t5 + 1)', () => {
+        const block = makeBlock([
+            { kind: 'add', dst: temp('t5'), a: tempOp('t5'), b: constOp(1) },
+            { kind: 'add', dst: temp('t5'), a: tempOp('t5'), b: constOp(1) },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        // Both should remain as 'add' because they're self-modifying
+        expect(result.blocks[0].instrs[0].kind).toBe('add');
+        expect(result.blocks[0].instrs[1].kind).toBe('add');
+    });
+});
+describe('CSE — different expressions not merged', () => {
+    it('does not merge different operations on same operands', () => {
+        const block = makeBlock([
+            { kind: 'add', dst: temp('t1'), a: tempOp('x'), b: tempOp('y') },
+            { kind: 'sub', dst: temp('t2'), a: tempOp('x'), b: tempOp('y') },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[0].kind).toBe('add');
+        expect(result.blocks[0].instrs[1].kind).toBe('sub');
+    });
+    it('does not merge same operation with different constants', () => {
+        const block = makeBlock([
+            { kind: 'add', dst: temp('t1'), a: tempOp('x'), b: constOp(1) },
+            { kind: 'add', dst: temp('t2'), a: tempOp('x'), b: constOp(2) },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[0].kind).toBe('add');
+        expect(result.blocks[0].instrs[1].kind).toBe('add');
+    });
+    it('different cmp operators are not merged', () => {
+        const block = makeBlock([
+            { kind: 'cmp', dst: temp('t1'), op: 'lt', a: tempOp('x'), b: tempOp('y') },
+            { kind: 'cmp', dst: temp('t2'), op: 'gt', a: tempOp('x'), b: tempOp('y') },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[0].kind).toBe('cmp');
+        expect(result.blocks[0].instrs[1].kind).toBe('cmp');
+    });
+});
+describe('CSE — multiple blocks', () => {
+    it('processes each block independently', () => {
+        const block1 = makeBlock([
+            { kind: 'add', dst: temp('t1'), a: tempOp('x'), b: constOp(1) },
+        ]);
+        const block2 = makeBlock([
+            // Same expression in different block — should NOT be CSE'd
+            { kind: 'add', dst: temp('t2'), a: tempOp('x'), b: constOp(1) },
+        ]);
+        block2.id = 'b1';
+        const result = (0, cse_1.cse)(makeFn([block1, block2]));
+        expect(result.blocks[0].instrs[0].kind).toBe('add');
+        expect(result.blocks[1].instrs[0].kind).toBe('add');
+    });
+});
+describe('CSE — passthrough of non-pure instructions', () => {
+    it('passes through const instruction unchanged', () => {
+        const block = makeBlock([
+            { kind: 'const', dst: temp('t1'), value: '42' },
+            { kind: 'const', dst: temp('t2'), value: '42' },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        // const instructions don't have exprKey so both should pass through
+        expect(result.blocks[0].instrs.length).toBe(2);
+    });
+    it('preserves jump and branch instructions', () => {
+        const block = makeBlock([
+            { kind: 'add', dst: temp('t1'), a: tempOp('x'), b: constOp(1) },
+            { kind: 'branch', cond: tempOp('t1'), thenBlock: 'b1', elseBlock: 'b2' },
+        ]);
+        const result = (0, cse_1.cse)(makeFn([block]));
+        expect(result.blocks[0].instrs[1].kind).toBe('branch');
+    });
+});
+//# sourceMappingURL=optimizer-cse.test.js.map

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

@@ -424,21 +424,12 @@ impl Point {
                 const expr = parseExpr('"hello"');
                 expect(expr).toEqual({ kind: 'str_lit', value: 'hello' });
             });
-            it('parses interpolated string literal', () => {
+            it('parses dollar-brace as plain string literal (no interpolation)', () => {
+                // ${...} in plain strings is NOT interpolated — only f"..." strings support {expr}
                 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 },
-                        },
-                    ],
+                    kind: 'str_lit',
+                    value: 'Hello ${name}, score is ${score + 1}',
                 });
             });
             it('parses f-string literal', () => {

package/dist/src/__tests__/repl-server-extra.test.js

@@ -44,9 +44,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const http = __importStar(require("http"));
 const repl_server_1 = require("../repl-server");
-// Use a different port from repl-server.test.ts (3000) to avoid port conflicts
-const PORT = 3001;
+// Use port 0 so the OS assigns a free port — avoids port conflicts
 const server = http.createServer(repl_server_1.requestHandler);
+let PORT = 0;
 function rawRequest(method, urlPath, body, headers = {}) {
     return new Promise((resolve, reject) => {
         const options = {
@@ -89,12 +89,11 @@ function jsonRequest(method, urlPath, body) {
     });
 }
 beforeAll(done => {
-    if (server.listening) {
+    server.listen(0, () => {
+        const addr = server.address();
+        PORT = addr.port;
         done();
-    }
-    else {
-        server.listen(PORT, done);
-    }
+    });
 });
 afterAll(done => {
     server.close(done);

package/dist/src/__tests__/repl-server.test.js

@@ -40,7 +40,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const http = __importStar(require("http"));
 const repl_server_1 = require("../repl-server");
-const PORT = 3000;
+let PORT = 0;
 function request(method, path, body) {
     return new Promise((resolve, reject) => {
         const payload = body !== undefined ? JSON.stringify(body) : undefined;
@@ -74,13 +74,11 @@ function request(method, path, body) {
     });
 }
 beforeAll(done => {
-    // If the server is already listening (e.g. imported elsewhere), just proceed.
-    if (repl_server_1.server.listening) {
+    repl_server_1.server.listen(0, () => {
+        const addr = repl_server_1.server.address();
+        PORT = addr.port;
         done();
-    }
-    else {
-        repl_server_1.server.listen(PORT, done);
-    }
+    });
 });
 afterAll(done => {
     repl_server_1.server.close(done);

package/dist/src/__tests__/stdlib/queue.test.js

@@ -59,18 +59,18 @@ describe('stdlib/queue.mcrs', () => {
     test('queue_pop reads head index from rs.q_head scoreboard', () => {
         const r = compileWith(`@keep fn t(): int { return queue_pop(); }`);
         const all = r.files.map(f => f.content).join('\n');
-        expect(all).toContain('scoreboard players get rs.q_head __RS__');
+        expect(all).toContain('scoreboard players get rs.q_head rs');
     });
     test('queue_pop advances head pointer after reading', () => {
         const r = compileWith(`@keep fn t(): int { return queue_pop(); }`);
         const all = r.files.map(f => f.content).join('\n');
-        expect(all).toContain('scoreboard players add rs.q_head __RS__ 1');
+        expect(all).toContain('scoreboard players add rs.q_head rs 1');
     });
     test('queue_pop uses __queue_peek_apply macro to read element', () => {
         const r = compileWith(`@keep fn t(): int { return queue_pop(); }`);
         const all = r.files.map(f => f.content).join('\n');
         expect(all).toContain('function test:__queue_peek_apply with storage rs:macro_args');
-        expect(all).toContain('$execute store result score $ret __test run data get storage rs:arrays Queue[$(idx)]');
+        expect(all).toContain('$execute store result score rs.peek_tmp rs run data get storage rs:arrays Queue[$(idx)]');
     });
     test('queue_peek uses __queue_peek_apply macro', () => {
         const r = compileWith(`@keep fn t(): int { return queue_peek(); }`);
@@ -80,18 +80,18 @@ describe('stdlib/queue.mcrs', () => {
     test('queue_size subtracts head from raw list length', () => {
         const r = compileWith(`@keep fn t(): int { return queue_size(); }`);
         const all = r.files.map(f => f.content).join('\n');
-        expect(all).toContain('scoreboard players operation $ret __test -= rs.q_head __RS__');
+        expect(all).toContain('scoreboard players operation $ret __test -= rs.q_head rs');
     });
     test('queue_size uses __queue_size_raw_apply to read raw list length', () => {
         const r = compileWith(`@keep fn t(): int { return queue_size(); }`);
         const all = r.files.map(f => f.content).join('\n');
-        expect(all).toContain('function test:__queue_size_raw_apply with storage rs:macro_args');
+        expect(all).toContain('function test:__queue_size_raw_apply');
     });
     test('queue_clear resets Queue list and head pointer', () => {
         const r = compileWith(`@keep fn t() { queue_clear(); }`);
         const all = r.files.map(f => f.content).join('\n');
         expect(all).toContain('data modify storage rs:arrays Queue set value []');
-        expect(all).toContain('scoreboard players set rs.q_head __RS__ 0');
+        expect(all).toContain('scoreboard players set rs.q_head rs 0');
     });
 });
 //# sourceMappingURL=queue.test.js.map

package/dist/src/lexer/index.js

@@ -464,8 +464,9 @@ class Lexer {
                 value += this.advance();
                 continue;
             }
+            // Check for {...} interpolation
             if (interpolationDepth === 0 && this.peek() === '{') {
-                value += this.advance();
+                value += this.advance(); // {
                 interpolationDepth = 1;
                 interpolationString = false;
                 continue;

package/dist/src/lint/index.d.ts

@@ -5,11 +5,16 @@
  * Run after HIR lowering, before MIR.
  *
  * Rules:
- *   unused-variable   — let x = 5 but x never read
- *   unused-import     — import math::sin but sin never called
- *   magic-number      — literal number > 1 used directly (0 and 1 ignored)
- *   dead-branch       — if (const == const) always-true/false condition
- *   function-too-long — function body exceeds 50 lines
+ *   unused-variable        — let x = 5 but x never read
+ *   unused-import          — import math::sin but sin never called
+ *   magic-number           — literal number > 1 used directly (0 and 1 ignored)
+ *   dead-branch            — if (const == const) always-true/false condition
+ *   function-too-long      — function body exceeds 50 lines
+ *   no-dead-assignment     — variable assigned but never read after the assignment
+ *   prefer-match-exhaustive — Option match missing Some or None arm
+ *   no-empty-catch         — empty else branch in if_let_some (silent failure)
+ *   naming-convention      — variables must be camelCase; types must be PascalCase
+ *   no-magic-numbers       — any literal number other than 0 or 1 used in an expression
  */
 import type { HIRModule } from '../hir/types';
 import type { ImportDecl } from '../ast/types';
@@ -24,6 +29,8 @@ export interface LintOptions {
     filePath?: string;
     /** Max function body lines before function-too-long fires (default: 50) */
     maxFunctionLines?: number;
+    /** Allowed literal number values for no-magic-numbers (default: [0, 1]) */
+    allowedNumbers?: number[];
 }
 /**
  * Lint a RedScript source file. Parses → lowers → analyzes HIR.