redscript-mc 2.6.2 → 3.0.0

package/dist/src/mir/macro.js

@@ -21,6 +21,19 @@ exports.BUILTIN_SET = new Set([
     'summon', 'particle', 'playsound', 'clear', 'weather',
     'time_set', 'time_add', 'gamerule', 'tag_add', 'tag_remove',
     'kick', 'setblock', 'fill', 'clone', 'difficulty', 'xp_add', 'xp_set',
+    // Entity movement / teleport
+    'tp', 'tp_to',
+    // Scoreboard management
+    'scoreboard_add_objective', 'scoreboard_remove_objective',
+    'scoreboard_display', 'scoreboard_hide',
+    // Team management
+    'team_add', 'team_remove', 'team_join', 'team_leave', 'team_option',
+    // Bossbar management
+    'bossbar_add', 'bossbar_remove', 'bossbar_set_value', 'bossbar_get_value',
+    'bossbar_set_max', 'bossbar_set_color', 'bossbar_set_style',
+    'bossbar_set_visible', 'bossbar_set_players',
+    // Data / NBT
+    'data_get', 'data_merge',
 ]);
 /**
  * Pre-scan HIR functions to detect which params need macro treatment.
@@ -35,7 +48,16 @@ function detectMacroFunctions(hir) {
         if (macroParams.size > 0) {
             const paramTypes = new Map();
             for (const p of fn.params) {
-                const typeName = p.type?.kind === 'named' ? p.type.name : 'int';
+                let typeName;
+                if (p.type?.kind === 'named') {
+                    typeName = p.type.name;
+                }
+                else if (p.type?.kind === 'selector' || p.type?.kind === 'entity') {
+                    typeName = 'selector';
+                }
+                else {
+                    typeName = 'int';
+                }
                 paramTypes.set(p.name, typeName);
             }
             result.set(fn.name, { macroParams, paramTypes });
@@ -49,7 +71,16 @@ function detectMacroFunctions(hir) {
             if (macroParams.size > 0) {
                 const paramTypes = new Map();
                 for (const p of m.params) {
-                    const typeName = p.type?.kind === 'named' ? p.type.name : 'int';
+                    let typeName;
+                    if (p.type?.kind === 'named') {
+                        typeName = p.type.name;
+                    }
+                    else if (p.type?.kind === 'selector' || p.type?.kind === 'entity') {
+                        typeName = 'selector';
+                    }
+                    else {
+                        typeName = 'int';
+                    }
                     paramTypes.set(p.name, typeName);
                 }
                 result.set(`${ib.typeName}::${m.name}`, { macroParams, paramTypes });
@@ -100,6 +131,9 @@ function scanStmt(stmt, paramNames, macroParams) {
         case 'execute':
             scanBlock(stmt.body, paramNames, macroParams);
             break;
+        case 'labeled_loop':
+            scanStmt(stmt.body, paramNames, macroParams);
+            break;
         case 'raw': break;
     }
 }

package/dist/src/mir/types.d.ts

@@ -110,6 +110,12 @@ export type MIRInstr = MIRInstrBase & ({
     op: CmpOp;
     a: Operand;
     b: Operand;
+} | {
+    kind: 'string_match';
+    dst: Temp;
+    ns: string;
+    path: string;
+    value: string;
 } | {
     kind: 'and';
     dst: Temp;
@@ -210,9 +216,15 @@ export interface MIRFunction {
     blocks: MIRBlock[];
     entry: BlockId;
     isMacro: boolean;
+    sourceLoc?: SourceLoc;
+    sourceSnippet?: string;
 }
 export interface MIRModule {
     functions: MIRFunction[];
     namespace: string;
     objective: string;
+    /** Set of fully-qualified function names marked @inline. */
+    inlineFunctions?: Set<string>;
+    /** Set of fully-qualified function names marked @no-inline. */
+    noInlineFunctions?: Set<string>;
 }

package/dist/src/mir/verify.js

