redscript-mc 1.2.30 → 2.1.0

package/dist/src/optimizer/block_merge.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Block Merging — MIR optimization pass.
+ *
+ * Merges a block B into its sole predecessor A when:
+ * - A ends with an unconditional jump to B
+ * - B has exactly one predecessor (A)
+ * - B is not the entry block
+ *
+ * The merged block keeps A's id and combines A's instrs + B's instrs + B's terminator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blockMerge = blockMerge;
+function blockMerge(fn) {
+    let blocks = fn.blocks;
+    // Iterate until no more merges possible
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const blockMap = new Map(blocks.map(b => [b.id, b]));
+        const predCounts = computePredCounts(blocks);
+        const newBlocks = [];
+        const removed = new Set();
+        for (const block of blocks) {
+            if (removed.has(block.id))
+                continue;
+            // Check: does this block jump unconditionally to a single-pred successor?
+            if (block.term.kind === 'jump') {
+                const targetId = block.term.target;
+                const target = blockMap.get(targetId);
+                if (target && targetId !== fn.entry && predCounts.get(targetId) === 1) {
+                    // Merge target into this block
+                    const merged = {
+                        id: block.id,
+                        instrs: [...block.instrs, ...target.instrs],
+                        term: target.term,
+                        preds: block.preds,
+                    };
+                    newBlocks.push(merged);
+                    removed.add(targetId);
+                    changed = true;
+                    continue;
+                }
+            }
+            newBlocks.push(block);
+        }
+        blocks = newBlocks;
+    }
+    // Recompute preds after merging
+    blocks = recomputePreds(blocks);
+    return { ...fn, blocks };
+}
+function computePredCounts(blocks) {
+    const counts = new Map();
+    for (const b of blocks)
+        counts.set(b.id, 0);
+    for (const block of blocks) {
+        for (const target of getTermTargets(block.term)) {
+            counts.set(target, (counts.get(target) ?? 0) + 1);
+        }
+    }
+    return counts;
+}
+function recomputePreds(blocks) {
+    const predMap = new Map();
+    for (const b of blocks)
+        predMap.set(b.id, []);
+    for (const block of blocks) {
+        for (const target of getTermTargets(block.term)) {
+            const preds = predMap.get(target);
+            if (preds)
+                preds.push(block.id);
+        }
+    }
+    return blocks.map(b => ({ ...b, preds: predMap.get(b.id) ?? [] }));
+}
+function getTermTargets(term) {
+    switch (term.kind) {
+        case 'jump': return [term.target];
+        case 'branch': return [term.then, term.else];
+        default: return [];
+    }
+}
+//# sourceMappingURL=block_merge.js.map

package/dist/src/optimizer/branch_simplify.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Branch Simplification — MIR optimization pass.
+ *
+ * Replaces `branch(const, then, else)` with an unconditional `jump`:
+ * - branch(nonzero, then, else) → jump(then)
+ * - branch(0, then, else) → jump(else)
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function branchSimplify(fn: MIRFunction): MIRFunction;

package/dist/src/optimizer/branch_simplify.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Branch Simplification — MIR optimization pass.
+ *
+ * Replaces `branch(const, then, else)` with an unconditional `jump`:
+ * - branch(nonzero, then, else) → jump(then)
+ * - branch(0, then, else) → jump(else)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.branchSimplify = branchSimplify;
+function branchSimplify(fn) {
+    return {
+        ...fn,
+        blocks: fn.blocks.map(simplifyBlock),
+    };
+}
+function simplifyBlock(block) {
+    if (block.term.kind !== 'branch')
+        return block;
+    if (block.term.cond.kind !== 'const')
+        return block;
+    const target = block.term.cond.value !== 0 ? block.term.then : block.term.else;
+    return {
+        ...block,
+        term: { kind: 'jump', target },
+    };
+}
+//# sourceMappingURL=branch_simplify.js.map

package/dist/src/optimizer/constant_fold.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Constant Folding — MIR optimization pass.
+ *
+ * Folds instructions where all operands are constants:
+ * - Arithmetic: add(3, 4) → 7, neg(5) → -5
+ * - Comparison: cmp(lt, 3, 4) → 1
+ * - Boolean: and(1, 0) → 0, not(0) → 1
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function constantFold(fn: MIRFunction): MIRFunction;

