redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/optimizer/strength-reduction.test.d.ts

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

package/dist/src/__tests__/optimizer/strength-reduction.test.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const strength_reduction_1 = require("../../optimizer/strength_reduction");
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+function mkBlock(id, instrs, term) {
+    return { id, instrs, term, preds: [] };
+}
+const c = (value) => ({ kind: 'const', value });
+const t = (name) => ({ kind: 'temp', name });
+describe('strength reduction', () => {
+    test('rewrites x * 2 to x + x', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mul', dst: 't0', a: t('x'), b: c(2) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, strength_reduction_1.strengthReduction)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'add', dst: 't0', a: t('x'), b: t('x') });
+    });
+    test('rewrites x * 1 to x', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mul', dst: 't0', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, strength_reduction_1.strengthReduction)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'copy', dst: 't0', src: t('x') });
+    });
+    test('rewrites x * 0 to 0', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mul', dst: 't0', a: t('x'), b: c(0) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, strength_reduction_1.strengthReduction)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 0 });
+    });
+    test('rewrites x + 0 to x', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: t('x'), b: c(0) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, strength_reduction_1.strengthReduction)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'copy', dst: 't0', src: t('x') });
+    });
+    test('rewrites x - 0 to x', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'sub', dst: 't0', a: t('x'), b: c(0) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, strength_reduction_1.strengthReduction)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'copy', dst: 't0', src: t('x') });
+    });
+    test('rewrites x / 1 to x', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'div', dst: 't0', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, strength_reduction_1.strengthReduction)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'copy', dst: 't0', src: t('x') });
+    });
+    test('rewrites x ^ 1 to x', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'pow', dst: 't0', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, strength_reduction_1.strengthReduction)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'copy', dst: 't0', src: t('x') });
+    });
+    test('rewrites x * -1 to -x', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mul', dst: 't0', a: t('x'), b: c(-1) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, strength_reduction_1.strengthReduction)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'neg', dst: 't0', src: t('x') });
+    });
+});
+//# sourceMappingURL=strength-reduction.test.js.map

package/dist/src/__tests__/optimizer/tco.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tests for Tail Call Optimization (TCO) — tco.ts
+ *
+ * 8 tests covering:
+ *   1. Detects direct self-tail-call (factorial)
+ *   2. Non-tail-call not flagged (result is used after the call)
+ *   3. Non-self-call not flagged (calls different function)
+ *   4. Tail-call with wrong arg count not flagged
+ *   5. Generated MIR has zero recursive call instructions (factorial)
+ *   6. Generated MIR has zero recursive call instructions (sum_acc)
+ *   7. Fibonacci TCO — tail-recursive accumulator form detected and eliminated
+ *   8. Macro functions are skipped entirely
+ */
+export {};

