redscript-mc 1.2.29 → 2.0.0

package/dist/src2/__tests__/mir/control-flow.test.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../../src/lexer");
+const parser_1 = require("../../../src/parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+function compile(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    return (0, lower_2.lowerToMIR)(hir);
+}
+function getFn(mod, name) {
+    if (name)
+        return mod.functions.find(f => f.name === name);
+    return mod.functions[0];
+}
+function getBlock(fn, id) {
+    return fn.blocks.find(b => b.id === id);
+}
+describe('MIR lowering — if/else → branch CFG', () => {
+    test('if without else creates branch to then + merge', () => {
+        const mod = compile('fn f(x: int): int { if (x > 0) { return x; } return 0; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        // Entry block should end with a branch
+        const entry = getBlock(fn, fn.entry);
+        expect(entry.term.kind).toBe('branch');
+        const branch = entry.term;
+        // Both targets should exist
+        expect(fn.blocks.some(b => b.id === branch.then)).toBe(true);
+        expect(fn.blocks.some(b => b.id === branch.else)).toBe(true);
+    });
+    test('if/else creates branch to then + else + merge', () => {
+        const mod = compile(`
+      fn f(x: int): int {
+        if (x > 0) { return 1; }
+        else { return -1; }
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        const entry = getBlock(fn, fn.entry);
+        expect(entry.term.kind).toBe('branch');
+        const branch = entry.term;
+        const thenBlock = getBlock(fn, branch.then);
+        const elseBlock = getBlock(fn, branch.else);
+        // Both branches should have return terminators
+        expect(thenBlock.term.kind).toBe('return');
+        expect(elseBlock.term.kind).toBe('return');
+    });
+    test('nested if/else produces correct block structure', () => {
+        const mod = compile(`
+      fn f(x: int): int {
+        if (x > 0) {
+          if (x > 10) { return 2; }
+          return 1;
+        }
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        // Should have multiple blocks due to nesting
+        expect(fn.blocks.length).toBeGreaterThanOrEqual(4);
+    });
+});
+describe('MIR lowering — while → loop CFG', () => {
+    test('while loop creates header + body + exit blocks', () => {
+        const mod = compile(`
+      fn f(x: int): int {
+        let sum: int = 0;
+        while (x > 0) {
+          sum = sum + x;
+          x = x - 1;
+        }
+        return sum;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        // Find loop header block (has branch terminator based on condition)
+        const headerBlock = fn.blocks.find(b => b.id.startsWith('loop_header') && b.term.kind === 'branch');
+        expect(headerBlock).toBeDefined();
+        // Find loop body block
+        const bodyBlock = fn.blocks.find(b => b.id.startsWith('loop_body'));
+        expect(bodyBlock).toBeDefined();
+        // Find loop exit block
+        const exitBlock = fn.blocks.find(b => b.id.startsWith('loop_exit'));
+        expect(exitBlock).toBeDefined();
+        // Header should branch to body (then) and exit (else)
+        const branch = headerBlock.term;
+        expect(branch.then).toBe(bodyBlock.id);
+        expect(branch.else).toBe(exitBlock.id);
+    });
+    test('break jumps to loop exit', () => {
+        const mod = compile(`
+      fn f(x: int): void {
+        while (x > 0) {
+          if (x == 5) { break; }
+          x = x - 1;
+        }
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        const exitBlock = fn.blocks.find(b => b.id.startsWith('loop_exit'));
+        expect(exitBlock).toBeDefined();
+        // Some block should jump directly to the exit (the break)
+        const breakBlock = fn.blocks.find(b => b.term.kind === 'jump' && b.term.target === exitBlock.id
+            && !b.id.startsWith('loop_header') && !b.id.startsWith('loop_exit')
+            && !b.id.startsWith('entry'));
+        expect(breakBlock).toBeDefined();
+    });
+    test('continue jumps to loop header', () => {
+        const mod = compile(`
+      fn f(x: int): void {
+        while (x > 0) {
+          x = x - 1;
+          if (x == 3) { continue; }
+        }
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        const headerBlock = fn.blocks.find(b => b.id.startsWith('loop_header'));
+        expect(headerBlock).toBeDefined();
+        // Some block should jump to header (the continue)
+        const continueBlock = fn.blocks.find(b => b.term.kind === 'jump' && b.term.target === headerBlock.id
+            && !b.id.startsWith('loop_body') && !b.id.startsWith('entry'));
+        expect(continueBlock).toBeDefined();
+    });
+});
+describe('MIR lowering — short-circuit operators', () => {
+    test('&& produces branch (short-circuit)', () => {
+        const mod = compile('fn f(a: bool, b: bool): bool { return a && b; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        // Should have and_right, and_false, and_merge blocks
+        expect(fn.blocks.some(b => b.id.startsWith('and_right'))).toBe(true);
+        expect(fn.blocks.some(b => b.id.startsWith('and_false'))).toBe(true);
+        expect(fn.blocks.some(b => b.id.startsWith('and_merge'))).toBe(true);
+    });
+    test('|| produces branch (short-circuit)', () => {
+        const mod = compile('fn f(a: bool, b: bool): bool { return a || b; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        expect(fn.blocks.some(b => b.id.startsWith('or_true'))).toBe(true);
+        expect(fn.blocks.some(b => b.id.startsWith('or_right'))).toBe(true);
+        expect(fn.blocks.some(b => b.id.startsWith('or_merge'))).toBe(true);
+    });
+});
+describe('MIR lowering — return', () => {
+    test('void return', () => {
+        const mod = compile('fn f(): void { return; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        const entry = getBlock(fn, fn.entry);
+        expect(entry.term.kind).toBe('return');
+        expect(entry.term.value).toBeNull();
+    });
+    test('value return', () => {
+        const mod = compile('fn f(): int { return 42; }');
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        const entry = getBlock(fn, fn.entry);
+        expect(entry.term.kind).toBe('return');
+        expect(entry.term.value).toEqual({ kind: 'const', value: 42 });
+    });
+    test('early return creates dead block for subsequent code', () => {
+        const mod = compile(`
+      fn f(x: int): int {
+        return x;
+        let y: int = 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        const entry = getBlock(fn, fn.entry);
+        expect(entry.term.kind).toBe('return');
+    });
+});
+describe('MIR lowering — all blocks reachable and well-formed', () => {
+    test('complex function verifies clean', () => {
+        const mod = compile(`
+      fn f(n: int): int {
+        let sum: int = 0;
+        let i: int = 0;
+        while (i < n) {
+          if (i % 2 == 0) {
+            sum = sum + i;
+          } else {
+            sum = sum - i;
+          }
+          i = i + 1;
+        }
+        return sum;
+      }
+    `);
+        const errors = (0, verify_1.verifyMIR)(mod);
+        expect(errors).toEqual([]);
+    });
+});
+//# sourceMappingURL=control-flow.test.js.map

package/dist/src2/__tests__/mir/verify.test.d.ts

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

package/dist/src2/__tests__/mir/verify.test.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const verify_1 = require("../../mir/verify");
+function makeModule(functions) {
+    return { functions, namespace: 'test', objective: '__test' };
+}
+function makeBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+describe('MIR verifier — terminator checks', () => {
+    test('rejects block without proper terminator', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'const', dst: 't0', value: 42 }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('does not end with a terminator');
+    });
+    test('rejects terminator in non-terminal position', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [{ kind: 'jump', target: 'entry' }], // terminator in instrs
+                { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('terminator');
+        expect(errors[0].message).toContain('non-terminal position');
+    });
+    test('accepts valid terminator (return)', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+    test('accepts valid terminator (jump)', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'jump', target: 'b1' }),
+                makeBlock('b1', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+});
+describe('MIR verifier — target existence', () => {
+    test('rejects jump to non-existent block', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'jump', target: 'nonexistent' }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('non-existent target');
+    });
+    test('rejects branch to non-existent block', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 1 },
+                ], { kind: 'branch', cond: { kind: 'temp', name: 't0' }, then: 'yes', else: 'no' }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBe(2); // both targets missing
+        expect(errors[0].message).toContain('non-existent target');
+    });
+});
+describe('MIR verifier — reachability', () => {
+    test('rejects unreachable block', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'return', value: null }),
+                makeBlock('orphan', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('unreachable');
+        expect(errors[0].block).toBe('orphan');
+    });
+    test('accepts all blocks reachable via jumps', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [], { kind: 'jump', target: 'b1' }),
+                makeBlock('b1', [], { kind: 'jump', target: 'b2' }),
+                makeBlock('b2', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+    test('accepts blocks reachable via branch', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 1 },
+                ], { kind: 'branch', cond: { kind: 'temp', name: 't0' }, then: 'yes', else: 'no' }),
+                makeBlock('yes', [], { kind: 'return', value: null }),
+                makeBlock('no', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+});
+describe('MIR verifier — use-before-def', () => {
+    test('rejects use of undefined temp', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('entry', [
+                    { kind: 'copy', dst: 't0', src: { kind: 'temp', name: 'undefined_temp' } },
+                ], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('undefined_temp');
+        expect(errors[0].message).toContain('never defined');
+    });
+    test('accepts temps defined as params', () => {
+        const fn = {
+            name: 'good',
+            params: [{ name: 't0', isMacroParam: false }],
+            blocks: [
+                makeBlock('entry', [], { kind: 'return', value: { kind: 'temp', name: 't0' } }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+    test('accepts temps defined in instructions', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 42 },
+                    { kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } },
+                ], { kind: 'return', value: { kind: 'temp', name: 't1' } }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+    test('const operands do not require definition', () => {
+        const fn = {
+            name: 'good',
+            params: [],
+            blocks: [
+                makeBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 5 },
+                    { kind: 'add', dst: 't1', a: { kind: 'temp', name: 't0' }, b: { kind: 'const', value: 3 } },
+                ], { kind: 'return', value: { kind: 'temp', name: 't1' } }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        expect((0, verify_1.verifyMIR)(makeModule([fn]))).toEqual([]);
+    });
+});
+describe('MIR verifier — entry block', () => {
+    test('rejects missing entry block', () => {
+        const fn = {
+            name: 'bad',
+            params: [],
+            blocks: [
+                makeBlock('not_entry', [], { kind: 'return', value: null }),
+            ],
+            entry: 'entry',
+            isMacro: false,
+        };
+        const errors = (0, verify_1.verifyMIR)(makeModule([fn]));
+        expect(errors.some(e => e.message.includes('entry block'))).toBe(true);
+    });
+});
+//# sourceMappingURL=verify.test.js.map

package/dist/src2/__tests__/optimizer/block_merge.test.d.ts

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

package/dist/src2/__tests__/optimizer/block_merge.test.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const block_merge_1 = require("../../optimizer/block_merge");
+function mkFn(blocks, entry = 'entry') {
+    return { name: 'test', params: [], blocks, entry, isMacro: false };
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('block merging', () => {
+    test('merges single-pred successor into predecessor', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 't0', value: 1 },
+            ], { kind: 'jump', target: 'b1' }),
+            mkBlock('b1', [
+                { kind: 'const', dst: 't1', value: 2 },
+            ], { kind: 'return', value: t('t1') }, ['entry']),
+        ]);
+        const result = (0, block_merge_1.blockMerge)(fn);
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].id).toBe('entry');
+        expect(result.blocks[0].instrs).toHaveLength(2);
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: t('t1') });
+    });
+    test('does not merge when successor has multiple preds', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'branch', cond: t('c'), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'jump', target: 'merge' }, ['entry']),
+            mkBlock('b2', [], { kind: 'jump', target: 'merge' }, ['entry']),
+            mkBlock('merge', [], { kind: 'return', value: null }, ['b1', 'b2']),
+        ]);
+        const result = (0, block_merge_1.blockMerge)(fn);
+        // merge has 2 preds → no merging of merge block
+        expect(result.blocks.length).toBeGreaterThanOrEqual(3);
+        expect(result.blocks.some(b => b.id === 'merge')).toBe(true);
+    });
+    test('does not merge entry block into predecessor', () => {
+        // Entry block should never be merged away
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'jump', target: 'b1' }),
+            mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+        ]);
+        const result = (0, block_merge_1.blockMerge)(fn);
+        // b1 has single pred → merged into entry
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].id).toBe('entry');
+    });
+    test('chains merges: A→B→C all single-pred', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 't0', value: 1 },
+            ], { kind: 'jump', target: 'b1' }),
+            mkBlock('b1', [
+                { kind: 'const', dst: 't1', value: 2 },
+            ], { kind: 'jump', target: 'b2' }, ['entry']),
+            mkBlock('b2', [
+                { kind: 'const', dst: 't2', value: 3 },
+            ], { kind: 'return', value: t('t2') }, ['b1']),
+        ]);
+        const result = (0, block_merge_1.blockMerge)(fn);
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].instrs).toHaveLength(3);
+    });
+    test('recomputes preds after merge', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'jump', target: 'b1' }),
+            mkBlock('b1', [], { kind: 'jump', target: 'b2' }, ['entry']),
+            mkBlock('b2', [], { kind: 'return', value: null }, ['b1']),
+        ]);
+        const result = (0, block_merge_1.blockMerge)(fn);
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].preds).toEqual([]);
+    });
+});
+//# sourceMappingURL=block_merge.test.js.map