package/dist/src/optimizer/constant_fold.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Constant Folding — MIR optimization pass.
+ *
+ * Folds instructions where all operands are constants:
+ * - Arithmetic: add(3, 4) → 7, neg(5) → -5
+ * - Comparison: cmp(lt, 3, 4) → 1
+ * - Boolean: and(1, 0) → 0, not(0) → 1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constantFold = constantFold;
+function constantFold(fn) {
+    return {
+        ...fn,
+        blocks: fn.blocks.map(foldBlock),
+    };
+}
+function foldBlock(block) {
+    const instrs = [];
+    for (const instr of block.instrs) {
+        const folded = tryFold(instr);
+        instrs.push(folded ?? instr);
+    }
+    return { ...block, instrs };
+}
+function isConst(op) {
+    return op.kind === 'const';
+}
+function tryFold(instr) {
+    switch (instr.kind) {
+        case 'add':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: instr.a.value + instr.b.value };
+            break;
+        case 'sub':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: instr.a.value - instr.b.value };
+            break;
+        case 'mul':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: instr.a.value * instr.b.value };
+            break;
+        case 'div':
+            if (isConst(instr.a) && isConst(instr.b) && instr.b.value !== 0)
+                return { kind: 'const', dst: instr.dst, value: Math.trunc(instr.a.value / instr.b.value) };
+            break;
+        case 'mod':
+            if (isConst(instr.a) && isConst(instr.b) && instr.b.value !== 0)
+                return { kind: 'const', dst: instr.dst, value: instr.a.value % instr.b.value };
+            break;
+        case 'neg':
+            if (isConst(instr.src))
+                return { kind: 'const', dst: instr.dst, value: -instr.src.value };
+            break;
+        case 'not':
+            if (isConst(instr.src))
+                return { kind: 'const', dst: instr.dst, value: instr.src.value === 0 ? 1 : 0 };
+            break;
+        case 'and':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: (instr.a.value !== 0 && instr.b.value !== 0) ? 1 : 0 };
+            break;
+        case 'or':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: (instr.a.value !== 0 || instr.b.value !== 0) ? 1 : 0 };
+            break;
+        case 'cmp':
+            if (isConst(instr.a) && isConst(instr.b))
+                return { kind: 'const', dst: instr.dst, value: evalCmp(instr.op, instr.a.value, instr.b.value) };
+            break;
+    }
+    return null;
+}
+function evalCmp(op, a, b) {
+    switch (op) {
+        case 'eq': return a === b ? 1 : 0;
+        case 'ne': return a !== b ? 1 : 0;
+        case 'lt': return a < b ? 1 : 0;
+        case 'le': return a <= b ? 1 : 0;
+        case 'gt': return a > b ? 1 : 0;
+        case 'ge': return a >= b ? 1 : 0;
+        default: return 0;
+    }
+}
+//# sourceMappingURL=constant_fold.js.map

package/dist/src/optimizer/copy_prop.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copy Propagation — MIR optimization pass.
+ *
+ * Within each block, tracks `copy dst, src` and `const dst, value` instructions
+ * and replaces subsequent uses of `dst` with the known operand.
+ * Invalidates mappings when a temp is redefined (written to).
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function copyProp(fn: MIRFunction): MIRFunction;