package/dist/src/__tests__/optimizer/tco.test.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Tests for Tail Call Optimization (TCO) — tco.ts
+ *
+ * 8 tests covering:
+ *   1. Detects direct self-tail-call (factorial)
+ *   2. Non-tail-call not flagged (result is used after the call)
+ *   3. Non-self-call not flagged (calls different function)
+ *   4. Tail-call with wrong arg count not flagged
+ *   5. Generated MIR has zero recursive call instructions (factorial)
+ *   6. Generated MIR has zero recursive call instructions (sum_acc)
+ *   7. Fibonacci TCO — tail-recursive accumulator form detected and eliminated
+ *   8. Macro functions are skipped entirely
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tco_1 = require("../../optimizer/tco");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+function mkFn(name, params, blocks, isMacro = false) {
+    return {
+        name,
+        params: params.map(p => ({ name: p, isMacroParam: false })),
+        blocks,
+        entry: 'entry',
+        isMacro,
+    };
+}
+function mkBlock(id, instrs, term) {
+    return { id, instrs, term, preds: [] };
+}
+/** Count call instructions targeting a given function name. */
+function countCalls(fn, target) {
+    return fn.blocks
+        .flatMap(b => [...b.instrs, b.term])
+        .filter(i => i.kind === 'call' && i.fn === target)
+        .length;
+}
+// ---------------------------------------------------------------------------
+// Sample MIR functions
+// ---------------------------------------------------------------------------
+/**
+ * factorial(n, acc):
+ *   entry: cmp n<=1 → branch base/recurse
+ *   base: return acc
+ *   recurse: t1=acc*n; t2=n-1; t3=factorial(t2,t1); return t3  ← tail call
+ */
+function factorialFn() {
+    return mkFn('test:factorial', ['n', 'acc'], [
+        mkBlock('entry', [
+            { kind: 'cmp', dst: 't0', op: 'le', a: t('n'), b: c(1) },
+        ], { kind: 'branch', cond: t('t0'), then: 'base', else: 'recurse' }),
+        mkBlock('base', [], { kind: 'return', value: t('acc') }),
+        mkBlock('recurse', [
+            { kind: 'mul', dst: 't1', a: t('acc'), b: t('n') },
+            { kind: 'sub', dst: 't2', a: t('n'), b: c(1) },
+            { kind: 'call', dst: 't3', fn: 'test:factorial', args: [t('t2'), t('t1')] },
+        ], { kind: 'return', value: t('t3') }),
+    ]);
+}
+/**
+ * Non-tail-call: result of recursive call is post-processed (+1) before return.
+ */
+function nonTailCallFn() {
+    return mkFn('test:sum', ['n', 'acc'], [
+        mkBlock('entry', [
+            { kind: 'cmp', dst: 't0', op: 'le', a: t('n'), b: c(0) },
+        ], { kind: 'branch', cond: t('t0'), then: 'base', else: 'recurse' }),
+        mkBlock('base', [], { kind: 'return', value: t('acc') }),
+        mkBlock('recurse', [
+            { kind: 'sub', dst: 't1', a: t('n'), b: c(1) },
+            { kind: 'call', dst: 't2', fn: 'test:sum', args: [t('t1'), t('acc')] },
+            { kind: 'add', dst: 't3', a: t('t2'), b: c(1) }, // post-process
+        ], { kind: 'return', value: t('t3') }),
+    ]);
+}
+/**
+ * Call to a different function — not a self-tail-call.
+ */
+function foreignCallFn() {
+    return mkFn('test:wrapper', ['x'], [
+        mkBlock('entry', [
+            { kind: 'call', dst: 't0', fn: 'test:helper', args: [t('x')] },
+        ], { kind: 'return', value: t('t0') }),
+    ]);
+}
+/**
+ * sum_acc(n, acc): accumulate sum from n to 0.
+ */
+function sumAccFn() {
+    return mkFn('test:sum_acc', ['n', 'acc'], [
+        mkBlock('entry', [
+            { kind: 'cmp', dst: 't0', op: 'le', a: t('n'), b: c(0) },
+        ], { kind: 'branch', cond: t('t0'), then: 'base', else: 'recurse' }),
+        mkBlock('base', [], { kind: 'return', value: t('acc') }),
+        mkBlock('recurse', [
+            { kind: 'add', dst: 't1', a: t('acc'), b: t('n') },
+            { kind: 'sub', dst: 't2', a: t('n'), b: c(1) },
+            { kind: 'call', dst: 't3', fn: 'test:sum_acc', args: [t('t2'), t('t1')] },
+        ], { kind: 'return', value: t('t3') }),
+    ]);
+}
+/**
+ * fib_acc(n, a, b): CPS fibonacci accumulator — tail-recursive.
+ *   recurse: t1=a+b; t2=n-1; t3=fib_acc(t2, b, t1); return t3
+ */
+function fibAccFn() {
+    return mkFn('test:fib_acc', ['n', 'a', 'b'], [
+        mkBlock('entry', [
+            { kind: 'cmp', dst: 't0', op: 'le', a: t('n'), b: c(0) },
+        ], { kind: 'branch', cond: t('t0'), then: 'base', else: 'recurse' }),
+        mkBlock('base', [], { kind: 'return', value: t('a') }),
+        mkBlock('recurse', [
+            { kind: 'add', dst: 't1', a: t('a'), b: t('b') },
+            { kind: 'sub', dst: 't2', a: t('n'), b: c(1) },
+            { kind: 'call', dst: 't3', fn: 'test:fib_acc', args: [t('t2'), t('b'), t('t1')] },
+        ], { kind: 'return', value: t('t3') }),
+    ]);
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('findTailCallBlocks', () => {
+    // Test 1
+    test('detects self-tail-call in factorial (recurse block)', () => {
+        const fn = factorialFn();
+        const tailBlocks = (0, tco_1.findTailCallBlocks)(fn);
+        expect(tailBlocks).toHaveLength(1);
+        expect(tailBlocks[0].blockId).toBe('recurse');
+    });
+    // Test 2
+    test('does not flag non-tail-call where result is post-processed', () => {
+        const fn = nonTailCallFn();
+        const tailBlocks = (0, tco_1.findTailCallBlocks)(fn);
+        expect(tailBlocks).toHaveLength(0);
+    });
+    // Test 3
+    test('does not flag call to a different function', () => {
+        const fn = foreignCallFn();
+        const tailBlocks = (0, tco_1.findTailCallBlocks)(fn);
+        expect(tailBlocks).toHaveLength(0);
+    });
+    // Test 4
+    test('does not flag self-call with mismatched argument count', () => {
+        const fn = mkFn('test:bad', ['x'], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 't0', fn: 'test:bad', args: [t('x'), c(1)] }, // 2 args, 1 param
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const tailBlocks = (0, tco_1.findTailCallBlocks)(fn);
+        expect(tailBlocks).toHaveLength(0);
+    });
+});
+describe('tailCallOptimize — factorial', () => {
+    // Test 5
+    test('eliminates all recursive call instructions from factorial', () => {
+        const fn = factorialFn();
+        const optimized = (0, tco_1.tailCallOptimize)(fn);
+        expect(countCalls(optimized, 'test:factorial')).toBe(0);
+    });
+    test('new entry is preamble block, not original entry', () => {
+        const fn = factorialFn();
+        const optimized = (0, tco_1.tailCallOptimize)(fn);
+        expect(optimized.entry).not.toBe('entry');
+    });
+});
+describe('tailCallOptimize — sum accumulator', () => {
+    // Test 6
+    test('eliminates all recursive call instructions from sum_acc', () => {
+        const fn = sumAccFn();
+        const optimized = (0, tco_1.tailCallOptimize)(fn);
+        expect(countCalls(optimized, 'test:sum_acc')).toBe(0);
+    });
+});
+describe('tailCallOptimize — fibonacci accumulator', () => {
+    // Test 7
+    test('detects tail call in fib_acc', () => {
+        const fn = fibAccFn();
+        const tailBlocks = (0, tco_1.findTailCallBlocks)(fn);
+        expect(tailBlocks).toHaveLength(1);
+        expect(tailBlocks[0].blockId).toBe('recurse');
+    });
+    test('eliminates recursive call from fib_acc after TCO', () => {
+        const fn = fibAccFn();
+        const optimized = (0, tco_1.tailCallOptimize)(fn);
+        expect(countCalls(optimized, 'test:fib_acc')).toBe(0);
+    });
+});
+describe('tailCallOptimize — macro skip', () => {
+    // Test 8
+    test('returns macro function unchanged (same reference)', () => {
+        const fn = mkFn('test:macro_fn', ['x'], [
+            mkBlock('entry', [
+                { kind: 'call', dst: 't0', fn: 'test:macro_fn', args: [t('x')] },
+            ], { kind: 'return', value: t('t0') }),
+        ], /* isMacro= */ true);
+        const result = (0, tco_1.tailCallOptimize)(fn);
+        expect(result).toBe(fn); // exact same reference — not touched
+    });
+});
+//# sourceMappingURL=tco.test.js.map

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

@@ -0,0 +1,25 @@
+/**
+ * Parser branch coverage — targets uncovered branches in src/parser/index.ts.
+ *
+ * Focus areas derived from coverage analysis:
+ *  • NBT suffix literals: byte_lit, short_lit, long_lit, double_lit
+ *  • Coordinate literals: rel_coord, local_coord in expressions
+ *  • mc_name literal (#health)
+ *  • isTypeCastAs variants (cast to double, byte, short, long, selector, Option)
+ *  • match pattern: enum with multi-binding, no-binding, negative int
+ *  • execute subcommands: rotated <yaw> <pitch>, anchored, align, on, summon,
+ *    store success, in dimension, unless score range
+ *  • facing entity with 'feet' anchor
+ *  • Function default parameter values
+ *  • const with inferred type (bool, float/fixed, string)
+ *  • module library declaration
+ *  • named module declaration
+ *  • enum variant with explicit value
+ *  • import wildcard (import math::*)
+ *  • negative integer match pattern
+ *  • PatEnum with no bindings
+ *  • member/index compound assignment operators (+=, -=, *=, /=, %=)
+ *  • Generic call: fn<Type>(args)
+ *  • invoke expression (callee is not ident)
+ */
+export {};