redscript-mc 1.2.30 → 2.1.0

package/dist/src/optimizer/lir/peephole.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Execute-Store Peephole Pass — LIR optimization pass.
+ *
+ * Merges a `call_context` immediately followed by `score_set(dst, value)`
+ * into a single `store_cmd_to_score` instruction:
+ *
+ *   execute [subcommands] run function ns:fn      ← call_context
+ *   scoreboard players set $result __ns N         ← score_set
+ *
+ * becomes:
+ *
+ *   execute store result score $result __ns [subcommands] run function ns:fn
+ *
+ * This saves one command when the caller only needs to know whether the
+ * execute chain ran (success = 1) or to capture the function's return value.
+ *
+ * Safety: only merges when the two instructions are immediately adjacent
+ * (no instructions between them).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execStorePeephole = execStorePeephole;
+function execStorePeephole(fn) {
+    const instrs = fn.instructions;
+    if (instrs.length < 2)
+        return fn;
+    const result = [];
+    let changed = false;
+    let i = 0;
+    while (i < instrs.length) {
+        const curr = instrs[i];
+        const next = instrs[i + 1];
+        // Pattern: call_context immediately followed by score_set
+        if (next &&
+            curr.kind === 'call_context' &&
+            next.kind === 'score_set') {
+            // Merge: execute store result score <dst> [subcommands] run function <fn>
+            result.push({
+                kind: 'store_cmd_to_score',
+                dst: next.dst,
+                cmd: curr,
+            });
+            changed = true;
+            i += 2;
+            continue;
+        }
+        result.push(curr);
+        i++;
+    }
+    return changed ? { ...fn, instructions: result } : fn;
+}
+//# sourceMappingURL=peephole.js.map

package/dist/src/optimizer/lir/pipeline.d.ts

@@ -0,0 +1,10 @@
+/**
+ * LIR Optimization Pipeline — runs all LIR passes on a module.
+ *
+ * Pass order: dead_slot → const_imm
+ * Dead slot runs first to remove unused writes, exposing more
+ * single-use const slots for const_imm to fold.
+ */
+import type { LIRFunction, LIRModule } from '../../lir/types';
+export type LIRPass = (fn: LIRFunction) => LIRFunction;
+export declare function lirOptimizeModule(mod: LIRModule): LIRModule;

