redscript-mc 2.0.0 → 2.1.1

package/dist/{src2 → src}/optimizer/pipeline.d.ts

@@ -3,8 +3,12 @@
  *
  * 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/{src2 → src}/optimizer/pipeline.js

@@ -4,8 +4,12 @@
  *
  * 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");
@@ -13,7 +17,17 @@ 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,
@@ -34,9 +48,11 @@ function optimizeFunction(fn, passes = defaultPasses) {
     return current;
 }
 function optimizeModule(mod, passes) {
-    return {
+    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;

package/dist/src/optimizer/unroll.js

@@ -0,0 +1,348 @@
+"use strict";
+/**
+ * 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')
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loopUnroll = loopUnroll;
+const UNROLL_LIMIT = 8;
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function loopUnroll(fn) {
+    let current = fn;
+    let changed = true;
+    // Iterate to fixpoint in case of multiple unrollable loops
+    while (changed) {
+        changed = false;
+        const result = tryUnrollOne(current);
+        if (result !== current) {
+            current = result;
+            changed = true;
+        }
+    }
+    return current;
+}
+function tryUnrollOne(fn) {
+    const blockMap = new Map(fn.blocks.map(b => [b.id, b]));
+    const info = findUnrollableLoop(fn, blockMap);
+    if (!info)
+        return fn;
+    return unroll(fn, blockMap, info);
+}
+// ---------------------------------------------------------------------------
+// Loop detection
+// ---------------------------------------------------------------------------
+function findUnrollableLoop(fn, blockMap) {
+    for (const block of fn.blocks) {
+        if (!block.id.startsWith('loop_header'))
+            continue;
+        const info = analyzeLoop(fn, blockMap, block);
+        if (info)
+            return info;
+    }
+    return null;
+}
+function analyzeLoop(fn, blockMap, header) {
+    // Header must branch on a cmp result
+    if (header.term.kind !== 'branch')
+        return null;
+    const branch = header.term;
+    if (branch.cond.kind !== 'temp')
+        return null;
+    const condName = branch.cond.name;
+    // Find the cmp instruction in the header
+    const cmpInstr = header.instrs.find(instr => instr.kind === 'cmp' && instr.dst === condName);
+    if (!cmpInstr)
+        return null;
+    // Must be a `lt` comparison: i < N
+    if (cmpInstr.op !== 'lt')
+        return null;
+    // Left operand must be a temp (the loop var), right must be a constant
+    if (cmpInstr.a.kind !== 'temp')
+        return null;
+    if (cmpInstr.b.kind !== 'const')
+        return null;
+    const loopVar = cmpInstr.a.name;
+    const N = cmpInstr.b.value;
+    // Reject if N > limit or N <= 0
+    if (N > UNROLL_LIMIT || N <= 0)
+        return null;
+    // then = loop_body, else = loop_exit
+    const bodyId = branch.then;
+    const exitId = branch.else;
+    const bodyBlock = blockMap.get(bodyId);
+    if (!bodyBlock)
+        return null;
+    if (!bodyBlock.id.startsWith('loop_body'))
+        return null;
+    // Body must end with jump to latch (or header if no latch)
+    if (bodyBlock.term.kind !== 'jump')
+        return null;
+    const afterBodyId = bodyBlock.term.target;
+    const afterBody = blockMap.get(afterBodyId);
+    if (!afterBody)
+        return null;
+    // Find the latch block
+    let latchId;
+    if (afterBody.id.startsWith('loop_latch')) {
+        latchId = afterBodyId;
+    }
+    else {
+        return null;
+    }
+    const latch = blockMap.get(latchId);
+    // Latch must end with jump back to header
+    if (latch.term.kind !== 'jump')
+        return null;
+    if (latch.term.target !== header.id)
+        return null;
+    // Latch must increment loopVar by 1
+    if (!latchIncrementsBy1(latch, loopVar))
+        return null;
+    // Loop var must be initialized to 0 before entering the loop
+    // Find the pre-header: the block that jumps to header (not the latch)
+    const preHeaderId = findPreHeader(fn, header.id, latchId);
+    if (!preHeaderId)
+        return null;
+    const preHeader = blockMap.get(preHeaderId);
+    if (!initializesTo0(preHeader, fn, loopVar))
+        return null;
+    // Body must not contain break (direct jump to exit) or continue to latch
+    // (those would require more complex handling)
+    if (bodyHasBreakOrContinue(bodyBlock, exitId, latchId))
+        return null;
+    return { headerId: header.id, bodyId, latchId, exitId, loopVar, N, preHeaderId };
+}
+/** Check that the latch increments loopVar by 1.
+ *
+ * Two common patterns:
+ *   1. Direct:  add loopVar loopVar 1
+ *   2. Two-step: add t_tmp loopVar 1; copy loopVar t_tmp
+ */
+function latchIncrementsBy1(latch, loopVar) {
+    // Pattern 1: add dst=loopVar, a=loopVar, b=const(1)
+    for (const instr of latch.instrs) {
+        if (instr.kind === 'add' &&
+            instr.dst === loopVar &&
+            instr.a.kind === 'temp' && instr.a.name === loopVar &&
+            instr.b.kind === 'const' && instr.b.value === 1) {
+            return true;
+        }
+    }
+    // Pattern 2: add t_tmp loopVar 1; copy loopVar t_tmp
+    // Find the copy that assigns loopVar, then check the add that produced the source
+    for (let i = 0; i < latch.instrs.length; i++) {
+        const instr = latch.instrs[i];
+        if (instr.kind === 'copy' &&
+            instr.dst === loopVar &&
+            instr.src.kind === 'temp') {
+            const srcTemp = instr.src.name;
+            // Find the add instruction that produced srcTemp
+            for (const addInstr of latch.instrs) {
+                if (addInstr.kind === 'add' &&
+                    addInstr.dst === srcTemp &&
+                    addInstr.a.kind === 'temp' && addInstr.a.name === loopVar &&
+                    addInstr.b.kind === 'const' && addInstr.b.value === 1) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/** Check if loopVar is initialized to 0 in the pre-header (or reachable const) */
+function initializesTo0(preHeader, fn, loopVar) {
+    // Check if last definition of loopVar in preHeader is const 0
+    for (let i = preHeader.instrs.length - 1; i >= 0; i--) {
+        const instr = preHeader.instrs[i];
+        if (instr.kind === 'const' && instr.dst === loopVar && instr.value === 0)
+            return true;
+        if (instr.kind === 'copy' && instr.dst === loopVar) {
+            return instr.src.kind === 'const' && instr.src.value === 0;
+        }
+        // If something else defines loopVar, it's not 0
+        if (getInstrDst(instr) === loopVar)
+            return false;
+    }
+    // Also check entry block if preHeader is entry
+    if (preHeader.id === fn.entry)
+        return false;
+    return false;
+}
+/** Find the pre-header block: the predecessor of header that is NOT the latch */
+function findPreHeader(fn, headerId, latchId) {
+    const preds = [];
+    for (const block of fn.blocks) {
+        const targets = getTermTargets(block.term);
+        if (targets.includes(headerId) && block.id !== latchId) {
+            preds.push(block.id);
+        }
+    }
+    return preds.length === 1 ? preds[0] : null;
+}
+/** Check if body block has break (jump to exit) or continue (jump to latch) */
+function bodyHasBreakOrContinue(body, exitId, latchId) {
+    // The normal path is body → latch. Any direct jump to exit = break,
+    // any jump to latch from within body sub-blocks = continue
+    // For simplicity, we only unroll if the body has no sub-blocks with these patterns.
+    // We only check the body block itself (single-block body).
+    // A multi-block body would need recursive checking.
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Unrolling
+// ---------------------------------------------------------------------------
+function unroll(fn, blockMap, info) {
+    const { headerId, bodyId, latchId, exitId, loopVar, N, preHeaderId } = info;
+    const preHeader = blockMap.get(preHeaderId);
+    const body = blockMap.get(bodyId);
+    // Remove the `const loopVar 0` init from preHeader
+    const newPreHeaderInstrs = preHeader.instrs.filter(instr => !(instr.kind === 'const' && instr.dst === loopVar && instr.value === 0) &&
+        !(instr.kind === 'copy' && instr.dst === loopVar &&
+            instr.src.kind === 'const' && instr.src.value === 0));
+    // Build N copies of the body with loopVar substituted
+    const unrolledInstrs = [];
+    for (let iter = 0; iter < N; iter++) {
+        const substitution = new Map([[loopVar, { kind: 'const', value: iter }]]);
+        for (const instr of body.instrs) {
+            unrolledInstrs.push(substituteInstr(instr, substitution));
+        }
+    }
+    // New pre-header: original instrs (minus init) + all unrolled body + jump to exit
+    const newPreHeader = {
+        ...preHeader,
+        instrs: [...newPreHeaderInstrs, ...unrolledInstrs],
+        term: { kind: 'jump', target: exitId },
+    };
+    // Remove header, body, latch blocks; update preHeader; keep exit
+    const keepIds = new Set(fn.blocks.map(b => b.id));
+    keepIds.delete(headerId);
+    keepIds.delete(bodyId);
+    keepIds.delete(latchId);
+    const newBlocks = [];
+    for (const block of fn.blocks) {
+        if (block.id === preHeaderId) {
+            newBlocks.push(newPreHeader);
+        }
+        else if (keepIds.has(block.id)) {
+            newBlocks.push(block);
+        }
+    }
+    // Recompute predecessors
+    const newBlocksWithPreds = recomputePreds(newBlocks);
+    return { ...fn, blocks: newBlocksWithPreds };
+}
+// ---------------------------------------------------------------------------
+// Instruction substitution
+// ---------------------------------------------------------------------------
+function substituteOp(op, sub) {
+    if (op.kind === 'temp') {
+        const replacement = sub.get(op.name);
+        if (replacement)
+            return replacement;
+    }
+    return op;
+}
+function substituteInstr(instr, sub) {
+    switch (instr.kind) {
+        case 'copy': return { ...instr, src: substituteOp(instr.src, sub) };
+        case 'neg':
+        case 'not': return { ...instr, src: substituteOp(instr.src, sub) };
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'and':
+        case 'or':
+            return { ...instr, a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) };
+        case 'cmp':
+            return { ...instr, a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) };
+        case 'nbt_write':
+            return { ...instr, src: substituteOp(instr.src, sub) };
+        case 'call':
+            return { ...instr, args: instr.args.map(a => substituteOp(a, sub)) };
+        case 'call_macro':
+            return { ...instr, args: instr.args.map(a => ({ ...a, value: substituteOp(a.value, sub) })) };
+        case 'branch':
+            return { ...instr, cond: substituteOp(instr.cond, sub) };
+        case 'return':
+            return { ...instr, value: instr.value ? substituteOp(instr.value, sub) : null };
+        default:
+            return instr;
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function getInstrDst(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;
+    }
+}
+function getTermTargets(term) {
+    switch (term.kind) {
+        case 'jump': return [term.target];
+        case 'branch': return [term.then, term.else];
+        default: return [];
+    }
+}
+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) ?? [] }));
+}
+//# sourceMappingURL=unroll.js.map

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

@@ -31,6 +31,8 @@ export declare class Parser {
     private parseImplBlock;
     private parseConstDecl;
     private parseGlobalDecl;
+    /** Parse `export fn name(...)` — marks the function as exported (survives DCE). */
+    private parseExportedFnDecl;
     private parseFnDecl;
     /** Parse a `declare fn name(params): returnType;` stub — no body, just discard. */
     private parseDeclareStub;
@@ -63,6 +65,12 @@ export declare class Parser {
     private parseUnaryExpr;
     private parseEntityTypeName;
     private isSubtraction;
+    /**
+     * Try to parse `<Type, ...>` as explicit generic type arguments.
+     * Returns the parsed type list if successful, null if this looks like a comparison.
+     * Does NOT consume any tokens if it returns null.
+     */
+    private tryParseTypeArgs;
     private parsePostfixExpr;
     private parseArgs;
     private parsePrimaryExpr;