package/dist/src2/__tests__/optimizer/branch_simplify.test.d.ts

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

package/dist/src2/__tests__/optimizer/branch_simplify.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const branch_simplify_1 = require("../../optimizer/branch_simplify");
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('branch simplification', () => {
+    test('branch(1, then, else) → jump(then)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'branch', cond: c(1), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+            mkBlock('b2', [], { kind: 'return', value: null }, ['entry']),
+        ]);
+        const result = (0, branch_simplify_1.branchSimplify)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b1' });
+    });
+    test('branch(0, then, else) → jump(else)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'branch', cond: c(0), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+            mkBlock('b2', [], { kind: 'return', value: null }, ['entry']),
+        ]);
+        const result = (0, branch_simplify_1.branchSimplify)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b2' });
+    });
+    test('nonzero const (42) → jump(then)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'branch', cond: c(42), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'return', value: null }),
+            mkBlock('b2', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, branch_simplify_1.branchSimplify)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b1' });
+    });
+    test('does not simplify branch with temp cond', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'branch', cond: t('flag'), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'return', value: null }),
+            mkBlock('b2', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, branch_simplify_1.branchSimplify)(fn);
+        expect(result.blocks[0].term.kind).toBe('branch');
+    });
+    test('does not touch jump terminators', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'jump', target: 'b1' }),
+            mkBlock('b1', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, branch_simplify_1.branchSimplify)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b1' });
+    });
+});
+//# sourceMappingURL=branch_simplify.test.js.map

package/dist/src2/__tests__/optimizer/constant_fold.test.d.ts

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