package/dist/src/optimizer/lir/pipeline.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * LIR Optimization Pipeline — runs all LIR passes on a module.
+ *
+ * Pass order: dead_slot → const_imm
+ * Dead slot runs first to remove unused writes, exposing more
+ * single-use const slots for const_imm to fold.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lirOptimizeModule = lirOptimizeModule;
+const dead_slot_1 = require("./dead_slot");
+const const_imm_1 = require("./const_imm");
+const peephole_1 = require("./peephole");
+const perFunctionPasses = [
+    peephole_1.execStorePeephole,
+    const_imm_1.constImmFold,
+];
+function lirOptimizeModule(mod) {
+    // Module-level pass: dead slot elimination (cross-function analysis)
+    let result = (0, dead_slot_1.deadSlotElimModule)(mod);
+    // Per-function passes
+    let changed = false;
+    const functions = result.functions.map(fn => {
+        let current = fn;
+        for (const pass of perFunctionPasses) {
+            current = pass(current);
+        }
+        if (current !== fn)
+            changed = true;
+        return current;
+    });
+    return changed ? { ...result, functions } : result;
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/src/optimizer/nbt-batch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * NBT Batch Read — MIR optimization pass.
+ *
+ * Eliminates redundant nbt_read instructions within a basic block:
+ * if the same (ns, path, scale) is read twice with no intervening nbt_write
+ * to that ns, the second read is replaced with a copy from the first read's dst.
+ *
+ * This reduces expensive `data get` commands in generated .mcfunction files.
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function nbtBatchRead(fn: MIRFunction): MIRFunction;

package/dist/src/optimizer/nbt-batch.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * NBT Batch Read — MIR optimization pass.
+ *
+ * Eliminates redundant nbt_read instructions within a basic block:
+ * if the same (ns, path, scale) is read twice with no intervening nbt_write
+ * to that ns, the second read is replaced with a copy from the first read's dst.
+ *
+ * This reduces expensive `data get` commands in generated .mcfunction files.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nbtBatchRead = nbtBatchRead;
+function nbtBatchRead(fn) {
+    return {
+        ...fn,
+        blocks: fn.blocks.map(deduplicateBlock),
+    };
+}
+function deduplicateBlock(block) {
+    // Map from "ns\0path\0scale" → dst temp of the first read
+    const cache = new Map();
+    const instrs = [];
+    for (const instr of block.instrs) {
+        if (instr.kind === 'nbt_read') {
+            const key = `${instr.ns}\0${instr.path}\0${instr.scale}`;
+            const cached = cache.get(key);
+            if (cached !== undefined) {
+                // Replace with copy from cached temp
+                instrs.push({ kind: 'copy', dst: instr.dst, src: { kind: 'temp', name: cached } });
+            }
+            else {
+                cache.set(key, instr.dst);
+                instrs.push(instr);
+            }
+        }
+        else if (instr.kind === 'nbt_write') {
+            // Invalidate all cached reads for this ns
+            for (const key of [...cache.keys()]) {
+                if (key.startsWith(instr.ns + '\0')) {
+                    cache.delete(key);
+                }
+            }
+            instrs.push(instr);
+        }
+        else {
+            instrs.push(instr);
+        }
+    }
+    return { ...block, instrs };
+}
+//# sourceMappingURL=nbt-batch.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * MIR Optimization Pipeline — runs all passes to a fixpoint.
+ *
+ * Each pass is a function MIRFunction → MIRFunction.
+ * The pipeline iterates until no pass changes the function (fixpoint).
+ *
+ * Module-level passes (interproceduralConstProp) run once after the
+ * per-function fixpoint loop.
+ */
+import type { MIRFunction, MIRModule } from '../mir/types';
+export { selectorCache } from './selector-cache';
+export type Pass = (fn: MIRFunction) => MIRFunction;
+export declare function optimizeFunction(fn: MIRFunction, passes?: Pass[]): MIRFunction;
+export declare function optimizeModule(mod: MIRModule, passes?: Pass[]): MIRModule;

package/dist/src/optimizer/pipeline.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * MIR Optimization Pipeline — runs all passes to a fixpoint.
+ *
+ * Each pass is a function MIRFunction → MIRFunction.
+ * The pipeline iterates until no pass changes the function (fixpoint).
+ *
+ * Module-level passes (interproceduralConstProp) run once after the
+ * per-function fixpoint loop.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectorCache = void 0;
+exports.optimizeFunction = optimizeFunction;
+exports.optimizeModule = optimizeModule;
+const constant_fold_1 = require("./constant_fold");
+const copy_prop_1 = require("./copy_prop");
+const dce_1 = require("./dce");
+const block_merge_1 = require("./block_merge");
+const branch_simplify_1 = require("./branch_simplify");
+const unroll_1 = require("./unroll");
+const nbt_batch_1 = require("./nbt-batch");
+const interprocedural_1 = require("./interprocedural");
+// selectorCache is intentionally excluded from the default pipeline:
+// it emits synthetic __sel_cleanup_* / __sel_tag_* call_context instructions
+// that require codegen support before being used end-to-end.
+var selector_cache_1 = require("./selector-cache");
+Object.defineProperty(exports, "selectorCache", { enumerable: true, get: function () { return selector_cache_1.selectorCache; } });
+const defaultPasses = [
+    unroll_1.loopUnroll,
+    nbt_batch_1.nbtBatchRead,
+    constant_fold_1.constantFold,
+    copy_prop_1.copyProp,
+    branch_simplify_1.branchSimplify,
+    dce_1.dce,
+    block_merge_1.blockMerge,
+];
+const MAX_ITERATIONS = 20;
+function optimizeFunction(fn, passes = defaultPasses) {
+    let current = fn;
+    for (let i = 0; i < MAX_ITERATIONS; i++) {
+        const before = JSON.stringify(current);
+        for (const pass of passes) {
+            current = pass(current);
+        }
+        if (JSON.stringify(current) === before)
+            break;
+    }
+    return current;
+}
+function optimizeModule(mod, passes) {
+    const perFnOptimized = {
+        ...mod,
+        functions: mod.functions.map(fn => optimizeFunction(fn, passes)),
+    };
+    // Module-level pass: interprocedural constant propagation
+    return (0, interprocedural_1.interproceduralConstProp)(perFnOptimized);
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/src/optimizer/selector-cache.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Selector Cache — MIR optimization pass.
+ *
+ * Within a single basic block, if the same complex selector (one containing '[')
+ * appears in ≥2 call_context instructions (as `as` or `at` subcommands),
+ * the pass replaces the 2nd and subsequent occurrences with a simpler
+ * tag-based selector `@e[tag=__cache_sel_N]`.
+ *
+ * Two new call_context instructions are prepended to the block:
+ *   1. Cleanup: execute as @e[tag=__cache_sel_N] run <fn: __sel_cleanup_<tag>>
+ *      — signals codegen to emit: tag @e[tag=<tag>] remove <tag>
+ *   2. Tag-add: execute as <original_selector> run <fn: __sel_tag_<tag>>
+ *      — signals codegen to emit: tag @s add <tag>
+ *
+ * The synthetic fn names `__sel_cleanup_*` and `__sel_tag_*` are a convention
+ * recognized by the codegen layer for special-case emission.
+ *
+ * This is a block-local pass (does not track selector lifetime across block
+ * boundaries) so it is always correct with respect to control flow.
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function selectorCache(fn: MIRFunction): MIRFunction;

package/dist/src/optimizer/selector-cache.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Selector Cache — MIR optimization pass.
+ *
+ * Within a single basic block, if the same complex selector (one containing '[')
+ * appears in ≥2 call_context instructions (as `as` or `at` subcommands),
+ * the pass replaces the 2nd and subsequent occurrences with a simpler
+ * tag-based selector `@e[tag=__cache_sel_N]`.
+ *
+ * Two new call_context instructions are prepended to the block:
+ *   1. Cleanup: execute as @e[tag=__cache_sel_N] run <fn: __sel_cleanup_<tag>>
+ *      — signals codegen to emit: tag @e[tag=<tag>] remove <tag>
+ *   2. Tag-add: execute as <original_selector> run <fn: __sel_tag_<tag>>
+ *      — signals codegen to emit: tag @s add <tag>
+ *
+ * The synthetic fn names `__sel_cleanup_*` and `__sel_tag_*` are a convention
+ * recognized by the codegen layer for special-case emission.
+ *
+ * This is a block-local pass (does not track selector lifetime across block
+ * boundaries) so it is always correct with respect to control flow.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectorCache = selectorCache;
+function selectorCache(fn) {
+    let tagId = 0;
+    return {
+        ...fn,
+        blocks: fn.blocks.map(block => processBlock(block, () => tagId++)),
+    };
+}
+function processBlock(block, nextId) {
+    // Count how many times each complex selector appears across call_context instrs
+    const selectorCount = new Map();
+    for (const instr of block.instrs) {
+        if (instr.kind === 'call_context') {
+            for (const sub of instr.subcommands) {
+                if ((sub.kind === 'as' || sub.kind === 'at') && isComplexSelector(sub.selector)) {
+                    selectorCount.set(sub.selector, (selectorCount.get(sub.selector) ?? 0) + 1);
+                }
+            }
+        }
+    }
+    // Build a map of selectors that appear ≥2 times → assigned tag name
+    const repeated = new Map(); // selector → tag name
+    for (const [sel, count] of selectorCount) {
+        if (count >= 2) {
+            repeated.set(sel, `__cache_sel_${nextId()}`);
+        }
+    }
+    if (repeated.size === 0)
+        return block;
+    // Prepend cleanup + tag-add instructions for each repeated selector
+    const prefixInstrs = [];
+    for (const [sel, tag] of repeated) {
+        // 1. Cleanup: remove stale tags from any entities that still carry this tag
+        prefixInstrs.push({
+            kind: 'call_context',
+            fn: `__sel_cleanup_${tag}`,
+            subcommands: [{ kind: 'as', selector: `@e[tag=${tag}]` }],
+        });
+        // 2. Tag-add: tag all matching entities with the cache tag
+        prefixInstrs.push({
+            kind: 'call_context',
+            fn: `__sel_tag_${tag}`,
+            subcommands: [{ kind: 'as', selector: sel }],
+        });
+    }
+    // Rewrite instructions: first occurrence of each repeated selector is kept
+    // as-is; subsequent occurrences are replaced with the tag-based selector.
+    const seen = new Set();
+    const newInstrs = [...prefixInstrs];
+    for (const instr of block.instrs) {
+        if (instr.kind === 'call_context') {
+            const newSubs = instr.subcommands.map(sub => {
+                if ((sub.kind === 'as' || sub.kind === 'at') && repeated.has(sub.selector)) {
+                    const tag = repeated.get(sub.selector);
+                    if (seen.has(sub.selector)) {
+                        // Subsequent occurrence — use the tag selector
+                        return { ...sub, selector: `@e[tag=${tag}]` };
+                    }
+                    else {
+                        // First occurrence — keep original, mark as seen
+                        seen.add(sub.selector);
+                        return sub;
+                    }
+                }
+                return sub;
+            });
+            newInstrs.push({ ...instr, subcommands: newSubs });
+        }
+        else {
+            newInstrs.push(instr);
+        }
+    }
+    return { ...block, instrs: newInstrs };
+}
+function isComplexSelector(selector) {
+    return selector.includes('[');
+}
+//# sourceMappingURL=selector-cache.js.map

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

@@ -0,0 +1,32 @@
+/**
+ * Small Constant Loop Unrolling — MIR optimization pass.
+ *
+ * Detects `for (let i = 0; i < N; i++)` loops where N is a compile-time
+ * constant and N ≤ 8, then unrolls them: the loop body is duplicated N times
+ * with the loop variable substituted as the literal 0..N-1.
+ *
+ * Pattern recognized (after HIR→MIR lowering):
+ *   entry block:      const t_i 0          (loop var init)
+ *   loop_header:      cmp(lt, t_i, N) → branch body/exit
+ *   loop_body:        body instructions, jump → loop_latch
+ *   loop_latch:       t_i = t_i + 1, jump → loop_header
+ *   loop_exit:        ...
+ *
+ * After unrolling:
+ *   entry block (with i=0 def removed):
+ *     [body with t_i → 0]
+ *     [body with t_i → 1]
+ *     ...
+ *     [body with t_i → N-1]
+ *     jump → loop_exit
+ *   loop_exit: ...
+ *
+ * Limitations:
+ * - Only unrolls when N ≤ 8
+ * - The loop variable must be initialized to exactly 0 before the loop
+ * - The latch must do exactly `t_i = t_i + 1` (or equivalent const add)
+ * - No break/continue (body must not jump directly to exit or latch)
+ * - N must be a compile-time constant (Operand kind='const')
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function loopUnroll(fn: MIRFunction): MIRFunction;