@@ -94,6 +94,12 @@ function verifyFunction(fn) {
     const allDefs = new Set();
     for (const p of fn.params)
         allDefs.add(p.name);
+    // __rf_* temps are "return frame" slots set by the callee at runtime.
+    // Pre-seed them so the verifier doesn't false-positive on caller reads.
+    for (let i = 0; i < 16; i++)
+        allDefs.add(`__rf_${i}`);
+    allDefs.add('__rf_has');
+    allDefs.add('__rf_val');
     for (const block of fn.blocks) {
         for (const instr of block.instrs) {
             const dst = getDst(instr);
@@ -151,6 +157,7 @@ function getDst(instr) {
         case 'mod':
         case 'neg':
         case 'cmp':
+        case 'string_match':
         case 'and':
         case 'or':
         case 'not':
@@ -188,6 +195,8 @@ function getUsedTemps(instr) {
         case 'or':
             temps.push(...getOperandTemps(instr.a), ...getOperandTemps(instr.b));
             break;
+        case 'string_match':
+            break;
         case 'nbt_read':
         case 'nbt_list_len':
             break;

package/dist/src/optimizer/auto-inline.d.ts

@@ -0,0 +1,2 @@
+import type { MIRModule } from '../mir/types';
+export declare function autoInlineSmallFunctions(mod: MIRModule): MIRModule;

package/dist/src/optimizer/auto-inline.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoInlineSmallFunctions = autoInlineSmallFunctions;
+const inline_1 = require("./inline");
+const SMALL_FUNCTION_INSTR_LIMIT = 5;
+function autoInlineSmallFunctions(mod) {
+    const recursiveFns = findRecursiveFunctions(mod.functions);
+    const noInlineFns = mod.noInlineFunctions ?? new Set();
+    const autoInlineFns = new Set();
+    for (const fn of mod.functions) {
+        if (fn.isMacro)
+            continue;
+        if (noInlineFns.has(fn.name))
+            continue;
+        if (recursiveFns.has(fn.name))
+            continue;
+        if (countFunctionInstrs(fn) > SMALL_FUNCTION_INSTR_LIMIT)
+            continue;
+        autoInlineFns.add(fn.name);
+    }
+    const inlineFunctions = new Set(mod.inlineFunctions ?? []);
+    for (const fnName of autoInlineFns)
+        inlineFunctions.add(fnName);
+    return (0, inline_1.inlinePass)({ ...mod, inlineFunctions });
+}
+function countFunctionInstrs(fn) {
+    let count = 0;
+    for (const block of fn.blocks) {
+        count += block.instrs.length + 1;
+    }
+    return count;
+}
+function findRecursiveFunctions(functions) {
+    const fnNames = new Set(functions.map(fn => fn.name));
+    const edges = new Map();
+    for (const fn of functions) {
+        const callees = new Set();
+        for (const block of fn.blocks) {
+            for (const instr of block.instrs) {
+                if ((instr.kind === 'call' || instr.kind === 'call_macro') && fnNames.has(instr.fn)) {
+                    callees.add(instr.fn);
+                }
+            }
+        }
+        edges.set(fn.name, callees);
+    }
+    const recursive = new Set();
+    for (const fn of functions) {
+        const seen = new Set();
+        const stack = [...(edges.get(fn.name) ?? [])];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (current === fn.name) {
+                recursive.add(fn.name);
+                break;
+            }
+            if (seen.has(current))
+                continue;
+            seen.add(current);
+            for (const next of edges.get(current) ?? []) {
+                stack.push(next);
+            }
+        }
+    }
+    return recursive;
+}
+//# sourceMappingURL=auto-inline.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * Common Subexpression Elimination (CSE) — MIR optimization pass.
+ *
+ * Performs local (intra-block) CSE: within each BasicBlock, if a pure
+ * computation has already been computed and its operands haven't been
+ * overwritten since, reuse the previous result via a `copy` instead of
+ * recomputing.
+ *
+ * Pure instructions considered:
+ *   add, sub, mul, div, mod, neg, cmp, and, or, not
+ *
+ * Side-effect instructions that invalidate expressions when their
+ * destination (or any operand) is overwritten:
+ *   score_write, nbt_write, nbt_write_dynamic, call, call_macro,
+ *   call_context, and any instruction that redefines a temp.
+ *
+ * Global (cross-block) CSE is not performed — only per-block.
+ */
+import type { MIRFunction } from '../mir/types';
+export declare function cse(fn: MIRFunction): MIRFunction;

package/dist/src/optimizer/cse.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Common Subexpression Elimination (CSE) — MIR optimization pass.
+ *
+ * Performs local (intra-block) CSE: within each BasicBlock, if a pure
+ * computation has already been computed and its operands haven't been
+ * overwritten since, reuse the previous result via a `copy` instead of
+ * recomputing.
+ *
+ * Pure instructions considered:
+ *   add, sub, mul, div, mod, neg, cmp, and, or, not
+ *
+ * Side-effect instructions that invalidate expressions when their
+ * destination (or any operand) is overwritten:
+ *   score_write, nbt_write, nbt_write_dynamic, call, call_macro,
+ *   call_context, and any instruction that redefines a temp.
+ *
+ * Global (cross-block) CSE is not performed — only per-block.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cse = cse;
+// ---------------------------------------------------------------------------
+// Expression key helpers
+// ---------------------------------------------------------------------------
+function operandKey(op) {
+    return op.kind === 'const' ? `c:${op.value}` : `t:${op.name}`;
+}
+/** Commutative ops — operand order doesn't matter. */
+const COMMUTATIVE = new Set(['add', 'mul', 'and', 'or']);
+function exprKey(instr) {
+    switch (instr.kind) {
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'and':
+        case 'or': {
+            const ka = operandKey(instr.a);
+            const kb = operandKey(instr.b);
+            const [l, r] = COMMUTATIVE.has(instr.kind) && ka > kb ? [kb, ka] : [ka, kb];
+            return `${instr.kind}:${l}:${r}`;
+        }
+        case 'neg':
+        case 'not':
+            return `${instr.kind}:${operandKey(instr.src)}`;
+        case 'cmp': {
+            const ka = operandKey(instr.a);
+            const kb = operandKey(instr.b);
+            return `cmp:${instr.op}:${ka}:${kb}`;
+        }
+        default:
+            return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Temp defined by an instruction
+// ---------------------------------------------------------------------------
+function getDst(instr) {
+    switch (instr.kind) {
+        case 'const':
+        case 'copy':
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'neg':
+        case 'not':
+        case 'and':
+        case 'or':
+        case 'cmp':
+        case 'string_match':
+        case 'nbt_read':
+        case 'nbt_read_dynamic':
+        case 'nbt_list_len':
+        case 'score_read':
+            return instr.dst;
+        case 'call':
+        case 'call_macro':
+            return instr.dst;
+        default:
+            return null;
+    }
+}
+/** Temps used as operands in an instruction (for invalidation). */
+function getUsedTemps(instr) {
+    const temps = [];
+    const add = (op) => { if (op.kind === 'temp')
+        temps.push(op.name); };
+    switch (instr.kind) {
+        case 'copy':
+            add(instr.src);
+            break;
+        case 'neg':
+        case 'not':
+            add(instr.src);
+            break;
+        case 'add':
+        case 'sub':
+        case 'mul':
+        case 'div':
+        case 'mod':
+        case 'and':
+        case 'or':
+            add(instr.a);
+            add(instr.b);
+            break;
+        case 'cmp':
+            add(instr.a);
+            add(instr.b);
+            break;
+        case 'nbt_write':
+            add(instr.src);
+            break;
+        case 'nbt_write_dynamic':
+            add(instr.indexSrc);
+            add(instr.valueSrc);
+            break;
+        case 'nbt_read_dynamic':
+            add(instr.indexSrc);
+            break;
+        case 'score_write':
+            add(instr.src);
+            break;
+        case 'call':
+            instr.args.forEach(add);
+            break;
+        case 'call_macro':
+            instr.args.forEach(a => add(a.value));
+            break;
+        case 'branch':
+            add(instr.cond);
+            break;
+        case 'return':
+            if (instr.value)
+                add(instr.value);
+            break;
+        case 'jump': break;
+    }
+    return temps;
+}
+// ---------------------------------------------------------------------------
+// Block-level CSE
+// ---------------------------------------------------------------------------
+function cseBlock(block) {
+    // Map: expression key → temp holding the already-computed result
+    const available = new Map();
+    // Map: temp → set of expression keys that depend on it (for invalidation)
+    const tempDeps = new Map();
+    function recordDep(key, deps) {
+        for (const dep of deps) {
+            if (!tempDeps.has(dep))
+                tempDeps.set(dep, new Set());
+            tempDeps.get(dep).add(key);
+        }
+    }
+    function invalidate(temp) {
+        // Remove all expressions that depend on this temp
+        const keys = tempDeps.get(temp);
+        if (keys) {
+            for (const key of keys) {
+                available.delete(key);
+            }
+            tempDeps.delete(temp);
+        }
+        // Also remove any expression whose result was stored in this temp
+        for (const [key, resultTemp] of available) {
+            if (resultTemp === temp) {
+                available.delete(key);
+            }
+        }
+    }
+    const instrs = [];
+    for (const instr of block.instrs) {
+        const key = exprKey(instr);
+        if (key !== null) {
+            const existing = available.get(key);
+            if (existing !== undefined) {
+                // Replace with a copy from the already-computed temp
+                const dst = getDst(instr);
+                instrs.push({ kind: 'copy', dst, src: { kind: 'temp', name: existing } });
+                // Don't update available[key] — the original mapping stays valid
+                // But do invalidate any previous mapping for dst if it existed
+                invalidate(dst);
+                // Record dst as another name for the result (through copy)
+                // No need to add to available again; the original key still maps to existing
+                continue;
+            }
+        }
+        // Process instruction normally
+        const dst = getDst(instr);
+        if (dst !== null) {
+            // Invalidate expressions that used the old value of dst
+            invalidate(dst);
+        }
+        if (key !== null && dst !== null) {
+            // Record this new expression
+            available.set(key, dst);
+            // Track which temps this expression depends on
+            const deps = getUsedTemps(instr);
+            recordDep(key, deps);
+        }
+        else if (
+        // Side-effect instructions that may alias-write through external state:
+        // call, call_macro, call_context, score_write, nbt_write, nbt_write_dynamic
+        // These don't define a Temp dst we can track, but they invalidate expressions
+        // that read from the same external state. For safety, clear all non-temp
+        // expressions (conservative approach for local CSE).
+        instr.kind === 'call' ||
+            instr.kind === 'call_macro' ||
+            instr.kind === 'call_context' ||
+            instr.kind === 'score_write' ||
+            instr.kind === 'nbt_write' ||
+            instr.kind === 'nbt_write_dynamic') {
+            // For calls and writes, we conservatively clear ALL available expressions
+            // since they may have side effects or alias effects we can't track locally.
+            available.clear();
+            tempDeps.clear();
+        }
+        instrs.push(instr);
+    }
+    return { ...block, instrs };
+}
+// ---------------------------------------------------------------------------
+// Public pass entry point
+// ---------------------------------------------------------------------------
+function cse(fn) {
+    return {
+        ...fn,
+        blocks: fn.blocks.map(cseBlock),
+    };
+}
+//# sourceMappingURL=cse.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * @inline Decorator — MIR-level function inlining pass.
+ *
+ * For each call instruction where the callee is marked @inline in the module's
+ * `inlineFunctions` set, replaces the call with a copy of the callee's CFG:
+ *
+ *   1. Clone all callee blocks with fresh names (prefixed by a unique inline ID).
+ *   2. Substitute formal parameters with the actual argument operands.
+ *   3. Replace every `return` terminator with a `jump` to a new continuation block.
+ *      The return value (if any) is copied into the call's dst temp via a `copy`.
+ *   4. Replace the original call instruction with a `jump` to the inlined entry block.
+ *   5. Move all instructions that followed the call into the continuation block.
+ *
+ * Constraints (inlining is skipped when violated):
+ *   - Callee must be in `mod.inlineFunctions`.
+ *   - Callee must exist in the module (no external calls).
+ *   - Callee must not be a macro function.
+ *   - Callee must not be directly recursive.
+ *   - Callee arg count must match param count.
+ *
+ * This is a module-level pass because it needs to read callee bodies.
+ */
+import type { MIRModule, MIRFunction } from '../mir/types';
+export declare function inlinePass(mod: MIRModule): MIRModule;
+export declare function inlineSelectedFunctions(mod: MIRModule, inlineSet?: ReadonlySet<string>): MIRModule;
+export declare function findRecursiveFunctions(functions: MIRFunction[]): Set<string>;