package/dist/src/optimizer/copy_prop.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Copy Propagation — MIR optimization pass.
+ *
+ * Within each block, tracks `copy dst, src` and `const dst, value` instructions
+ * and replaces subsequent uses of `dst` with the known operand.
+ * Invalidates mappings when a temp is redefined (written to).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyProp = copyProp;
+function copyProp(fn) {
+    return {
+        ...fn,
+        blocks: fn.blocks.map(propBlock),
+    };
+}
+function propBlock(block) {
+    // Map from temp → the operand it was copied from
+    const copies = new Map();
+    const instrs = [];
+    for (const instr of block.instrs) {
+        // Rewrite uses first
+        const rewritten = rewriteUses(instr, copies);
+        // Invalidate any mapping whose source was just redefined
+        const dst = getDst(rewritten);
+        if (dst) {
+            // Remove any mapping that points TO this dst (as a temp source)
+            for (const [k, v] of copies) {
+                if (v.kind === 'temp' && v.name === dst) {
+                    copies.delete(k);
+                }
+            }
+            // Remove dst's own previous mapping (will be re-added below if applicable)
+            copies.delete(dst);
+        }
+        // Track new propagatable definitions
+        if (rewritten.kind === 'const') {
+            // const dst, value → record dst → const operand
+            copies.set(rewritten.dst, { kind: 'const', value: rewritten.value });
+        }
+        else if (rewritten.kind === 'copy') {
+            // copy dst, src → record dst → src (temp or const)
+            copies.set(rewritten.dst, rewritten.src);
+        }
+        instrs.push(rewritten);
+    }
+    // Also rewrite terminator uses
+    const term = rewriteUses(block.term, copies);
+    return { ...block, instrs, term };
+}
+function resolve(op, copies) {
+    if (op.kind === 'temp') {
+        const replacement = copies.get(op.name);
+        if (replacement)
+            return replacement;
+    }
+    return op;
+}
+function rewriteUses(instr, copies) {
+    switch (instr.kind) {
+        case 'copy':
+            return { ...instr, src: resolve(instr.src, copies) };
+        case 'neg':
+        case 'not':
+            return { ...instr, src: resolve(instr.src, copies) };
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'and':
+        case 'or':
+            return { ...instr, a: resolve(instr.a, copies), b: resolve(instr.b, copies) };
+        case 'cmp':
+            return { ...instr, a: resolve(instr.a, copies), b: resolve(instr.b, copies) };
+        case 'nbt_write':
+            return { ...instr, src: resolve(instr.src, copies) };
+        case 'call':
+            return { ...instr, args: instr.args.map(a => resolve(a, copies)) };
+        case 'call_macro':
+            return { ...instr, args: instr.args.map(a => ({ ...a, value: resolve(a.value, copies) })) };
+        case 'branch':
+            return { ...instr, cond: resolve(instr.cond, copies) };
+        case 'return':
+            return { ...instr, value: instr.value ? resolve(instr.value, copies) : null };
+        default:
+            return instr;
+    }
+}
+function getDst(instr) {
+    switch (instr.kind) {
+        case 'const':
+        case 'copy':
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'neg':
+        case 'cmp':
+        case 'and':
+        case 'or':
+        case 'not':
+        case 'nbt_read':
+            return instr.dst;
+        case 'call':
+        case 'call_macro':
+            return instr.dst;
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=copy_prop.js.map

package/dist/src/optimizer/coroutine.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Coroutine Transform — MIR module-level pass.
+ *
+ * Transforms functions annotated with @coroutine(batch=N, onDone=fn) into
+ * tick-spread state machines. Each loop back-edge becomes a yield point,
+ * and the function is split into continuation functions dispatched by a
+ * @tick function via a pc (program counter) scoreboard slot.
+ *
+ * Algorithm:
+ *   1. Compute dominator tree → find back edges (yield points)
+ *   2. Backward liveness analysis at yield points
+ *   3. Split CFG into continuations at yield points
+ *   4. Promote live variables to persistent scoreboard slots
+ *   5. Generate @tick dispatcher function
+ *
+ * Spec: docs/compiler-pipeline-redesign.md § "Coroutine Transform"
+ */
+import type { MIRModule } from '../mir/types';
+export interface CoroutineInfo {
+    fnName: string;
+    batch: number;
+    onDone?: string;
+}
+export interface CoroutineResult {
+    module: MIRModule;
+    /** Names of generated @tick dispatcher functions (caller must add to tick list). */
+    generatedTickFunctions: string[];
+}
+/**
+ * Apply the coroutine transform to all functions in `infos`.
+ * Returns a new module with continuations + dispatchers injected,
+ * and the original function replaced with initialization code.
+ */
+export declare function coroutineTransform(mod: MIRModule, infos: CoroutineInfo[]): CoroutineResult;